Release Apis of Version 2019-09-10.

CHANGELOG

@@ -1,3 +1,6 @@
+2019-08-30 Version 1.36.102
+- Release Apis of Version 2019-09-10.
+
 2019-08-30 Version 1.36.101
 - Supported Meida complex for IMM.
 

VERSION

@@ -1 +1 @@
-1.36.101
+1.36.102

ros/include/alibabacloud/ros/ROSClient.h

@@ -0,0 +1,254 @@
+/*
+ * 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_ROS_ROSCLIENT_H_
+#define ALIBABACLOUD_ROS_ROSCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "ROSExport.h"
+#include "model/ListStacksRequest.h"
+#include "model/ListStacksResult.h"
+#include "model/GetChangeSetRequest.h"
+#include "model/GetChangeSetResult.h"
+#include "model/ValidateTemplateRequest.h"
+#include "model/ValidateTemplateResult.h"
+#include "model/UpdateStackRequest.h"
+#include "model/UpdateStackResult.h"
+#include "model/GetStackResourceRequest.h"
+#include "model/GetStackResourceResult.h"
+#include "model/ListResourceTypesRequest.h"
+#include "model/ListResourceTypesResult.h"
+#include "model/DescribeRegionsRequest.h"
+#include "model/DescribeRegionsResult.h"
+#include "model/GetResourceTypeTemplateRequest.h"
+#include "model/GetResourceTypeTemplateResult.h"
+#include "model/CreateStackRequest.h"
+#include "model/CreateStackResult.h"
+#include "model/DeleteStackRequest.h"
+#include "model/DeleteStackResult.h"
+#include "model/GetTemplateEstimateCostRequest.h"
+#include "model/GetTemplateEstimateCostResult.h"
+#include "model/ContinueCreateStackRequest.h"
+#include "model/ContinueCreateStackResult.h"
+#include "model/GetResourceTypeRequest.h"
+#include "model/GetResourceTypeResult.h"
+#include "model/DeleteChangeSetRequest.h"
+#include "model/DeleteChangeSetResult.h"
+#include "model/PreviewStackRequest.h"
+#include "model/PreviewStackResult.h"
+#include "model/SignalResourceRequest.h"
+#include "model/SignalResourceResult.h"
+#include "model/ExecuteChangeSetRequest.h"
+#include "model/ExecuteChangeSetResult.h"
+#include "model/SetStackPolicyRequest.h"
+#include "model/SetStackPolicyResult.h"
+#include "model/CreateChangeSetRequest.h"
+#include "model/CreateChangeSetResult.h"
+#include "model/GetTemplateRequest.h"
+#include "model/GetTemplateResult.h"
+#include "model/ListStackEventsRequest.h"
+#include "model/ListStackEventsResult.h"
+#include "model/GetStackRequest.h"
+#include "model/GetStackResult.h"
+#include "model/GetStackPolicyRequest.h"
+#include "model/GetStackPolicyResult.h"
+#include "model/CancelUpdateStackRequest.h"
+#include "model/CancelUpdateStackResult.h"
+#include "model/ListStackResourcesRequest.h"
+#include "model/ListStackResourcesResult.h"
+#include "model/ListChangeSetsRequest.h"
+#include "model/ListChangeSetsResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		class ALIBABACLOUD_ROS_EXPORT ROSClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::ListStacksResult> ListStacksOutcome;
+			typedef std::future<ListStacksOutcome> ListStacksOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::ListStacksRequest&, const ListStacksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListStacksAsyncHandler;
+			typedef Outcome<Error, Model::GetChangeSetResult> GetChangeSetOutcome;
+			typedef std::future<GetChangeSetOutcome> GetChangeSetOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::GetChangeSetRequest&, const GetChangeSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetChangeSetAsyncHandler;
+			typedef Outcome<Error, Model::ValidateTemplateResult> ValidateTemplateOutcome;
+			typedef std::future<ValidateTemplateOutcome> ValidateTemplateOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::ValidateTemplateRequest&, const ValidateTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ValidateTemplateAsyncHandler;
+			typedef Outcome<Error, Model::UpdateStackResult> UpdateStackOutcome;
+			typedef std::future<UpdateStackOutcome> UpdateStackOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::UpdateStackRequest&, const UpdateStackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateStackAsyncHandler;
+			typedef Outcome<Error, Model::GetStackResourceResult> GetStackResourceOutcome;
+			typedef std::future<GetStackResourceOutcome> GetStackResourceOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::GetStackResourceRequest&, const GetStackResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetStackResourceAsyncHandler;
+			typedef Outcome<Error, Model::ListResourceTypesResult> ListResourceTypesOutcome;
+			typedef std::future<ListResourceTypesOutcome> ListResourceTypesOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::ListResourceTypesRequest&, const ListResourceTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListResourceTypesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
+			typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
+			typedef Outcome<Error, Model::GetResourceTypeTemplateResult> GetResourceTypeTemplateOutcome;
+			typedef std::future<GetResourceTypeTemplateOutcome> GetResourceTypeTemplateOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::GetResourceTypeTemplateRequest&, const GetResourceTypeTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetResourceTypeTemplateAsyncHandler;
+			typedef Outcome<Error, Model::CreateStackResult> CreateStackOutcome;
+			typedef std::future<CreateStackOutcome> CreateStackOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::CreateStackRequest&, const CreateStackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateStackAsyncHandler;
+			typedef Outcome<Error, Model::DeleteStackResult> DeleteStackOutcome;
+			typedef std::future<DeleteStackOutcome> DeleteStackOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::DeleteStackRequest&, const DeleteStackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteStackAsyncHandler;
+			typedef Outcome<Error, Model::GetTemplateEstimateCostResult> GetTemplateEstimateCostOutcome;
+			typedef std::future<GetTemplateEstimateCostOutcome> GetTemplateEstimateCostOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::GetTemplateEstimateCostRequest&, const GetTemplateEstimateCostOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTemplateEstimateCostAsyncHandler;
+			typedef Outcome<Error, Model::ContinueCreateStackResult> ContinueCreateStackOutcome;
+			typedef std::future<ContinueCreateStackOutcome> ContinueCreateStackOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::ContinueCreateStackRequest&, const ContinueCreateStackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ContinueCreateStackAsyncHandler;
+			typedef Outcome<Error, Model::GetResourceTypeResult> GetResourceTypeOutcome;
+			typedef std::future<GetResourceTypeOutcome> GetResourceTypeOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::GetResourceTypeRequest&, const GetResourceTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetResourceTypeAsyncHandler;
+			typedef Outcome<Error, Model::DeleteChangeSetResult> DeleteChangeSetOutcome;
+			typedef std::future<DeleteChangeSetOutcome> DeleteChangeSetOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::DeleteChangeSetRequest&, const DeleteChangeSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteChangeSetAsyncHandler;
+			typedef Outcome<Error, Model::PreviewStackResult> PreviewStackOutcome;
+			typedef std::future<PreviewStackOutcome> PreviewStackOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::PreviewStackRequest&, const PreviewStackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PreviewStackAsyncHandler;
+			typedef Outcome<Error, Model::SignalResourceResult> SignalResourceOutcome;
+			typedef std::future<SignalResourceOutcome> SignalResourceOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::SignalResourceRequest&, const SignalResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SignalResourceAsyncHandler;
+			typedef Outcome<Error, Model::ExecuteChangeSetResult> ExecuteChangeSetOutcome;
+			typedef std::future<ExecuteChangeSetOutcome> ExecuteChangeSetOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::ExecuteChangeSetRequest&, const ExecuteChangeSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExecuteChangeSetAsyncHandler;
+			typedef Outcome<Error, Model::SetStackPolicyResult> SetStackPolicyOutcome;
+			typedef std::future<SetStackPolicyOutcome> SetStackPolicyOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::SetStackPolicyRequest&, const SetStackPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetStackPolicyAsyncHandler;
+			typedef Outcome<Error, Model::CreateChangeSetResult> CreateChangeSetOutcome;
+			typedef std::future<CreateChangeSetOutcome> CreateChangeSetOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::CreateChangeSetRequest&, const CreateChangeSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateChangeSetAsyncHandler;
+			typedef Outcome<Error, Model::GetTemplateResult> GetTemplateOutcome;
+			typedef std::future<GetTemplateOutcome> GetTemplateOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::GetTemplateRequest&, const GetTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTemplateAsyncHandler;
+			typedef Outcome<Error, Model::ListStackEventsResult> ListStackEventsOutcome;
+			typedef std::future<ListStackEventsOutcome> ListStackEventsOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::ListStackEventsRequest&, const ListStackEventsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListStackEventsAsyncHandler;
+			typedef Outcome<Error, Model::GetStackResult> GetStackOutcome;
+			typedef std::future<GetStackOutcome> GetStackOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::GetStackRequest&, const GetStackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetStackAsyncHandler;
+			typedef Outcome<Error, Model::GetStackPolicyResult> GetStackPolicyOutcome;
+			typedef std::future<GetStackPolicyOutcome> GetStackPolicyOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::GetStackPolicyRequest&, const GetStackPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetStackPolicyAsyncHandler;
+			typedef Outcome<Error, Model::CancelUpdateStackResult> CancelUpdateStackOutcome;
+			typedef std::future<CancelUpdateStackOutcome> CancelUpdateStackOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::CancelUpdateStackRequest&, const CancelUpdateStackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CancelUpdateStackAsyncHandler;
+			typedef Outcome<Error, Model::ListStackResourcesResult> ListStackResourcesOutcome;
+			typedef std::future<ListStackResourcesOutcome> ListStackResourcesOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::ListStackResourcesRequest&, const ListStackResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListStackResourcesAsyncHandler;
+			typedef Outcome<Error, Model::ListChangeSetsResult> ListChangeSetsOutcome;
+			typedef std::future<ListChangeSetsOutcome> ListChangeSetsOutcomeCallable;
+			typedef std::function<void(const ROSClient*, const Model::ListChangeSetsRequest&, const ListChangeSetsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListChangeSetsAsyncHandler;
+
+			ROSClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			ROSClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			ROSClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~ROSClient();
+			ListStacksOutcome listStacks(const Model::ListStacksRequest &request)const;
+			void listStacksAsync(const Model::ListStacksRequest& request, const ListStacksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListStacksOutcomeCallable listStacksCallable(const Model::ListStacksRequest& request) const;
+			GetChangeSetOutcome getChangeSet(const Model::GetChangeSetRequest &request)const;
+			void getChangeSetAsync(const Model::GetChangeSetRequest& request, const GetChangeSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetChangeSetOutcomeCallable getChangeSetCallable(const Model::GetChangeSetRequest& request) const;
+			ValidateTemplateOutcome validateTemplate(const Model::ValidateTemplateRequest &request)const;
+			void validateTemplateAsync(const Model::ValidateTemplateRequest& request, const ValidateTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ValidateTemplateOutcomeCallable validateTemplateCallable(const Model::ValidateTemplateRequest& request) const;
+			UpdateStackOutcome updateStack(const Model::UpdateStackRequest &request)const;
+			void updateStackAsync(const Model::UpdateStackRequest& request, const UpdateStackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateStackOutcomeCallable updateStackCallable(const Model::UpdateStackRequest& request) const;
+			GetStackResourceOutcome getStackResource(const Model::GetStackResourceRequest &request)const;
+			void getStackResourceAsync(const Model::GetStackResourceRequest& request, const GetStackResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetStackResourceOutcomeCallable getStackResourceCallable(const Model::GetStackResourceRequest& request) const;
+			ListResourceTypesOutcome listResourceTypes(const Model::ListResourceTypesRequest &request)const;
+			void listResourceTypesAsync(const Model::ListResourceTypesRequest& request, const ListResourceTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListResourceTypesOutcomeCallable listResourceTypesCallable(const Model::ListResourceTypesRequest& request) const;
+			DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
+			void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
+			GetResourceTypeTemplateOutcome getResourceTypeTemplate(const Model::GetResourceTypeTemplateRequest &request)const;
+			void getResourceTypeTemplateAsync(const Model::GetResourceTypeTemplateRequest& request, const GetResourceTypeTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetResourceTypeTemplateOutcomeCallable getResourceTypeTemplateCallable(const Model::GetResourceTypeTemplateRequest& request) const;
+			CreateStackOutcome createStack(const Model::CreateStackRequest &request)const;
+			void createStackAsync(const Model::CreateStackRequest& request, const CreateStackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateStackOutcomeCallable createStackCallable(const Model::CreateStackRequest& request) const;
+			DeleteStackOutcome deleteStack(const Model::DeleteStackRequest &request)const;
+			void deleteStackAsync(const Model::DeleteStackRequest& request, const DeleteStackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteStackOutcomeCallable deleteStackCallable(const Model::DeleteStackRequest& request) const;
+			GetTemplateEstimateCostOutcome getTemplateEstimateCost(const Model::GetTemplateEstimateCostRequest &request)const;
+			void getTemplateEstimateCostAsync(const Model::GetTemplateEstimateCostRequest& request, const GetTemplateEstimateCostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetTemplateEstimateCostOutcomeCallable getTemplateEstimateCostCallable(const Model::GetTemplateEstimateCostRequest& request) const;
+			ContinueCreateStackOutcome continueCreateStack(const Model::ContinueCreateStackRequest &request)const;
+			void continueCreateStackAsync(const Model::ContinueCreateStackRequest& request, const ContinueCreateStackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ContinueCreateStackOutcomeCallable continueCreateStackCallable(const Model::ContinueCreateStackRequest& request) const;
+			GetResourceTypeOutcome getResourceType(const Model::GetResourceTypeRequest &request)const;
+			void getResourceTypeAsync(const Model::GetResourceTypeRequest& request, const GetResourceTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetResourceTypeOutcomeCallable getResourceTypeCallable(const Model::GetResourceTypeRequest& request) const;
+			DeleteChangeSetOutcome deleteChangeSet(const Model::DeleteChangeSetRequest &request)const;
+			void deleteChangeSetAsync(const Model::DeleteChangeSetRequest& request, const DeleteChangeSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteChangeSetOutcomeCallable deleteChangeSetCallable(const Model::DeleteChangeSetRequest& request) const;
+			PreviewStackOutcome previewStack(const Model::PreviewStackRequest &request)const;
+			void previewStackAsync(const Model::PreviewStackRequest& request, const PreviewStackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PreviewStackOutcomeCallable previewStackCallable(const Model::PreviewStackRequest& request) const;
+			SignalResourceOutcome signalResource(const Model::SignalResourceRequest &request)const;
+			void signalResourceAsync(const Model::SignalResourceRequest& request, const SignalResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SignalResourceOutcomeCallable signalResourceCallable(const Model::SignalResourceRequest& request) const;
+			ExecuteChangeSetOutcome executeChangeSet(const Model::ExecuteChangeSetRequest &request)const;
+			void executeChangeSetAsync(const Model::ExecuteChangeSetRequest& request, const ExecuteChangeSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ExecuteChangeSetOutcomeCallable executeChangeSetCallable(const Model::ExecuteChangeSetRequest& request) const;
+			SetStackPolicyOutcome setStackPolicy(const Model::SetStackPolicyRequest &request)const;
+			void setStackPolicyAsync(const Model::SetStackPolicyRequest& request, const SetStackPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetStackPolicyOutcomeCallable setStackPolicyCallable(const Model::SetStackPolicyRequest& request) const;
+			CreateChangeSetOutcome createChangeSet(const Model::CreateChangeSetRequest &request)const;
+			void createChangeSetAsync(const Model::CreateChangeSetRequest& request, const CreateChangeSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateChangeSetOutcomeCallable createChangeSetCallable(const Model::CreateChangeSetRequest& request) const;
+			GetTemplateOutcome getTemplate(const Model::GetTemplateRequest &request)const;
+			void getTemplateAsync(const Model::GetTemplateRequest& request, const GetTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetTemplateOutcomeCallable getTemplateCallable(const Model::GetTemplateRequest& request) const;
+			ListStackEventsOutcome listStackEvents(const Model::ListStackEventsRequest &request)const;
+			void listStackEventsAsync(const Model::ListStackEventsRequest& request, const ListStackEventsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListStackEventsOutcomeCallable listStackEventsCallable(const Model::ListStackEventsRequest& request) const;
+			GetStackOutcome getStack(const Model::GetStackRequest &request)const;
+			void getStackAsync(const Model::GetStackRequest& request, const GetStackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetStackOutcomeCallable getStackCallable(const Model::GetStackRequest& request) const;
+			GetStackPolicyOutcome getStackPolicy(const Model::GetStackPolicyRequest &request)const;
+			void getStackPolicyAsync(const Model::GetStackPolicyRequest& request, const GetStackPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetStackPolicyOutcomeCallable getStackPolicyCallable(const Model::GetStackPolicyRequest& request) const;
+			CancelUpdateStackOutcome cancelUpdateStack(const Model::CancelUpdateStackRequest &request)const;
+			void cancelUpdateStackAsync(const Model::CancelUpdateStackRequest& request, const CancelUpdateStackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CancelUpdateStackOutcomeCallable cancelUpdateStackCallable(const Model::CancelUpdateStackRequest& request) const;
+			ListStackResourcesOutcome listStackResources(const Model::ListStackResourcesRequest &request)const;
+			void listStackResourcesAsync(const Model::ListStackResourcesRequest& request, const ListStackResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListStackResourcesOutcomeCallable listStackResourcesCallable(const Model::ListStackResourcesRequest& request) const;
+			ListChangeSetsOutcome listChangeSets(const Model::ListChangeSetsRequest &request)const;
+			void listChangeSetsAsync(const Model::ListChangeSetsRequest& request, const ListChangeSetsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListChangeSetsOutcomeCallable listChangeSetsCallable(const Model::ListChangeSetsRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_ROS_ROSCLIENT_H_

ros/include/alibabacloud/ros/ROSExport.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_ROS_ROSEXPORT_H_
+#define ALIBABACLOUD_ROS_ROSEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_ROS_LIBRARY)
+#		define ALIBABACLOUD_ROS_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_ROS_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_ROS_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_ROS_ROSEXPORT_H_

ros/include/alibabacloud/ros/model/CancelUpdateStackRequest.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_ROS_MODEL_CANCELUPDATESTACKREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_CANCELUPDATESTACKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT CancelUpdateStackRequest : public RpcServiceRequest
+			{
+
+			public:
+				CancelUpdateStackRequest();
+				~CancelUpdateStackRequest();
+
+				std::string getCancelType()const;
+				void setCancelType(const std::string& cancelType);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getStackId()const;
+				void setStackId(const std::string& stackId);
+
+            private:
+				std::string cancelType_;
+				std::string regionId_;
+				std::string stackId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_CANCELUPDATESTACKREQUEST_H_

ros/include/alibabacloud/ros/model/CancelUpdateStackResult.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_ROS_MODEL_CANCELUPDATESTACKRESULT_H_
+#define ALIBABACLOUD_ROS_MODEL_CANCELUPDATESTACKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT CancelUpdateStackResult : public ServiceResult
+			{
+			public:
+
+
+				CancelUpdateStackResult();
+				explicit CancelUpdateStackResult(const std::string &payload);
+				~CancelUpdateStackResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_CANCELUPDATESTACKRESULT_H_

ros/include/alibabacloud/ros/model/ContinueCreateStackRequest.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_ROS_MODEL_CONTINUECREATESTACKREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_CONTINUECREATESTACKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT ContinueCreateStackRequest : public RpcServiceRequest
+			{
+
+			public:
+				ContinueCreateStackRequest();
+				~ContinueCreateStackRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getStackId()const;
+				void setStackId(const std::string& stackId);
+				std::vector<std::string> getRecreatingResources()const;
+				void setRecreatingResources(const std::vector<std::string>& recreatingResources);
+
+            private:
+				std::string regionId_;
+				std::string stackId_;
+				std::vector<std::string> recreatingResources_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_CONTINUECREATESTACKREQUEST_H_

ros/include/alibabacloud/ros/model/ContinueCreateStackResult.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_ROS_MODEL_CONTINUECREATESTACKRESULT_H_
+#define ALIBABACLOUD_ROS_MODEL_CONTINUECREATESTACKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT ContinueCreateStackResult : public ServiceResult
+			{
+			public:
+
+
+				ContinueCreateStackResult();
+				explicit ContinueCreateStackResult(const std::string &payload);
+				~ContinueCreateStackResult();
+				std::string getStackId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string stackId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_CONTINUECREATESTACKRESULT_H_

ros/include/alibabacloud/ros/model/CreateChangeSetRequest.h

@@ -0,0 +1,116 @@
+/*
+ * 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_ROS_MODEL_CREATECHANGESETREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_CREATECHANGESETREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT CreateChangeSetRequest : public RpcServiceRequest
+			{
+				struct Parameters
+				{
+					std::string parameterValue;
+					std::string parameterKey;
+				};
+
+			public:
+				CreateChangeSetRequest();
+				~CreateChangeSetRequest();
+
+				std::string getStackPolicyDuringUpdateURL()const;
+				void setStackPolicyDuringUpdateURL(const std::string& stackPolicyDuringUpdateURL);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getTemplateBody()const;
+				void setTemplateBody(const std::string& templateBody);
+				std::string getStackId()const;
+				void setStackId(const std::string& stackId);
+				std::string getChangeSetType()const;
+				void setChangeSetType(const std::string& changeSetType);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				bool getDisableRollback()const;
+				void setDisableRollback(bool disableRollback);
+				std::string getUpdateAllowPolicy()const;
+				void setUpdateAllowPolicy(const std::string& updateAllowPolicy);
+				long getTimeoutInMinutes()const;
+				void setTimeoutInMinutes(long timeoutInMinutes);
+				bool getUsePreviousParameters()const;
+				void setUsePreviousParameters(bool usePreviousParameters);
+				std::string getTemplateURL()const;
+				void setTemplateURL(const std::string& templateURL);
+				std::string getOrderSource()const;
+				void setOrderSource(const std::string& orderSource);
+				std::string getActivityId()const;
+				void setActivityId(const std::string& activityId);
+				std::string getStackPolicyDuringUpdateBody()const;
+				void setStackPolicyDuringUpdateBody(const std::string& stackPolicyDuringUpdateBody);
+				std::vector<std::string> getNotificationURLs()const;
+				void setNotificationURLs(const std::vector<std::string>& notificationURLs);
+				std::string getStackPolicyURL()const;
+				void setStackPolicyURL(const std::string& stackPolicyURL);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getChangeSetName()const;
+				void setChangeSetName(const std::string& changeSetName);
+				std::string getStackName()const;
+				void setStackName(const std::string& stackName);
+				std::vector<Parameters> getParameters()const;
+				void setParameters(const std::vector<Parameters>& parameters);
+				std::string getStackPolicyBody()const;
+				void setStackPolicyBody(const std::string& stackPolicyBody);
+				std::string getChannelId()const;
+				void setChannelId(const std::string& channelId);
+
+            private:
+				std::string stackPolicyDuringUpdateURL_;
+				std::string clientToken_;
+				std::string templateBody_;
+				std::string stackId_;
+				std::string changeSetType_;
+				std::string description_;
+				bool disableRollback_;
+				std::string updateAllowPolicy_;
+				long timeoutInMinutes_;
+				bool usePreviousParameters_;
+				std::string templateURL_;
+				std::string orderSource_;
+				std::string activityId_;
+				std::string stackPolicyDuringUpdateBody_;
+				std::vector<std::string> notificationURLs_;
+				std::string stackPolicyURL_;
+				std::string regionId_;
+				std::string changeSetName_;
+				std::string stackName_;
+				std::vector<Parameters> parameters_;
+				std::string stackPolicyBody_;
+				std::string channelId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_CREATECHANGESETREQUEST_H_

ros/include/alibabacloud/ros/model/CreateChangeSetResult.h

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

ros/include/alibabacloud/ros/model/CreateStackRequest.h

@@ -0,0 +1,92 @@
+/*
+ * 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_ROS_MODEL_CREATESTACKREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_CREATESTACKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT CreateStackRequest : public RpcServiceRequest
+			{
+				struct Parameters
+				{
+					std::string parameterValue;
+					std::string parameterKey;
+				};
+
+			public:
+				CreateStackRequest();
+				~CreateStackRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getTemplateBody()const;
+				void setTemplateBody(const std::string& templateBody);
+				bool getDisableRollback()const;
+				void setDisableRollback(bool disableRollback);
+				long getTimeoutInMinutes()const;
+				void setTimeoutInMinutes(long timeoutInMinutes);
+				std::string getOrderSource()const;
+				void setOrderSource(const std::string& orderSource);
+				std::string getTemplateURL()const;
+				void setTemplateURL(const std::string& templateURL);
+				std::string getActivityId()const;
+				void setActivityId(const std::string& activityId);
+				std::vector<std::string> getNotificationURLs()const;
+				void setNotificationURLs(const std::vector<std::string>& notificationURLs);
+				std::string getStackPolicyURL()const;
+				void setStackPolicyURL(const std::string& stackPolicyURL);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getStackName()const;
+				void setStackName(const std::string& stackName);
+				std::vector<Parameters> getParameters()const;
+				void setParameters(const std::vector<Parameters>& parameters);
+				std::string getStackPolicyBody()const;
+				void setStackPolicyBody(const std::string& stackPolicyBody);
+				std::string getChannelId()const;
+				void setChannelId(const std::string& channelId);
+
+            private:
+				std::string clientToken_;
+				std::string templateBody_;
+				bool disableRollback_;
+				long timeoutInMinutes_;
+				std::string orderSource_;
+				std::string templateURL_;
+				std::string activityId_;
+				std::vector<std::string> notificationURLs_;
+				std::string stackPolicyURL_;
+				std::string regionId_;
+				std::string stackName_;
+				std::vector<Parameters> parameters_;
+				std::string stackPolicyBody_;
+				std::string channelId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_CREATESTACKREQUEST_H_

ros/include/alibabacloud/ros/model/CreateStackResult.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_ROS_MODEL_CREATESTACKRESULT_H_
+#define ALIBABACLOUD_ROS_MODEL_CREATESTACKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT CreateStackResult : public ServiceResult
+			{
+			public:
+
+
+				CreateStackResult();
+				explicit CreateStackResult(const std::string &payload);
+				~CreateStackResult();
+				std::string getStackId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string stackId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_CREATESTACKRESULT_H_

ros/include/alibabacloud/ros/model/DeleteChangeSetRequest.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_ROS_MODEL_DELETECHANGESETREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_DELETECHANGESETREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT DeleteChangeSetRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteChangeSetRequest();
+				~DeleteChangeSetRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getChangeSetId()const;
+				void setChangeSetId(const std::string& changeSetId);
+
+            private:
+				std::string regionId_;
+				std::string changeSetId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_DELETECHANGESETREQUEST_H_

ros/include/alibabacloud/ros/model/DeleteChangeSetResult.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_ROS_MODEL_DELETECHANGESETRESULT_H_
+#define ALIBABACLOUD_ROS_MODEL_DELETECHANGESETRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT DeleteChangeSetResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteChangeSetResult();
+				explicit DeleteChangeSetResult(const std::string &payload);
+				~DeleteChangeSetResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_DELETECHANGESETRESULT_H_

ros/include/alibabacloud/ros/model/DeleteStackRequest.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_ROS_MODEL_DELETESTACKREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_DELETESTACKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT DeleteStackRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteStackRequest();
+				~DeleteStackRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				bool getRetainAllResources()const;
+				void setRetainAllResources(bool retainAllResources);
+				std::string getStackId()const;
+				void setStackId(const std::string& stackId);
+
+            private:
+				std::string regionId_;
+				bool retainAllResources_;
+				std::string stackId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_DELETESTACKREQUEST_H_

ros/include/alibabacloud/ros/model/DeleteStackResult.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_ROS_MODEL_DELETESTACKRESULT_H_
+#define ALIBABACLOUD_ROS_MODEL_DELETESTACKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT DeleteStackResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteStackResult();
+				explicit DeleteStackResult(const std::string &payload);
+				~DeleteStackResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_DELETESTACKRESULT_H_

ros/include/alibabacloud/ros/model/DescribeRegionsRequest.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_ROS_MODEL_DESCRIBEREGIONSREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_DESCRIBEREGIONSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT DescribeRegionsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeRegionsRequest();
+				~DescribeRegionsRequest();
+
+				std::string getAcceptLanguage()const;
+				void setAcceptLanguage(const std::string& acceptLanguage);
+
+            private:
+				std::string acceptLanguage_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_DESCRIBEREGIONSREQUEST_H_

ros/include/alibabacloud/ros/model/DescribeRegionsResult.h

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

ros/include/alibabacloud/ros/model/ExecuteChangeSetRequest.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_ROS_MODEL_EXECUTECHANGESETREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_EXECUTECHANGESETREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT ExecuteChangeSetRequest : public RpcServiceRequest
+			{
+
+			public:
+				ExecuteChangeSetRequest();
+				~ExecuteChangeSetRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getChangeSetId()const;
+				void setChangeSetId(const std::string& changeSetId);
+
+            private:
+				std::string regionId_;
+				std::string changeSetId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_EXECUTECHANGESETREQUEST_H_

ros/include/alibabacloud/ros/model/ExecuteChangeSetResult.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_ROS_MODEL_EXECUTECHANGESETRESULT_H_
+#define ALIBABACLOUD_ROS_MODEL_EXECUTECHANGESETRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT ExecuteChangeSetResult : public ServiceResult
+			{
+			public:
+
+
+				ExecuteChangeSetResult();
+				explicit ExecuteChangeSetResult(const std::string &payload);
+				~ExecuteChangeSetResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_EXECUTECHANGESETRESULT_H_

ros/include/alibabacloud/ros/model/GetChangeSetRequest.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_ROS_MODEL_GETCHANGESETREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_GETCHANGESETREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT GetChangeSetRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetChangeSetRequest();
+				~GetChangeSetRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getChangeSetId()const;
+				void setChangeSetId(const std::string& changeSetId);
+				bool getShowTemplate()const;
+				void setShowTemplate(bool showTemplate);
+
+            private:
+				std::string regionId_;
+				std::string changeSetId_;
+				bool showTemplate_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_GETCHANGESETREQUEST_H_

ros/include/alibabacloud/ros/model/GetChangeSetResult.h

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ROS_MODEL_GETCHANGESETRESULT_H_
+#define ALIBABACLOUD_ROS_MODEL_GETCHANGESETRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT GetChangeSetResult : public ServiceResult
+			{
+			public:
+				struct Parameter
+				{
+					std::string parameterValue;
+					std::string parameterKey;
+				};
+
+
+				GetChangeSetResult();
+				explicit GetChangeSetResult(const std::string &payload);
+				~GetChangeSetResult();
+				std::vector<std::string> getChanges()const;
+				std::string getStatus()const;
+				std::vector<Parameter> getParameters()const;
+				std::string getDescription()const;
+				std::string getCreateTime()const;
+				std::string getTemplateBody()const;
+				std::string getChangeSetName()const;
+				std::string getChangeSetId()const;
+				std::string getExecutionStatus()const;
+				std::string getChangeSetType()const;
+				std::string getRegionId()const;
+				bool getDisableRollback()const;
+				std::string getStackName()const;
+				std::string getStackId()const;
+				int getTimeoutInMinutes()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<std::string> changes_;
+				std::string status_;
+				std::vector<Parameter> parameters_;
+				std::string description_;
+				std::string createTime_;
+				std::string templateBody_;
+				std::string changeSetName_;
+				std::string changeSetId_;
+				std::string executionStatus_;
+				std::string changeSetType_;
+				std::string regionId_;
+				bool disableRollback_;
+				std::string stackName_;
+				std::string stackId_;
+				int timeoutInMinutes_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_GETCHANGESETRESULT_H_

ros/include/alibabacloud/ros/model/GetResourceTypeRequest.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_ROS_MODEL_GETRESOURCETYPEREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_GETRESOURCETYPEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT GetResourceTypeRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetResourceTypeRequest();
+				~GetResourceTypeRequest();
+
+				std::string getResourceType()const;
+				void setResourceType(const std::string& resourceType);
+
+            private:
+				std::string resourceType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_GETRESOURCETYPEREQUEST_H_

ros/include/alibabacloud/ros/model/GetResourceTypeResult.h

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

ros/include/alibabacloud/ros/model/GetResourceTypeTemplateRequest.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_ROS_MODEL_GETRESOURCETYPETEMPLATEREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_GETRESOURCETYPETEMPLATEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT GetResourceTypeTemplateRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetResourceTypeTemplateRequest();
+				~GetResourceTypeTemplateRequest();
+
+				std::string getResourceType()const;
+				void setResourceType(const std::string& resourceType);
+
+            private:
+				std::string resourceType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_GETRESOURCETYPETEMPLATEREQUEST_H_

ros/include/alibabacloud/ros/model/GetResourceTypeTemplateResult.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_ROS_MODEL_GETRESOURCETYPETEMPLATERESULT_H_
+#define ALIBABACLOUD_ROS_MODEL_GETRESOURCETYPETEMPLATERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT GetResourceTypeTemplateResult : public ServiceResult
+			{
+			public:
+
+
+				GetResourceTypeTemplateResult();
+				explicit GetResourceTypeTemplateResult(const std::string &payload);
+				~GetResourceTypeTemplateResult();
+				std::string getTemplateBody()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string templateBody_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_GETRESOURCETYPETEMPLATERESULT_H_

ros/include/alibabacloud/ros/model/GetStackPolicyRequest.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_ROS_MODEL_GETSTACKPOLICYREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_GETSTACKPOLICYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT GetStackPolicyRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetStackPolicyRequest();
+				~GetStackPolicyRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getStackId()const;
+				void setStackId(const std::string& stackId);
+
+            private:
+				std::string regionId_;
+				std::string stackId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_GETSTACKPOLICYREQUEST_H_

ros/include/alibabacloud/ros/model/GetStackPolicyResult.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_ROS_MODEL_GETSTACKPOLICYRESULT_H_
+#define ALIBABACLOUD_ROS_MODEL_GETSTACKPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT GetStackPolicyResult : public ServiceResult
+			{
+			public:
+
+
+				GetStackPolicyResult();
+				explicit GetStackPolicyResult(const std::string &payload);
+				~GetStackPolicyResult();
+				std::string getStackPolicyBody()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string stackPolicyBody_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_GETSTACKPOLICYRESULT_H_

ros/include/alibabacloud/ros/model/GetStackRequest.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_ROS_MODEL_GETSTACKREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_GETSTACKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT GetStackRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetStackRequest();
+				~GetStackRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getStackId()const;
+				void setStackId(const std::string& stackId);
+
+            private:
+				std::string regionId_;
+				std::string clientToken_;
+				std::string stackId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_GETSTACKREQUEST_H_

ros/include/alibabacloud/ros/model/GetStackResourceRequest.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_ROS_MODEL_GETSTACKRESOURCEREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_GETSTACKRESOURCEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT GetStackResourceRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetStackResourceRequest();
+				~GetStackResourceRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getStackId()const;
+				void setStackId(const std::string& stackId);
+				std::string getLogicalResourceId()const;
+				void setLogicalResourceId(const std::string& logicalResourceId);
+				bool getShowResourceAttributes()const;
+				void setShowResourceAttributes(bool showResourceAttributes);
+
+            private:
+				std::string clientToken_;
+				std::string regionId_;
+				std::string stackId_;
+				std::string logicalResourceId_;
+				bool showResourceAttributes_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_GETSTACKRESOURCEREQUEST_H_

ros/include/alibabacloud/ros/model/GetStackResourceResult.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_ROS_MODEL_GETSTACKRESOURCERESULT_H_
+#define ALIBABACLOUD_ROS_MODEL_GETSTACKRESOURCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT GetStackResourceResult : public ServiceResult
+			{
+			public:
+
+
+				GetStackResourceResult();
+				explicit GetStackResourceResult(const std::string &payload);
+				~GetStackResourceResult();
+				std::string getStatus()const;
+				std::string getLogicalResourceId()const;
+				std::string getDescription()const;
+				std::string getPhysicalResourceId()const;
+				std::string getStatusReason()const;
+				std::string getCreateTime()const;
+				std::string getMetadata()const;
+				std::string getUpdateTime()const;
+				std::string getResourceType()const;
+				std::vector<std::string> getResourceAttributes()const;
+				std::string getStackName()const;
+				std::string getStackId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string status_;
+				std::string logicalResourceId_;
+				std::string description_;
+				std::string physicalResourceId_;
+				std::string statusReason_;
+				std::string createTime_;
+				std::string metadata_;
+				std::string updateTime_;
+				std::string resourceType_;
+				std::vector<std::string> resourceAttributes_;
+				std::string stackName_;
+				std::string stackId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_GETSTACKRESOURCERESULT_H_

ros/include/alibabacloud/ros/model/GetStackResult.h

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ROS_MODEL_GETSTACKRESULT_H_
+#define ALIBABACLOUD_ROS_MODEL_GETSTACKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT GetStackResult : public ServiceResult
+			{
+			public:
+				struct Parameter
+				{
+					std::string parameterValue;
+					std::string parameterKey;
+				};
+
+
+				GetStackResult();
+				explicit GetStackResult(const std::string &payload);
+				~GetStackResult();
+				std::string getStatus()const;
+				std::vector<Parameter> getParameters()const;
+				std::string getDescription()const;
+				std::string getStatusReason()const;
+				std::string getParentStackId()const;
+				std::string getCreateTime()const;
+				std::string getTemplateDescription()const;
+				std::vector<std::string> getOutputs()const;
+				std::string getUpdateTime()const;
+				std::string getRegionId()const;
+				std::vector<std::string> getNotificationURLs()const;
+				bool getDisableRollback()const;
+				std::string getStackName()const;
+				std::string getStackId()const;
+				int getTimeoutInMinutes()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string status_;
+				std::vector<Parameter> parameters_;
+				std::string description_;
+				std::string statusReason_;
+				std::string parentStackId_;
+				std::string createTime_;
+				std::string templateDescription_;
+				std::vector<std::string> outputs_;
+				std::string updateTime_;
+				std::string regionId_;
+				std::vector<std::string> notificationURLs_;
+				bool disableRollback_;
+				std::string stackName_;
+				std::string stackId_;
+				int timeoutInMinutes_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_GETSTACKRESULT_H_

ros/include/alibabacloud/ros/model/GetTemplateEstimateCostRequest.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_ROS_MODEL_GETTEMPLATEESTIMATECOSTREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_GETTEMPLATEESTIMATECOSTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT GetTemplateEstimateCostRequest : public RpcServiceRequest
+			{
+				struct Parameters
+				{
+					std::string parameterValue;
+					std::string parameterKey;
+				};
+
+			public:
+				GetTemplateEstimateCostRequest();
+				~GetTemplateEstimateCostRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getTemplateBody()const;
+				void setTemplateBody(const std::string& templateBody);
+				std::vector<Parameters> getParameters()const;
+				void setParameters(const std::vector<Parameters>& parameters);
+				std::string getTemplateURL()const;
+				void setTemplateURL(const std::string& templateURL);
+
+            private:
+				std::string regionId_;
+				std::string clientToken_;
+				std::string templateBody_;
+				std::vector<Parameters> parameters_;
+				std::string templateURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_GETTEMPLATEESTIMATECOSTREQUEST_H_

ros/include/alibabacloud/ros/model/GetTemplateEstimateCostResult.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_ROS_MODEL_GETTEMPLATEESTIMATECOSTRESULT_H_
+#define ALIBABACLOUD_ROS_MODEL_GETTEMPLATEESTIMATECOSTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT GetTemplateEstimateCostResult : public ServiceResult
+			{
+			public:
+
+
+				GetTemplateEstimateCostResult();
+				explicit GetTemplateEstimateCostResult(const std::string &payload);
+				~GetTemplateEstimateCostResult();
+				std::string getResources()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string resources_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_GETTEMPLATEESTIMATECOSTRESULT_H_

ros/include/alibabacloud/ros/model/GetTemplateRequest.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_ROS_MODEL_GETTEMPLATEREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_GETTEMPLATEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT GetTemplateRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetTemplateRequest();
+				~GetTemplateRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getStackId()const;
+				void setStackId(const std::string& stackId);
+				std::string getChangeSetId()const;
+				void setChangeSetId(const std::string& changeSetId);
+
+            private:
+				std::string regionId_;
+				std::string stackId_;
+				std::string changeSetId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_GETTEMPLATEREQUEST_H_

ros/include/alibabacloud/ros/model/GetTemplateResult.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_ROS_MODEL_GETTEMPLATERESULT_H_
+#define ALIBABACLOUD_ROS_MODEL_GETTEMPLATERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT GetTemplateResult : public ServiceResult
+			{
+			public:
+
+
+				GetTemplateResult();
+				explicit GetTemplateResult(const std::string &payload);
+				~GetTemplateResult();
+				std::string getTemplateBody()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string templateBody_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_GETTEMPLATERESULT_H_

ros/include/alibabacloud/ros/model/ListChangeSetsRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ROS_MODEL_LISTCHANGESETSREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_LISTCHANGESETSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT ListChangeSetsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListChangeSetsRequest();
+				~ListChangeSetsRequest();
+
+				std::vector<std::string> getExecutionStatus()const;
+				void setExecutionStatus(const std::vector<std::string>& executionStatus);
+				std::vector<std::string> getChangeSetName()const;
+				void setChangeSetName(const std::vector<std::string>& changeSetName);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getStackId()const;
+				void setStackId(const std::string& stackId);
+				long getPageSize()const;
+				void setPageSize(long pageSize);
+				long getPageNumber()const;
+				void setPageNumber(long pageNumber);
+				std::vector<std::string> getStatus()const;
+				void setStatus(const std::vector<std::string>& status);
+
+            private:
+				std::vector<std::string> executionStatus_;
+				std::vector<std::string> changeSetName_;
+				std::string regionId_;
+				std::string stackId_;
+				long pageSize_;
+				long pageNumber_;
+				std::vector<std::string> status_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_LISTCHANGESETSREQUEST_H_

ros/include/alibabacloud/ros/model/ListChangeSetsResult.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ROS_MODEL_LISTCHANGESETSRESULT_H_
+#define ALIBABACLOUD_ROS_MODEL_LISTCHANGESETSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT ListChangeSetsResult : public ServiceResult
+			{
+			public:
+				struct ChangeSet
+				{
+					std::string status;
+					std::string changeSetId;
+					std::string description;
+					std::string executionStatus;
+					std::string createTime;
+					std::string changeSetType;
+					std::string regionId;
+					std::string changeSetName;
+					std::string stackName;
+					std::string stackId;
+				};
+
+
+				ListChangeSetsResult();
+				explicit ListChangeSetsResult(const std::string &payload);
+				~ListChangeSetsResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<ChangeSet> getChangeSets()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<ChangeSet> changeSets_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_LISTCHANGESETSRESULT_H_

ros/include/alibabacloud/ros/model/ListResourceTypesRequest.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_ROS_MODEL_LISTRESOURCETYPESREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_LISTRESOURCETYPESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT ListResourceTypesRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListResourceTypesRequest();
+				~ListResourceTypesRequest();
+
+
+            private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_LISTRESOURCETYPESREQUEST_H_

ros/include/alibabacloud/ros/model/ListResourceTypesResult.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_ROS_MODEL_LISTRESOURCETYPESRESULT_H_
+#define ALIBABACLOUD_ROS_MODEL_LISTRESOURCETYPESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT ListResourceTypesResult : public ServiceResult
+			{
+			public:
+
+
+				ListResourceTypesResult();
+				explicit ListResourceTypesResult(const std::string &payload);
+				~ListResourceTypesResult();
+				std::vector<std::string> getResourceTypes()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<std::string> resourceTypes_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_LISTRESOURCETYPESRESULT_H_

ros/include/alibabacloud/ros/model/ListStackEventsRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ROS_MODEL_LISTSTACKEVENTSREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_LISTSTACKEVENTSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT ListStackEventsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListStackEventsRequest();
+				~ListStackEventsRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getStackId()const;
+				void setStackId(const std::string& stackId);
+				long getPageSize()const;
+				void setPageSize(long pageSize);
+				std::vector<std::string> getLogicalResourceId()const;
+				void setLogicalResourceId(const std::vector<std::string>& logicalResourceId);
+				std::vector<std::string> getResourceType()const;
+				void setResourceType(const std::vector<std::string>& resourceType);
+				long getPageNumber()const;
+				void setPageNumber(long pageNumber);
+				std::vector<std::string> getStatus()const;
+				void setStatus(const std::vector<std::string>& status);
+
+            private:
+				std::string regionId_;
+				std::string stackId_;
+				long pageSize_;
+				std::vector<std::string> logicalResourceId_;
+				std::vector<std::string> resourceType_;
+				long pageNumber_;
+				std::vector<std::string> status_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_LISTSTACKEVENTSREQUEST_H_

ros/include/alibabacloud/ros/model/ListStackEventsResult.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_ROS_MODEL_LISTSTACKEVENTSRESULT_H_
+#define ALIBABACLOUD_ROS_MODEL_LISTSTACKEVENTSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT ListStackEventsResult : public ServiceResult
+			{
+			public:
+				struct Event
+				{
+					std::string status;
+					std::string logicalResourceId;
+					std::string physicalResourceId;
+					std::string statusReason;
+					std::string createTime;
+					std::string eventId;
+					std::string resourceType;
+					std::string stackName;
+					std::string stackId;
+				};
+
+
+				ListStackEventsResult();
+				explicit ListStackEventsResult(const std::string &payload);
+				~ListStackEventsResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				std::vector<Event> getEvents()const;
+				int getPageNumber()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				std::vector<Event> events_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_LISTSTACKEVENTSRESULT_H_

ros/include/alibabacloud/ros/model/ListStackResourcesRequest.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_ROS_MODEL_LISTSTACKRESOURCESREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_LISTSTACKRESOURCESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT ListStackResourcesRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListStackResourcesRequest();
+				~ListStackResourcesRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getStackId()const;
+				void setStackId(const std::string& stackId);
+
+            private:
+				std::string regionId_;
+				std::string stackId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_LISTSTACKRESOURCESREQUEST_H_

ros/include/alibabacloud/ros/model/ListStackResourcesResult.h

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

ros/include/alibabacloud/ros/model/ListStacksRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ROS_MODEL_LISTSTACKSREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_LISTSTACKSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT ListStacksRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListStacksRequest();
+				~ListStacksRequest();
+
+				std::string getParentStackId()const;
+				void setParentStackId(const std::string& parentStackId);
+				bool getShowNestedStack()const;
+				void setShowNestedStack(bool showNestedStack);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				long getPageSize()const;
+				void setPageSize(long pageSize);
+				std::vector<std::string> getStackName()const;
+				void setStackName(const std::vector<std::string>& stackName);
+				long getPageNumber()const;
+				void setPageNumber(long pageNumber);
+				std::vector<std::string> getStatus()const;
+				void setStatus(const std::vector<std::string>& status);
+
+            private:
+				std::string parentStackId_;
+				bool showNestedStack_;
+				std::string regionId_;
+				long pageSize_;
+				std::vector<std::string> stackName_;
+				long pageNumber_;
+				std::vector<std::string> status_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_LISTSTACKSREQUEST_H_

ros/include/alibabacloud/ros/model/ListStacksResult.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ROS_MODEL_LISTSTACKSRESULT_H_
+#define ALIBABACLOUD_ROS_MODEL_LISTSTACKSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT ListStacksResult : public ServiceResult
+			{
+			public:
+				struct Stack
+				{
+					std::string status;
+					std::string statusReason;
+					std::string parentStackId;
+					std::string createTime;
+					std::string updateTime;
+					std::string regionId;
+					bool disableRollback;
+					std::string stackName;
+					std::string stackId;
+					int timeoutInMinutes;
+				};
+
+
+				ListStacksResult();
+				explicit ListStacksResult(const std::string &payload);
+				~ListStacksResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<Stack> getStacks()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<Stack> stacks_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_LISTSTACKSRESULT_H_

ros/include/alibabacloud/ros/model/PreviewStackRequest.h

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ROS_MODEL_PREVIEWSTACKREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_PREVIEWSTACKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT PreviewStackRequest : public RpcServiceRequest
+			{
+				struct Parameters
+				{
+					std::string parameterValue;
+					std::string parameterKey;
+				};
+
+			public:
+				PreviewStackRequest();
+				~PreviewStackRequest();
+
+				std::string getStackPolicyURL()const;
+				void setStackPolicyURL(const std::string& stackPolicyURL);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getTemplateBody()const;
+				void setTemplateBody(const std::string& templateBody);
+				bool getDisableRollback()const;
+				void setDisableRollback(bool disableRollback);
+				std::string getStackName()const;
+				void setStackName(const std::string& stackName);
+				std::vector<Parameters> getParameters()const;
+				void setParameters(const std::vector<Parameters>& parameters);
+				std::string getStackPolicyBody()const;
+				void setStackPolicyBody(const std::string& stackPolicyBody);
+				long getTimeoutInMinutes()const;
+				void setTimeoutInMinutes(long timeoutInMinutes);
+				std::string getTemplateURL()const;
+				void setTemplateURL(const std::string& templateURL);
+
+            private:
+				std::string stackPolicyURL_;
+				std::string regionId_;
+				std::string clientToken_;
+				std::string templateBody_;
+				bool disableRollback_;
+				std::string stackName_;
+				std::vector<Parameters> parameters_;
+				std::string stackPolicyBody_;
+				long timeoutInMinutes_;
+				std::string templateURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_PREVIEWSTACKREQUEST_H_

ros/include/alibabacloud/ros/model/PreviewStackResult.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_ROS_MODEL_PREVIEWSTACKRESULT_H_
+#define ALIBABACLOUD_ROS_MODEL_PREVIEWSTACKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT PreviewStackResult : public ServiceResult
+			{
+			public:
+
+
+				PreviewStackResult();
+				explicit PreviewStackResult(const std::string &payload);
+				~PreviewStackResult();
+				std::string getStack()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string stack_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_PREVIEWSTACKRESULT_H_

ros/include/alibabacloud/ros/model/SetStackPolicyRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ROS_MODEL_SETSTACKPOLICYREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_SETSTACKPOLICYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT SetStackPolicyRequest : public RpcServiceRequest
+			{
+
+			public:
+				SetStackPolicyRequest();
+				~SetStackPolicyRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getStackPolicyURL()const;
+				void setStackPolicyURL(const std::string& stackPolicyURL);
+				std::string getStackId()const;
+				void setStackId(const std::string& stackId);
+				std::string getStackPolicyBody()const;
+				void setStackPolicyBody(const std::string& stackPolicyBody);
+
+            private:
+				std::string regionId_;
+				std::string stackPolicyURL_;
+				std::string stackId_;
+				std::string stackPolicyBody_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_SETSTACKPOLICYREQUEST_H_

ros/include/alibabacloud/ros/model/SetStackPolicyResult.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_ROS_MODEL_SETSTACKPOLICYRESULT_H_
+#define ALIBABACLOUD_ROS_MODEL_SETSTACKPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT SetStackPolicyResult : public ServiceResult
+			{
+			public:
+
+
+				SetStackPolicyResult();
+				explicit SetStackPolicyResult(const std::string &payload);
+				~SetStackPolicyResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_SETSTACKPOLICYRESULT_H_

ros/include/alibabacloud/ros/model/SignalResourceRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ROS_MODEL_SIGNALRESOURCEREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_SIGNALRESOURCEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT SignalResourceRequest : public RpcServiceRequest
+			{
+
+			public:
+				SignalResourceRequest();
+				~SignalResourceRequest();
+
+				std::string getData()const;
+				void setData(const std::string& data);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getStackId()const;
+				void setStackId(const std::string& stackId);
+				std::string getLogicalResourceId()const;
+				void setLogicalResourceId(const std::string& logicalResourceId);
+				std::string getUniqueId()const;
+				void setUniqueId(const std::string& uniqueId);
+				std::string getStatus()const;
+				void setStatus(const std::string& status);
+
+            private:
+				std::string data_;
+				std::string regionId_;
+				std::string clientToken_;
+				std::string stackId_;
+				std::string logicalResourceId_;
+				std::string uniqueId_;
+				std::string status_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_SIGNALRESOURCEREQUEST_H_

ros/include/alibabacloud/ros/model/SignalResourceResult.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_ROS_MODEL_SIGNALRESOURCERESULT_H_
+#define ALIBABACLOUD_ROS_MODEL_SIGNALRESOURCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT SignalResourceResult : public ServiceResult
+			{
+			public:
+
+
+				SignalResourceResult();
+				explicit SignalResourceResult(const std::string &payload);
+				~SignalResourceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_SIGNALRESOURCERESULT_H_

ros/include/alibabacloud/ros/model/UpdateStackRequest.h

@@ -0,0 +1,95 @@
+/*
+ * 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_ROS_MODEL_UPDATESTACKREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_UPDATESTACKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT UpdateStackRequest : public RpcServiceRequest
+			{
+				struct Parameters
+				{
+					std::string parameterValue;
+					std::string parameterKey;
+				};
+
+			public:
+				UpdateStackRequest();
+				~UpdateStackRequest();
+
+				std::string getStackPolicyDuringUpdateURL()const;
+				void setStackPolicyDuringUpdateURL(const std::string& stackPolicyDuringUpdateURL);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getTemplateBody()const;
+				void setTemplateBody(const std::string& templateBody);
+				std::string getStackId()const;
+				void setStackId(const std::string& stackId);
+				bool getDisableRollback()const;
+				void setDisableRollback(bool disableRollback);
+				bool getEnableRecover()const;
+				void setEnableRecover(bool enableRecover);
+				std::string getUpdateAllowPolicy()const;
+				void setUpdateAllowPolicy(const std::string& updateAllowPolicy);
+				long getTimeoutInMinutes()const;
+				void setTimeoutInMinutes(long timeoutInMinutes);
+				bool getUsePreviousParameters()const;
+				void setUsePreviousParameters(bool usePreviousParameters);
+				std::string getTemplateURL()const;
+				void setTemplateURL(const std::string& templateURL);
+				std::string getStackPolicyDuringUpdateBody()const;
+				void setStackPolicyDuringUpdateBody(const std::string& stackPolicyDuringUpdateBody);
+				std::string getStackPolicyURL()const;
+				void setStackPolicyURL(const std::string& stackPolicyURL);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::vector<Parameters> getParameters()const;
+				void setParameters(const std::vector<Parameters>& parameters);
+				std::string getStackPolicyBody()const;
+				void setStackPolicyBody(const std::string& stackPolicyBody);
+
+            private:
+				std::string stackPolicyDuringUpdateURL_;
+				std::string clientToken_;
+				std::string templateBody_;
+				std::string stackId_;
+				bool disableRollback_;
+				bool enableRecover_;
+				std::string updateAllowPolicy_;
+				long timeoutInMinutes_;
+				bool usePreviousParameters_;
+				std::string templateURL_;
+				std::string stackPolicyDuringUpdateBody_;
+				std::string stackPolicyURL_;
+				std::string regionId_;
+				std::vector<Parameters> parameters_;
+				std::string stackPolicyBody_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_UPDATESTACKREQUEST_H_

ros/include/alibabacloud/ros/model/UpdateStackResult.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_ROS_MODEL_UPDATESTACKRESULT_H_
+#define ALIBABACLOUD_ROS_MODEL_UPDATESTACKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT UpdateStackResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateStackResult();
+				explicit UpdateStackResult(const std::string &payload);
+				~UpdateStackResult();
+				std::string getStackId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string stackId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_UPDATESTACKRESULT_H_

ros/include/alibabacloud/ros/model/ValidateTemplateRequest.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_ROS_MODEL_VALIDATETEMPLATEREQUEST_H_
+#define ALIBABACLOUD_ROS_MODEL_VALIDATETEMPLATEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ros/ROSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ROS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ROS_EXPORT ValidateTemplateRequest : public RpcServiceRequest
+			{
+
+			public:
+				ValidateTemplateRequest();
+				~ValidateTemplateRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getTemplateBody()const;
+				void setTemplateBody(const std::string& templateBody);
+				std::string getTemplateURL()const;
+				void setTemplateURL(const std::string& templateURL);
+
+            private:
+				std::string regionId_;
+				std::string templateBody_;
+				std::string templateURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ROS_MODEL_VALIDATETEMPLATEREQUEST_H_

ros/include/alibabacloud/ros/model/ValidateTemplateResult.h

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

ros/src/ROSClient.cc

@@ -0,0 +1,989 @@
+/*
+ * 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/ros/ROSClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "ROS";
+}
+
+ROSClient::ROSClient(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, "ROS");
+}
+
+ROSClient::ROSClient(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, "ROS");
+}
+
+ROSClient::ROSClient(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, "ROS");
+}
+
+ROSClient::~ROSClient()
+{}
+
+ROSClient::ListStacksOutcome ROSClient::listStacks(const ListStacksRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListStacksOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListStacksOutcome(ListStacksResult(outcome.result()));
+	else
+		return ListStacksOutcome(outcome.error());
+}
+
+void ROSClient::listStacksAsync(const ListStacksRequest& request, const ListStacksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listStacks(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::ListStacksOutcomeCallable ROSClient::listStacksCallable(const ListStacksRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListStacksOutcome()>>(
+			[this, request]()
+			{
+			return this->listStacks(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::GetChangeSetOutcome ROSClient::getChangeSet(const GetChangeSetRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetChangeSetOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetChangeSetOutcome(GetChangeSetResult(outcome.result()));
+	else
+		return GetChangeSetOutcome(outcome.error());
+}
+
+void ROSClient::getChangeSetAsync(const GetChangeSetRequest& request, const GetChangeSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getChangeSet(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::GetChangeSetOutcomeCallable ROSClient::getChangeSetCallable(const GetChangeSetRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetChangeSetOutcome()>>(
+			[this, request]()
+			{
+			return this->getChangeSet(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::ValidateTemplateOutcome ROSClient::validateTemplate(const ValidateTemplateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ValidateTemplateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ValidateTemplateOutcome(ValidateTemplateResult(outcome.result()));
+	else
+		return ValidateTemplateOutcome(outcome.error());
+}
+
+void ROSClient::validateTemplateAsync(const ValidateTemplateRequest& request, const ValidateTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, validateTemplate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::ValidateTemplateOutcomeCallable ROSClient::validateTemplateCallable(const ValidateTemplateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ValidateTemplateOutcome()>>(
+			[this, request]()
+			{
+			return this->validateTemplate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::UpdateStackOutcome ROSClient::updateStack(const UpdateStackRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateStackOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateStackOutcome(UpdateStackResult(outcome.result()));
+	else
+		return UpdateStackOutcome(outcome.error());
+}
+
+void ROSClient::updateStackAsync(const UpdateStackRequest& request, const UpdateStackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateStack(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::UpdateStackOutcomeCallable ROSClient::updateStackCallable(const UpdateStackRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateStackOutcome()>>(
+			[this, request]()
+			{
+			return this->updateStack(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::GetStackResourceOutcome ROSClient::getStackResource(const GetStackResourceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetStackResourceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetStackResourceOutcome(GetStackResourceResult(outcome.result()));
+	else
+		return GetStackResourceOutcome(outcome.error());
+}
+
+void ROSClient::getStackResourceAsync(const GetStackResourceRequest& request, const GetStackResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getStackResource(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::GetStackResourceOutcomeCallable ROSClient::getStackResourceCallable(const GetStackResourceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetStackResourceOutcome()>>(
+			[this, request]()
+			{
+			return this->getStackResource(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::ListResourceTypesOutcome ROSClient::listResourceTypes(const ListResourceTypesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListResourceTypesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListResourceTypesOutcome(ListResourceTypesResult(outcome.result()));
+	else
+		return ListResourceTypesOutcome(outcome.error());
+}
+
+void ROSClient::listResourceTypesAsync(const ListResourceTypesRequest& request, const ListResourceTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listResourceTypes(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::ListResourceTypesOutcomeCallable ROSClient::listResourceTypesCallable(const ListResourceTypesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListResourceTypesOutcome()>>(
+			[this, request]()
+			{
+			return this->listResourceTypes(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::DescribeRegionsOutcome ROSClient::describeRegions(const DescribeRegionsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeRegionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeRegionsOutcome(DescribeRegionsResult(outcome.result()));
+	else
+		return DescribeRegionsOutcome(outcome.error());
+}
+
+void ROSClient::describeRegionsAsync(const DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeRegions(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::DescribeRegionsOutcomeCallable ROSClient::describeRegionsCallable(const DescribeRegionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeRegionsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeRegions(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::GetResourceTypeTemplateOutcome ROSClient::getResourceTypeTemplate(const GetResourceTypeTemplateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetResourceTypeTemplateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetResourceTypeTemplateOutcome(GetResourceTypeTemplateResult(outcome.result()));
+	else
+		return GetResourceTypeTemplateOutcome(outcome.error());
+}
+
+void ROSClient::getResourceTypeTemplateAsync(const GetResourceTypeTemplateRequest& request, const GetResourceTypeTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getResourceTypeTemplate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::GetResourceTypeTemplateOutcomeCallable ROSClient::getResourceTypeTemplateCallable(const GetResourceTypeTemplateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetResourceTypeTemplateOutcome()>>(
+			[this, request]()
+			{
+			return this->getResourceTypeTemplate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::CreateStackOutcome ROSClient::createStack(const CreateStackRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateStackOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateStackOutcome(CreateStackResult(outcome.result()));
+	else
+		return CreateStackOutcome(outcome.error());
+}
+
+void ROSClient::createStackAsync(const CreateStackRequest& request, const CreateStackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createStack(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::CreateStackOutcomeCallable ROSClient::createStackCallable(const CreateStackRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateStackOutcome()>>(
+			[this, request]()
+			{
+			return this->createStack(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::DeleteStackOutcome ROSClient::deleteStack(const DeleteStackRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteStackOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteStackOutcome(DeleteStackResult(outcome.result()));
+	else
+		return DeleteStackOutcome(outcome.error());
+}
+
+void ROSClient::deleteStackAsync(const DeleteStackRequest& request, const DeleteStackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteStack(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::DeleteStackOutcomeCallable ROSClient::deleteStackCallable(const DeleteStackRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteStackOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteStack(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::GetTemplateEstimateCostOutcome ROSClient::getTemplateEstimateCost(const GetTemplateEstimateCostRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetTemplateEstimateCostOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetTemplateEstimateCostOutcome(GetTemplateEstimateCostResult(outcome.result()));
+	else
+		return GetTemplateEstimateCostOutcome(outcome.error());
+}
+
+void ROSClient::getTemplateEstimateCostAsync(const GetTemplateEstimateCostRequest& request, const GetTemplateEstimateCostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getTemplateEstimateCost(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::GetTemplateEstimateCostOutcomeCallable ROSClient::getTemplateEstimateCostCallable(const GetTemplateEstimateCostRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetTemplateEstimateCostOutcome()>>(
+			[this, request]()
+			{
+			return this->getTemplateEstimateCost(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::ContinueCreateStackOutcome ROSClient::continueCreateStack(const ContinueCreateStackRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ContinueCreateStackOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ContinueCreateStackOutcome(ContinueCreateStackResult(outcome.result()));
+	else
+		return ContinueCreateStackOutcome(outcome.error());
+}
+
+void ROSClient::continueCreateStackAsync(const ContinueCreateStackRequest& request, const ContinueCreateStackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, continueCreateStack(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::ContinueCreateStackOutcomeCallable ROSClient::continueCreateStackCallable(const ContinueCreateStackRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ContinueCreateStackOutcome()>>(
+			[this, request]()
+			{
+			return this->continueCreateStack(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::GetResourceTypeOutcome ROSClient::getResourceType(const GetResourceTypeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetResourceTypeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetResourceTypeOutcome(GetResourceTypeResult(outcome.result()));
+	else
+		return GetResourceTypeOutcome(outcome.error());
+}
+
+void ROSClient::getResourceTypeAsync(const GetResourceTypeRequest& request, const GetResourceTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getResourceType(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::GetResourceTypeOutcomeCallable ROSClient::getResourceTypeCallable(const GetResourceTypeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetResourceTypeOutcome()>>(
+			[this, request]()
+			{
+			return this->getResourceType(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::DeleteChangeSetOutcome ROSClient::deleteChangeSet(const DeleteChangeSetRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteChangeSetOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteChangeSetOutcome(DeleteChangeSetResult(outcome.result()));
+	else
+		return DeleteChangeSetOutcome(outcome.error());
+}
+
+void ROSClient::deleteChangeSetAsync(const DeleteChangeSetRequest& request, const DeleteChangeSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteChangeSet(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::DeleteChangeSetOutcomeCallable ROSClient::deleteChangeSetCallable(const DeleteChangeSetRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteChangeSetOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteChangeSet(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::PreviewStackOutcome ROSClient::previewStack(const PreviewStackRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PreviewStackOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PreviewStackOutcome(PreviewStackResult(outcome.result()));
+	else
+		return PreviewStackOutcome(outcome.error());
+}
+
+void ROSClient::previewStackAsync(const PreviewStackRequest& request, const PreviewStackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, previewStack(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::PreviewStackOutcomeCallable ROSClient::previewStackCallable(const PreviewStackRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PreviewStackOutcome()>>(
+			[this, request]()
+			{
+			return this->previewStack(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::SignalResourceOutcome ROSClient::signalResource(const SignalResourceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SignalResourceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SignalResourceOutcome(SignalResourceResult(outcome.result()));
+	else
+		return SignalResourceOutcome(outcome.error());
+}
+
+void ROSClient::signalResourceAsync(const SignalResourceRequest& request, const SignalResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, signalResource(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::SignalResourceOutcomeCallable ROSClient::signalResourceCallable(const SignalResourceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SignalResourceOutcome()>>(
+			[this, request]()
+			{
+			return this->signalResource(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::ExecuteChangeSetOutcome ROSClient::executeChangeSet(const ExecuteChangeSetRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ExecuteChangeSetOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ExecuteChangeSetOutcome(ExecuteChangeSetResult(outcome.result()));
+	else
+		return ExecuteChangeSetOutcome(outcome.error());
+}
+
+void ROSClient::executeChangeSetAsync(const ExecuteChangeSetRequest& request, const ExecuteChangeSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, executeChangeSet(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::ExecuteChangeSetOutcomeCallable ROSClient::executeChangeSetCallable(const ExecuteChangeSetRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ExecuteChangeSetOutcome()>>(
+			[this, request]()
+			{
+			return this->executeChangeSet(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::SetStackPolicyOutcome ROSClient::setStackPolicy(const SetStackPolicyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetStackPolicyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetStackPolicyOutcome(SetStackPolicyResult(outcome.result()));
+	else
+		return SetStackPolicyOutcome(outcome.error());
+}
+
+void ROSClient::setStackPolicyAsync(const SetStackPolicyRequest& request, const SetStackPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setStackPolicy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::SetStackPolicyOutcomeCallable ROSClient::setStackPolicyCallable(const SetStackPolicyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetStackPolicyOutcome()>>(
+			[this, request]()
+			{
+			return this->setStackPolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::CreateChangeSetOutcome ROSClient::createChangeSet(const CreateChangeSetRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateChangeSetOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateChangeSetOutcome(CreateChangeSetResult(outcome.result()));
+	else
+		return CreateChangeSetOutcome(outcome.error());
+}
+
+void ROSClient::createChangeSetAsync(const CreateChangeSetRequest& request, const CreateChangeSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createChangeSet(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::CreateChangeSetOutcomeCallable ROSClient::createChangeSetCallable(const CreateChangeSetRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateChangeSetOutcome()>>(
+			[this, request]()
+			{
+			return this->createChangeSet(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::GetTemplateOutcome ROSClient::getTemplate(const GetTemplateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetTemplateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetTemplateOutcome(GetTemplateResult(outcome.result()));
+	else
+		return GetTemplateOutcome(outcome.error());
+}
+
+void ROSClient::getTemplateAsync(const GetTemplateRequest& request, const GetTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getTemplate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::GetTemplateOutcomeCallable ROSClient::getTemplateCallable(const GetTemplateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetTemplateOutcome()>>(
+			[this, request]()
+			{
+			return this->getTemplate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::ListStackEventsOutcome ROSClient::listStackEvents(const ListStackEventsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListStackEventsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListStackEventsOutcome(ListStackEventsResult(outcome.result()));
+	else
+		return ListStackEventsOutcome(outcome.error());
+}
+
+void ROSClient::listStackEventsAsync(const ListStackEventsRequest& request, const ListStackEventsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listStackEvents(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::ListStackEventsOutcomeCallable ROSClient::listStackEventsCallable(const ListStackEventsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListStackEventsOutcome()>>(
+			[this, request]()
+			{
+			return this->listStackEvents(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::GetStackOutcome ROSClient::getStack(const GetStackRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetStackOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetStackOutcome(GetStackResult(outcome.result()));
+	else
+		return GetStackOutcome(outcome.error());
+}
+
+void ROSClient::getStackAsync(const GetStackRequest& request, const GetStackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getStack(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::GetStackOutcomeCallable ROSClient::getStackCallable(const GetStackRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetStackOutcome()>>(
+			[this, request]()
+			{
+			return this->getStack(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::GetStackPolicyOutcome ROSClient::getStackPolicy(const GetStackPolicyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetStackPolicyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetStackPolicyOutcome(GetStackPolicyResult(outcome.result()));
+	else
+		return GetStackPolicyOutcome(outcome.error());
+}
+
+void ROSClient::getStackPolicyAsync(const GetStackPolicyRequest& request, const GetStackPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getStackPolicy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::GetStackPolicyOutcomeCallable ROSClient::getStackPolicyCallable(const GetStackPolicyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetStackPolicyOutcome()>>(
+			[this, request]()
+			{
+			return this->getStackPolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::CancelUpdateStackOutcome ROSClient::cancelUpdateStack(const CancelUpdateStackRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CancelUpdateStackOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CancelUpdateStackOutcome(CancelUpdateStackResult(outcome.result()));
+	else
+		return CancelUpdateStackOutcome(outcome.error());
+}
+
+void ROSClient::cancelUpdateStackAsync(const CancelUpdateStackRequest& request, const CancelUpdateStackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, cancelUpdateStack(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::CancelUpdateStackOutcomeCallable ROSClient::cancelUpdateStackCallable(const CancelUpdateStackRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CancelUpdateStackOutcome()>>(
+			[this, request]()
+			{
+			return this->cancelUpdateStack(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::ListStackResourcesOutcome ROSClient::listStackResources(const ListStackResourcesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListStackResourcesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListStackResourcesOutcome(ListStackResourcesResult(outcome.result()));
+	else
+		return ListStackResourcesOutcome(outcome.error());
+}
+
+void ROSClient::listStackResourcesAsync(const ListStackResourcesRequest& request, const ListStackResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listStackResources(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::ListStackResourcesOutcomeCallable ROSClient::listStackResourcesCallable(const ListStackResourcesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListStackResourcesOutcome()>>(
+			[this, request]()
+			{
+			return this->listStackResources(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ROSClient::ListChangeSetsOutcome ROSClient::listChangeSets(const ListChangeSetsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListChangeSetsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListChangeSetsOutcome(ListChangeSetsResult(outcome.result()));
+	else
+		return ListChangeSetsOutcome(outcome.error());
+}
+
+void ROSClient::listChangeSetsAsync(const ListChangeSetsRequest& request, const ListChangeSetsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listChangeSets(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ROSClient::ListChangeSetsOutcomeCallable ROSClient::listChangeSetsCallable(const ListChangeSetsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListChangeSetsOutcome()>>(
+			[this, request]()
+			{
+			return this->listChangeSets(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

ros/src/model/CancelUpdateStackRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/ros/model/CancelUpdateStackRequest.h>
+
+using AlibabaCloud::ROS::Model::CancelUpdateStackRequest;
+
+CancelUpdateStackRequest::CancelUpdateStackRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "CancelUpdateStack")
+{}
+
+CancelUpdateStackRequest::~CancelUpdateStackRequest()
+{}
+
+std::string CancelUpdateStackRequest::getCancelType()const
+{
+	return cancelType_;
+}
+
+void CancelUpdateStackRequest::setCancelType(const std::string& cancelType)
+{
+	cancelType_ = cancelType;
+	setCoreParameter("CancelType", cancelType);
+}
+
+std::string CancelUpdateStackRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CancelUpdateStackRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string CancelUpdateStackRequest::getStackId()const
+{
+	return stackId_;
+}
+
+void CancelUpdateStackRequest::setStackId(const std::string& stackId)
+{
+	stackId_ = stackId;
+	setCoreParameter("StackId", stackId);
+}
+

ros/src/model/CancelUpdateStackResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/ros/model/CancelUpdateStackResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+CancelUpdateStackResult::CancelUpdateStackResult() :
+	ServiceResult()
+{}
+
+CancelUpdateStackResult::CancelUpdateStackResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CancelUpdateStackResult::~CancelUpdateStackResult()
+{}
+
+void CancelUpdateStackResult::parse(const std::string &payload)
+{
+	Json::CharReaderBuilder builder;
+	Json::CharReader *reader = builder.newCharReader();
+	Json::Value *val;
+	Json::Value value;
+	JSONCPP_STRING *errs;
+	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
+	value = *val;
+	setRequestId(value["RequestId"].asString());
+
+}
+

ros/src/model/ContinueCreateStackRequest.cc

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ros/model/ContinueCreateStackRequest.h>
+
+using AlibabaCloud::ROS::Model::ContinueCreateStackRequest;
+
+ContinueCreateStackRequest::ContinueCreateStackRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "ContinueCreateStack")
+{}
+
+ContinueCreateStackRequest::~ContinueCreateStackRequest()
+{}
+
+std::string ContinueCreateStackRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ContinueCreateStackRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string ContinueCreateStackRequest::getStackId()const
+{
+	return stackId_;
+}
+
+void ContinueCreateStackRequest::setStackId(const std::string& stackId)
+{
+	stackId_ = stackId;
+	setCoreParameter("StackId", stackId);
+}
+
+std::vector<std::string> ContinueCreateStackRequest::getRecreatingResources()const
+{
+	return recreatingResources_;
+}
+
+void ContinueCreateStackRequest::setRecreatingResources(const std::vector<std::string>& recreatingResources)
+{
+	recreatingResources_ = recreatingResources;
+	for(int i = 0; i!= recreatingResources.size(); i++)
+		setCoreParameter("RecreatingResources."+ std::to_string(i), recreatingResources.at(i));
+}
+

ros/src/model/ContinueCreateStackResult.cc

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ros/model/ContinueCreateStackResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+ContinueCreateStackResult::ContinueCreateStackResult() :
+	ServiceResult()
+{}
+
+ContinueCreateStackResult::ContinueCreateStackResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ContinueCreateStackResult::~ContinueCreateStackResult()
+{}
+
+void ContinueCreateStackResult::parse(const std::string &payload)
+{
+	Json::CharReaderBuilder builder;
+	Json::CharReader *reader = builder.newCharReader();
+	Json::Value *val;
+	Json::Value value;
+	JSONCPP_STRING *errs;
+	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
+	value = *val;
+	setRequestId(value["RequestId"].asString());
+	if(!value["StackId"].isNull())
+		stackId_ = value["StackId"].asString();
+
+}
+
+std::string ContinueCreateStackResult::getStackId()const
+{
+	return stackId_;
+}
+

ros/src/model/CreateChangeSetRequest.cc

@@ -0,0 +1,276 @@
+/*
+ * 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/ros/model/CreateChangeSetRequest.h>
+
+using AlibabaCloud::ROS::Model::CreateChangeSetRequest;
+
+CreateChangeSetRequest::CreateChangeSetRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "CreateChangeSet")
+{}
+
+CreateChangeSetRequest::~CreateChangeSetRequest()
+{}
+
+std::string CreateChangeSetRequest::getStackPolicyDuringUpdateURL()const
+{
+	return stackPolicyDuringUpdateURL_;
+}
+
+void CreateChangeSetRequest::setStackPolicyDuringUpdateURL(const std::string& stackPolicyDuringUpdateURL)
+{
+	stackPolicyDuringUpdateURL_ = stackPolicyDuringUpdateURL;
+	setCoreParameter("StackPolicyDuringUpdateURL", stackPolicyDuringUpdateURL);
+}
+
+std::string CreateChangeSetRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void CreateChangeSetRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setCoreParameter("ClientToken", clientToken);
+}
+
+std::string CreateChangeSetRequest::getTemplateBody()const
+{
+	return templateBody_;
+}
+
+void CreateChangeSetRequest::setTemplateBody(const std::string& templateBody)
+{
+	templateBody_ = templateBody;
+	setCoreParameter("TemplateBody", templateBody);
+}
+
+std::string CreateChangeSetRequest::getStackId()const
+{
+	return stackId_;
+}
+
+void CreateChangeSetRequest::setStackId(const std::string& stackId)
+{
+	stackId_ = stackId;
+	setCoreParameter("StackId", stackId);
+}
+
+std::string CreateChangeSetRequest::getChangeSetType()const
+{
+	return changeSetType_;
+}
+
+void CreateChangeSetRequest::setChangeSetType(const std::string& changeSetType)
+{
+	changeSetType_ = changeSetType;
+	setCoreParameter("ChangeSetType", changeSetType);
+}
+
+std::string CreateChangeSetRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateChangeSetRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setCoreParameter("Description", description);
+}
+
+bool CreateChangeSetRequest::getDisableRollback()const
+{
+	return disableRollback_;
+}
+
+void CreateChangeSetRequest::setDisableRollback(bool disableRollback)
+{
+	disableRollback_ = disableRollback;
+	setCoreParameter("DisableRollback", disableRollback ? "true" : "false");
+}
+
+std::string CreateChangeSetRequest::getUpdateAllowPolicy()const
+{
+	return updateAllowPolicy_;
+}
+
+void CreateChangeSetRequest::setUpdateAllowPolicy(const std::string& updateAllowPolicy)
+{
+	updateAllowPolicy_ = updateAllowPolicy;
+	setCoreParameter("UpdateAllowPolicy", updateAllowPolicy);
+}
+
+long CreateChangeSetRequest::getTimeoutInMinutes()const
+{
+	return timeoutInMinutes_;
+}
+
+void CreateChangeSetRequest::setTimeoutInMinutes(long timeoutInMinutes)
+{
+	timeoutInMinutes_ = timeoutInMinutes;
+	setCoreParameter("TimeoutInMinutes", std::to_string(timeoutInMinutes));
+}
+
+bool CreateChangeSetRequest::getUsePreviousParameters()const
+{
+	return usePreviousParameters_;
+}
+
+void CreateChangeSetRequest::setUsePreviousParameters(bool usePreviousParameters)
+{
+	usePreviousParameters_ = usePreviousParameters;
+	setCoreParameter("UsePreviousParameters", usePreviousParameters ? "true" : "false");
+}
+
+std::string CreateChangeSetRequest::getTemplateURL()const
+{
+	return templateURL_;
+}
+
+void CreateChangeSetRequest::setTemplateURL(const std::string& templateURL)
+{
+	templateURL_ = templateURL;
+	setCoreParameter("TemplateURL", templateURL);
+}
+
+std::string CreateChangeSetRequest::getOrderSource()const
+{
+	return orderSource_;
+}
+
+void CreateChangeSetRequest::setOrderSource(const std::string& orderSource)
+{
+	orderSource_ = orderSource;
+	setCoreParameter("OrderSource", orderSource);
+}
+
+std::string CreateChangeSetRequest::getActivityId()const
+{
+	return activityId_;
+}
+
+void CreateChangeSetRequest::setActivityId(const std::string& activityId)
+{
+	activityId_ = activityId;
+	setCoreParameter("ActivityId", activityId);
+}
+
+std::string CreateChangeSetRequest::getStackPolicyDuringUpdateBody()const
+{
+	return stackPolicyDuringUpdateBody_;
+}
+
+void CreateChangeSetRequest::setStackPolicyDuringUpdateBody(const std::string& stackPolicyDuringUpdateBody)
+{
+	stackPolicyDuringUpdateBody_ = stackPolicyDuringUpdateBody;
+	setCoreParameter("StackPolicyDuringUpdateBody", stackPolicyDuringUpdateBody);
+}
+
+std::vector<std::string> CreateChangeSetRequest::getNotificationURLs()const
+{
+	return notificationURLs_;
+}
+
+void CreateChangeSetRequest::setNotificationURLs(const std::vector<std::string>& notificationURLs)
+{
+	notificationURLs_ = notificationURLs;
+	for(int i = 0; i!= notificationURLs.size(); i++)
+		setCoreParameter("NotificationURLs."+ std::to_string(i), notificationURLs.at(i));
+}
+
+std::string CreateChangeSetRequest::getStackPolicyURL()const
+{
+	return stackPolicyURL_;
+}
+
+void CreateChangeSetRequest::setStackPolicyURL(const std::string& stackPolicyURL)
+{
+	stackPolicyURL_ = stackPolicyURL;
+	setCoreParameter("StackPolicyURL", stackPolicyURL);
+}
+
+std::string CreateChangeSetRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateChangeSetRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string CreateChangeSetRequest::getChangeSetName()const
+{
+	return changeSetName_;
+}
+
+void CreateChangeSetRequest::setChangeSetName(const std::string& changeSetName)
+{
+	changeSetName_ = changeSetName;
+	setCoreParameter("ChangeSetName", changeSetName);
+}
+
+std::string CreateChangeSetRequest::getStackName()const
+{
+	return stackName_;
+}
+
+void CreateChangeSetRequest::setStackName(const std::string& stackName)
+{
+	stackName_ = stackName;
+	setCoreParameter("StackName", stackName);
+}
+
+std::vector<CreateChangeSetRequest::Parameters> CreateChangeSetRequest::getParameters()const
+{
+	return parameters_;
+}
+
+void CreateChangeSetRequest::setParameters(const std::vector<Parameters>& parameters)
+{
+	parameters_ = parameters;
+	int i = 0;
+	for(int i = 0; i!= parameters.size(); i++)	{
+		auto obj = parameters.at(i);
+		std::string str ="Parameters."+ std::to_string(i);
+		setCoreParameter(str + ".ParameterValue", obj.parameterValue);
+		setCoreParameter(str + ".ParameterKey", obj.parameterKey);
+	}
+}
+
+std::string CreateChangeSetRequest::getStackPolicyBody()const
+{
+	return stackPolicyBody_;
+}
+
+void CreateChangeSetRequest::setStackPolicyBody(const std::string& stackPolicyBody)
+{
+	stackPolicyBody_ = stackPolicyBody;
+	setCoreParameter("StackPolicyBody", stackPolicyBody);
+}
+
+std::string CreateChangeSetRequest::getChannelId()const
+{
+	return channelId_;
+}
+
+void CreateChangeSetRequest::setChannelId(const std::string& channelId)
+{
+	channelId_ = channelId;
+	setCoreParameter("ChannelId", channelId);
+}
+

ros/src/model/CreateChangeSetResult.cc

@@ -0,0 +1,62 @@
+/*
+ * 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/ros/model/CreateChangeSetResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+CreateChangeSetResult::CreateChangeSetResult() :
+	ServiceResult()
+{}
+
+CreateChangeSetResult::CreateChangeSetResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateChangeSetResult::~CreateChangeSetResult()
+{}
+
+void CreateChangeSetResult::parse(const std::string &payload)
+{
+	Json::CharReaderBuilder builder;
+	Json::CharReader *reader = builder.newCharReader();
+	Json::Value *val;
+	Json::Value value;
+	JSONCPP_STRING *errs;
+	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
+	value = *val;
+	setRequestId(value["RequestId"].asString());
+	if(!value["ChangeSetId"].isNull())
+		changeSetId_ = value["ChangeSetId"].asString();
+	if(!value["StackId"].isNull())
+		stackId_ = value["StackId"].asString();
+
+}
+
+std::string CreateChangeSetResult::getChangeSetId()const
+{
+	return changeSetId_;
+}
+
+std::string CreateChangeSetResult::getStackId()const
+{
+	return stackId_;
+}
+

ros/src/model/CreateStackRequest.cc

@@ -0,0 +1,188 @@
+/*
+ * 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/ros/model/CreateStackRequest.h>
+
+using AlibabaCloud::ROS::Model::CreateStackRequest;
+
+CreateStackRequest::CreateStackRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "CreateStack")
+{}
+
+CreateStackRequest::~CreateStackRequest()
+{}
+
+std::string CreateStackRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void CreateStackRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setCoreParameter("ClientToken", clientToken);
+}
+
+std::string CreateStackRequest::getTemplateBody()const
+{
+	return templateBody_;
+}
+
+void CreateStackRequest::setTemplateBody(const std::string& templateBody)
+{
+	templateBody_ = templateBody;
+	setCoreParameter("TemplateBody", templateBody);
+}
+
+bool CreateStackRequest::getDisableRollback()const
+{
+	return disableRollback_;
+}
+
+void CreateStackRequest::setDisableRollback(bool disableRollback)
+{
+	disableRollback_ = disableRollback;
+	setCoreParameter("DisableRollback", disableRollback ? "true" : "false");
+}
+
+long CreateStackRequest::getTimeoutInMinutes()const
+{
+	return timeoutInMinutes_;
+}
+
+void CreateStackRequest::setTimeoutInMinutes(long timeoutInMinutes)
+{
+	timeoutInMinutes_ = timeoutInMinutes;
+	setCoreParameter("TimeoutInMinutes", std::to_string(timeoutInMinutes));
+}
+
+std::string CreateStackRequest::getOrderSource()const
+{
+	return orderSource_;
+}
+
+void CreateStackRequest::setOrderSource(const std::string& orderSource)
+{
+	orderSource_ = orderSource;
+	setCoreParameter("OrderSource", orderSource);
+}
+
+std::string CreateStackRequest::getTemplateURL()const
+{
+	return templateURL_;
+}
+
+void CreateStackRequest::setTemplateURL(const std::string& templateURL)
+{
+	templateURL_ = templateURL;
+	setCoreParameter("TemplateURL", templateURL);
+}
+
+std::string CreateStackRequest::getActivityId()const
+{
+	return activityId_;
+}
+
+void CreateStackRequest::setActivityId(const std::string& activityId)
+{
+	activityId_ = activityId;
+	setCoreParameter("ActivityId", activityId);
+}
+
+std::vector<std::string> CreateStackRequest::getNotificationURLs()const
+{
+	return notificationURLs_;
+}
+
+void CreateStackRequest::setNotificationURLs(const std::vector<std::string>& notificationURLs)
+{
+	notificationURLs_ = notificationURLs;
+	for(int i = 0; i!= notificationURLs.size(); i++)
+		setCoreParameter("NotificationURLs."+ std::to_string(i), notificationURLs.at(i));
+}
+
+std::string CreateStackRequest::getStackPolicyURL()const
+{
+	return stackPolicyURL_;
+}
+
+void CreateStackRequest::setStackPolicyURL(const std::string& stackPolicyURL)
+{
+	stackPolicyURL_ = stackPolicyURL;
+	setCoreParameter("StackPolicyURL", stackPolicyURL);
+}
+
+std::string CreateStackRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateStackRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string CreateStackRequest::getStackName()const
+{
+	return stackName_;
+}
+
+void CreateStackRequest::setStackName(const std::string& stackName)
+{
+	stackName_ = stackName;
+	setCoreParameter("StackName", stackName);
+}
+
+std::vector<CreateStackRequest::Parameters> CreateStackRequest::getParameters()const
+{
+	return parameters_;
+}
+
+void CreateStackRequest::setParameters(const std::vector<Parameters>& parameters)
+{
+	parameters_ = parameters;
+	int i = 0;
+	for(int i = 0; i!= parameters.size(); i++)	{
+		auto obj = parameters.at(i);
+		std::string str ="Parameters."+ std::to_string(i);
+		setCoreParameter(str + ".ParameterValue", obj.parameterValue);
+		setCoreParameter(str + ".ParameterKey", obj.parameterKey);
+	}
+}
+
+std::string CreateStackRequest::getStackPolicyBody()const
+{
+	return stackPolicyBody_;
+}
+
+void CreateStackRequest::setStackPolicyBody(const std::string& stackPolicyBody)
+{
+	stackPolicyBody_ = stackPolicyBody;
+	setCoreParameter("StackPolicyBody", stackPolicyBody);
+}
+
+std::string CreateStackRequest::getChannelId()const
+{
+	return channelId_;
+}
+
+void CreateStackRequest::setChannelId(const std::string& channelId)
+{
+	channelId_ = channelId;
+	setCoreParameter("ChannelId", channelId);
+}
+

ros/src/model/CreateStackResult.cc

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ros/model/CreateStackResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+CreateStackResult::CreateStackResult() :
+	ServiceResult()
+{}
+
+CreateStackResult::CreateStackResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateStackResult::~CreateStackResult()
+{}
+
+void CreateStackResult::parse(const std::string &payload)
+{
+	Json::CharReaderBuilder builder;
+	Json::CharReader *reader = builder.newCharReader();
+	Json::Value *val;
+	Json::Value value;
+	JSONCPP_STRING *errs;
+	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
+	value = *val;
+	setRequestId(value["RequestId"].asString());
+	if(!value["StackId"].isNull())
+		stackId_ = value["StackId"].asString();
+
+}
+
+std::string CreateStackResult::getStackId()const
+{
+	return stackId_;
+}
+

ros/src/model/DeleteChangeSetRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/ros/model/DeleteChangeSetRequest.h>
+
+using AlibabaCloud::ROS::Model::DeleteChangeSetRequest;
+
+DeleteChangeSetRequest::DeleteChangeSetRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "DeleteChangeSet")
+{}
+
+DeleteChangeSetRequest::~DeleteChangeSetRequest()
+{}
+
+std::string DeleteChangeSetRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteChangeSetRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string DeleteChangeSetRequest::getChangeSetId()const
+{
+	return changeSetId_;
+}
+
+void DeleteChangeSetRequest::setChangeSetId(const std::string& changeSetId)
+{
+	changeSetId_ = changeSetId;
+	setCoreParameter("ChangeSetId", changeSetId);
+}
+

ros/src/model/DeleteChangeSetResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/ros/model/DeleteChangeSetResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+DeleteChangeSetResult::DeleteChangeSetResult() :
+	ServiceResult()
+{}
+
+DeleteChangeSetResult::DeleteChangeSetResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteChangeSetResult::~DeleteChangeSetResult()
+{}
+
+void DeleteChangeSetResult::parse(const std::string &payload)
+{
+	Json::CharReaderBuilder builder;
+	Json::CharReader *reader = builder.newCharReader();
+	Json::Value *val;
+	Json::Value value;
+	JSONCPP_STRING *errs;
+	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
+	value = *val;
+	setRequestId(value["RequestId"].asString());
+
+}
+

ros/src/model/DeleteStackRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/ros/model/DeleteStackRequest.h>
+
+using AlibabaCloud::ROS::Model::DeleteStackRequest;
+
+DeleteStackRequest::DeleteStackRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "DeleteStack")
+{}
+
+DeleteStackRequest::~DeleteStackRequest()
+{}
+
+std::string DeleteStackRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteStackRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+bool DeleteStackRequest::getRetainAllResources()const
+{
+	return retainAllResources_;
+}
+
+void DeleteStackRequest::setRetainAllResources(bool retainAllResources)
+{
+	retainAllResources_ = retainAllResources;
+	setCoreParameter("RetainAllResources", retainAllResources ? "true" : "false");
+}
+
+std::string DeleteStackRequest::getStackId()const
+{
+	return stackId_;
+}
+
+void DeleteStackRequest::setStackId(const std::string& stackId)
+{
+	stackId_ = stackId;
+	setCoreParameter("StackId", stackId);
+}
+

ros/src/model/DeleteStackResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/ros/model/DeleteStackResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+DeleteStackResult::DeleteStackResult() :
+	ServiceResult()
+{}
+
+DeleteStackResult::DeleteStackResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteStackResult::~DeleteStackResult()
+{}
+
+void DeleteStackResult::parse(const std::string &payload)
+{
+	Json::CharReaderBuilder builder;
+	Json::CharReader *reader = builder.newCharReader();
+	Json::Value *val;
+	Json::Value value;
+	JSONCPP_STRING *errs;
+	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
+	value = *val;
+	setRequestId(value["RequestId"].asString());
+
+}
+

ros/src/model/DescribeRegionsRequest.cc

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ros/model/DescribeRegionsRequest.h>
+
+using AlibabaCloud::ROS::Model::DescribeRegionsRequest;
+
+DescribeRegionsRequest::DescribeRegionsRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "DescribeRegions")
+{}
+
+DescribeRegionsRequest::~DescribeRegionsRequest()
+{}
+
+std::string DescribeRegionsRequest::getAcceptLanguage()const
+{
+	return acceptLanguage_;
+}
+
+void DescribeRegionsRequest::setAcceptLanguage(const std::string& acceptLanguage)
+{
+	acceptLanguage_ = acceptLanguage;
+	setCoreParameter("AcceptLanguage", acceptLanguage);
+}
+

ros/src/model/DescribeRegionsResult.cc

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ros/model/DescribeRegionsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+DescribeRegionsResult::DescribeRegionsResult() :
+	ServiceResult()
+{}
+
+DescribeRegionsResult::DescribeRegionsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeRegionsResult::~DescribeRegionsResult()
+{}
+
+void DescribeRegionsResult::parse(const std::string &payload)
+{
+	Json::CharReaderBuilder builder;
+	Json::CharReader *reader = builder.newCharReader();
+	Json::Value *val;
+	Json::Value value;
+	JSONCPP_STRING *errs;
+	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
+	value = *val;
+	setRequestId(value["RequestId"].asString());
+	auto allRegions = value["Regions"]["Region"];
+	for (auto value : allRegions)
+	{
+		Region regionsObject;
+		if(!value["RegionId"].isNull())
+			regionsObject.regionId = value["RegionId"].asString();
+		if(!value["LocalName"].isNull())
+			regionsObject.localName = value["LocalName"].asString();
+		if(!value["RegionEndpoint"].isNull())
+			regionsObject.regionEndpoint = value["RegionEndpoint"].asString();
+		regions_.push_back(regionsObject);
+	}
+
+}
+
+std::vector<DescribeRegionsResult::Region> DescribeRegionsResult::getRegions()const
+{
+	return regions_;
+}
+

ros/src/model/ExecuteChangeSetRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/ros/model/ExecuteChangeSetRequest.h>
+
+using AlibabaCloud::ROS::Model::ExecuteChangeSetRequest;
+
+ExecuteChangeSetRequest::ExecuteChangeSetRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "ExecuteChangeSet")
+{}
+
+ExecuteChangeSetRequest::~ExecuteChangeSetRequest()
+{}
+
+std::string ExecuteChangeSetRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ExecuteChangeSetRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string ExecuteChangeSetRequest::getChangeSetId()const
+{
+	return changeSetId_;
+}
+
+void ExecuteChangeSetRequest::setChangeSetId(const std::string& changeSetId)
+{
+	changeSetId_ = changeSetId;
+	setCoreParameter("ChangeSetId", changeSetId);
+}
+

ros/src/model/ExecuteChangeSetResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/ros/model/ExecuteChangeSetResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+ExecuteChangeSetResult::ExecuteChangeSetResult() :
+	ServiceResult()
+{}
+
+ExecuteChangeSetResult::ExecuteChangeSetResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ExecuteChangeSetResult::~ExecuteChangeSetResult()
+{}
+
+void ExecuteChangeSetResult::parse(const std::string &payload)
+{
+	Json::CharReaderBuilder builder;
+	Json::CharReader *reader = builder.newCharReader();
+	Json::Value *val;
+	Json::Value value;
+	JSONCPP_STRING *errs;
+	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
+	value = *val;
+	setRequestId(value["RequestId"].asString());
+
+}
+

ros/src/model/GetChangeSetRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/ros/model/GetChangeSetRequest.h>
+
+using AlibabaCloud::ROS::Model::GetChangeSetRequest;
+
+GetChangeSetRequest::GetChangeSetRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "GetChangeSet")
+{}
+
+GetChangeSetRequest::~GetChangeSetRequest()
+{}
+
+std::string GetChangeSetRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GetChangeSetRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string GetChangeSetRequest::getChangeSetId()const
+{
+	return changeSetId_;
+}
+
+void GetChangeSetRequest::setChangeSetId(const std::string& changeSetId)
+{
+	changeSetId_ = changeSetId;
+	setCoreParameter("ChangeSetId", changeSetId);
+}
+
+bool GetChangeSetRequest::getShowTemplate()const
+{
+	return showTemplate_;
+}
+
+void GetChangeSetRequest::setShowTemplate(bool showTemplate)
+{
+	showTemplate_ = showTemplate;
+	setCoreParameter("ShowTemplate", showTemplate ? "true" : "false");
+}
+

ros/src/model/GetChangeSetResult.cc

@@ -0,0 +1,162 @@
+/*
+ * 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/ros/model/GetChangeSetResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+GetChangeSetResult::GetChangeSetResult() :
+	ServiceResult()
+{}
+
+GetChangeSetResult::GetChangeSetResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetChangeSetResult::~GetChangeSetResult()
+{}
+
+void GetChangeSetResult::parse(const std::string &payload)
+{
+	Json::CharReaderBuilder builder;
+	Json::CharReader *reader = builder.newCharReader();
+	Json::Value *val;
+	Json::Value value;
+	JSONCPP_STRING *errs;
+	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
+	value = *val;
+	setRequestId(value["RequestId"].asString());
+	auto allParameters = value["Parameters"]["Parameter"];
+	for (auto value : allParameters)
+	{
+		Parameter parametersObject;
+		if(!value["ParameterKey"].isNull())
+			parametersObject.parameterKey = value["ParameterKey"].asString();
+		if(!value["ParameterValue"].isNull())
+			parametersObject.parameterValue = value["ParameterValue"].asString();
+		parameters_.push_back(parametersObject);
+	}
+	auto allChanges = value["Changes"]["Change"];
+	for (const auto &item : allChanges)
+		changes_.push_back(item.asString());
+	if(!value["ChangeSetId"].isNull())
+		changeSetId_ = value["ChangeSetId"].asString();
+	if(!value["ChangeSetName"].isNull())
+		changeSetName_ = value["ChangeSetName"].asString();
+	if(!value["ChangeSetType"].isNull())
+		changeSetType_ = value["ChangeSetType"].asString();
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
+	if(!value["DisableRollback"].isNull())
+		disableRollback_ = value["DisableRollback"].asString() == "true";
+	if(!value["ExecutionStatus"].isNull())
+		executionStatus_ = value["ExecutionStatus"].asString();
+	if(!value["RegionId"].isNull())
+		regionId_ = value["RegionId"].asString();
+	if(!value["StackId"].isNull())
+		stackId_ = value["StackId"].asString();
+	if(!value["StackName"].isNull())
+		stackName_ = value["StackName"].asString();
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["TemplateBody"].isNull())
+		templateBody_ = value["TemplateBody"].asString();
+	if(!value["TimeoutInMinutes"].isNull())
+		timeoutInMinutes_ = std::stoi(value["TimeoutInMinutes"].asString());
+
+}
+
+std::vector<std::string> GetChangeSetResult::getChanges()const
+{
+	return changes_;
+}
+
+std::string GetChangeSetResult::getStatus()const
+{
+	return status_;
+}
+
+std::vector<GetChangeSetResult::Parameter> GetChangeSetResult::getParameters()const
+{
+	return parameters_;
+}
+
+std::string GetChangeSetResult::getDescription()const
+{
+	return description_;
+}
+
+std::string GetChangeSetResult::getCreateTime()const
+{
+	return createTime_;
+}
+
+std::string GetChangeSetResult::getTemplateBody()const
+{
+	return templateBody_;
+}
+
+std::string GetChangeSetResult::getChangeSetName()const
+{
+	return changeSetName_;
+}
+
+std::string GetChangeSetResult::getChangeSetId()const
+{
+	return changeSetId_;
+}
+
+std::string GetChangeSetResult::getExecutionStatus()const
+{
+	return executionStatus_;
+}
+
+std::string GetChangeSetResult::getChangeSetType()const
+{
+	return changeSetType_;
+}
+
+std::string GetChangeSetResult::getRegionId()const
+{
+	return regionId_;
+}
+
+bool GetChangeSetResult::getDisableRollback()const
+{
+	return disableRollback_;
+}
+
+std::string GetChangeSetResult::getStackName()const
+{
+	return stackName_;
+}
+
+std::string GetChangeSetResult::getStackId()const
+{
+	return stackId_;
+}
+
+int GetChangeSetResult::getTimeoutInMinutes()const
+{
+	return timeoutInMinutes_;
+}
+

ros/src/model/GetResourceTypeRequest.cc

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ros/model/GetResourceTypeRequest.h>
+
+using AlibabaCloud::ROS::Model::GetResourceTypeRequest;
+
+GetResourceTypeRequest::GetResourceTypeRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "GetResourceType")
+{}
+
+GetResourceTypeRequest::~GetResourceTypeRequest()
+{}
+
+std::string GetResourceTypeRequest::getResourceType()const
+{
+	return resourceType_;
+}
+
+void GetResourceTypeRequest::setResourceType(const std::string& resourceType)
+{
+	resourceType_ = resourceType;
+	setCoreParameter("ResourceType", resourceType);
+}
+

ros/src/model/GetResourceTypeResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/ros/model/GetResourceTypeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+GetResourceTypeResult::GetResourceTypeResult() :
+	ServiceResult()
+{}
+
+GetResourceTypeResult::GetResourceTypeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetResourceTypeResult::~GetResourceTypeResult()
+{}
+
+void GetResourceTypeResult::parse(const std::string &payload)
+{
+	Json::CharReaderBuilder builder;
+	Json::CharReader *reader = builder.newCharReader();
+	Json::Value *val;
+	Json::Value value;
+	JSONCPP_STRING *errs;
+	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
+	value = *val;
+	setRequestId(value["RequestId"].asString());
+	if(!value["Attributes"].isNull())
+		attributes_ = value["Attributes"].asString();
+	if(!value["Properties"].isNull())
+		properties_ = value["Properties"].asString();
+	if(!value["ResourceType"].isNull())
+		resourceType_ = value["ResourceType"].asString();
+
+}
+
+std::string GetResourceTypeResult::getAttributes()const
+{
+	return attributes_;
+}
+
+std::string GetResourceTypeResult::getResourceType()const
+{
+	return resourceType_;
+}
+
+std::string GetResourceTypeResult::getProperties()const
+{
+	return properties_;
+}
+

ros/src/model/GetResourceTypeTemplateRequest.cc

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ros/model/GetResourceTypeTemplateRequest.h>
+
+using AlibabaCloud::ROS::Model::GetResourceTypeTemplateRequest;
+
+GetResourceTypeTemplateRequest::GetResourceTypeTemplateRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "GetResourceTypeTemplate")
+{}
+
+GetResourceTypeTemplateRequest::~GetResourceTypeTemplateRequest()
+{}
+
+std::string GetResourceTypeTemplateRequest::getResourceType()const
+{
+	return resourceType_;
+}
+
+void GetResourceTypeTemplateRequest::setResourceType(const std::string& resourceType)
+{
+	resourceType_ = resourceType;
+	setCoreParameter("ResourceType", resourceType);
+}
+

ros/src/model/GetResourceTypeTemplateResult.cc

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ros/model/GetResourceTypeTemplateResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+GetResourceTypeTemplateResult::GetResourceTypeTemplateResult() :
+	ServiceResult()
+{}
+
+GetResourceTypeTemplateResult::GetResourceTypeTemplateResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetResourceTypeTemplateResult::~GetResourceTypeTemplateResult()
+{}
+
+void GetResourceTypeTemplateResult::parse(const std::string &payload)
+{
+	Json::CharReaderBuilder builder;
+	Json::CharReader *reader = builder.newCharReader();
+	Json::Value *val;
+	Json::Value value;
+	JSONCPP_STRING *errs;
+	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
+	value = *val;
+	setRequestId(value["RequestId"].asString());
+	if(!value["TemplateBody"].isNull())
+		templateBody_ = value["TemplateBody"].asString();
+
+}
+
+std::string GetResourceTypeTemplateResult::getTemplateBody()const
+{
+	return templateBody_;
+}
+

ros/src/model/GetStackPolicyRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/ros/model/GetStackPolicyRequest.h>
+
+using AlibabaCloud::ROS::Model::GetStackPolicyRequest;
+
+GetStackPolicyRequest::GetStackPolicyRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "GetStackPolicy")
+{}
+
+GetStackPolicyRequest::~GetStackPolicyRequest()
+{}
+
+std::string GetStackPolicyRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GetStackPolicyRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string GetStackPolicyRequest::getStackId()const
+{
+	return stackId_;
+}
+
+void GetStackPolicyRequest::setStackId(const std::string& stackId)
+{
+	stackId_ = stackId;
+	setCoreParameter("StackId", stackId);
+}
+

ros/src/model/GetStackPolicyResult.cc

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ros/model/GetStackPolicyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+GetStackPolicyResult::GetStackPolicyResult() :
+	ServiceResult()
+{}
+
+GetStackPolicyResult::GetStackPolicyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetStackPolicyResult::~GetStackPolicyResult()
+{}
+
+void GetStackPolicyResult::parse(const std::string &payload)
+{
+	Json::CharReaderBuilder builder;
+	Json::CharReader *reader = builder.newCharReader();
+	Json::Value *val;
+	Json::Value value;
+	JSONCPP_STRING *errs;
+	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
+	value = *val;
+	setRequestId(value["RequestId"].asString());
+	if(!value["StackPolicyBody"].isNull())
+		stackPolicyBody_ = value["StackPolicyBody"].asString();
+
+}
+
+std::string GetStackPolicyResult::getStackPolicyBody()const
+{
+	return stackPolicyBody_;
+}
+

ros/src/model/GetStackRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/ros/model/GetStackRequest.h>
+
+using AlibabaCloud::ROS::Model::GetStackRequest;
+
+GetStackRequest::GetStackRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "GetStack")
+{}
+
+GetStackRequest::~GetStackRequest()
+{}
+
+std::string GetStackRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GetStackRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string GetStackRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void GetStackRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setCoreParameter("ClientToken", clientToken);
+}
+
+std::string GetStackRequest::getStackId()const
+{
+	return stackId_;
+}
+
+void GetStackRequest::setStackId(const std::string& stackId)
+{
+	stackId_ = stackId;
+	setCoreParameter("StackId", stackId);
+}
+

ros/src/model/GetStackResourceRequest.cc

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ros/model/GetStackResourceRequest.h>
+
+using AlibabaCloud::ROS::Model::GetStackResourceRequest;
+
+GetStackResourceRequest::GetStackResourceRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "GetStackResource")
+{}
+
+GetStackResourceRequest::~GetStackResourceRequest()
+{}
+
+std::string GetStackResourceRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void GetStackResourceRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setCoreParameter("ClientToken", clientToken);
+}
+
+std::string GetStackResourceRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GetStackResourceRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string GetStackResourceRequest::getStackId()const
+{
+	return stackId_;
+}
+
+void GetStackResourceRequest::setStackId(const std::string& stackId)
+{
+	stackId_ = stackId;
+	setCoreParameter("StackId", stackId);
+}
+
+std::string GetStackResourceRequest::getLogicalResourceId()const
+{
+	return logicalResourceId_;
+}
+
+void GetStackResourceRequest::setLogicalResourceId(const std::string& logicalResourceId)
+{
+	logicalResourceId_ = logicalResourceId;
+	setCoreParameter("LogicalResourceId", logicalResourceId);
+}
+
+bool GetStackResourceRequest::getShowResourceAttributes()const
+{
+	return showResourceAttributes_;
+}
+
+void GetStackResourceRequest::setShowResourceAttributes(bool showResourceAttributes)
+{
+	showResourceAttributes_ = showResourceAttributes;
+	setCoreParameter("ShowResourceAttributes", showResourceAttributes ? "true" : "false");
+}
+

ros/src/model/GetStackResourceResult.cc

@@ -0,0 +1,133 @@
+/*
+ * 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/ros/model/GetStackResourceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+GetStackResourceResult::GetStackResourceResult() :
+	ServiceResult()
+{}
+
+GetStackResourceResult::GetStackResourceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetStackResourceResult::~GetStackResourceResult()
+{}
+
+void GetStackResourceResult::parse(const std::string &payload)
+{
+	Json::CharReaderBuilder builder;
+	Json::CharReader *reader = builder.newCharReader();
+	Json::Value *val;
+	Json::Value value;
+	JSONCPP_STRING *errs;
+	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
+	value = *val;
+	setRequestId(value["RequestId"].asString());
+	auto allResourceAttributes = value["ResourceAttributes"]["ResourceAttribute"];
+	for (const auto &item : allResourceAttributes)
+		resourceAttributes_.push_back(item.asString());
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
+	if(!value["LogicalResourceId"].isNull())
+		logicalResourceId_ = value["LogicalResourceId"].asString();
+	if(!value["Metadata"].isNull())
+		metadata_ = value["Metadata"].asString();
+	if(!value["PhysicalResourceId"].isNull())
+		physicalResourceId_ = value["PhysicalResourceId"].asString();
+	if(!value["ResourceType"].isNull())
+		resourceType_ = value["ResourceType"].asString();
+	if(!value["StackId"].isNull())
+		stackId_ = value["StackId"].asString();
+	if(!value["StackName"].isNull())
+		stackName_ = value["StackName"].asString();
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["StatusReason"].isNull())
+		statusReason_ = value["StatusReason"].asString();
+	if(!value["UpdateTime"].isNull())
+		updateTime_ = value["UpdateTime"].asString();
+
+}
+
+std::string GetStackResourceResult::getStatus()const
+{
+	return status_;
+}
+
+std::string GetStackResourceResult::getLogicalResourceId()const
+{
+	return logicalResourceId_;
+}
+
+std::string GetStackResourceResult::getDescription()const
+{
+	return description_;
+}
+
+std::string GetStackResourceResult::getPhysicalResourceId()const
+{
+	return physicalResourceId_;
+}
+
+std::string GetStackResourceResult::getStatusReason()const
+{
+	return statusReason_;
+}
+
+std::string GetStackResourceResult::getCreateTime()const
+{
+	return createTime_;
+}
+
+std::string GetStackResourceResult::getMetadata()const
+{
+	return metadata_;
+}
+
+std::string GetStackResourceResult::getUpdateTime()const
+{
+	return updateTime_;
+}
+
+std::string GetStackResourceResult::getResourceType()const
+{
+	return resourceType_;
+}
+
+std::vector<std::string> GetStackResourceResult::getResourceAttributes()const
+{
+	return resourceAttributes_;
+}
+
+std::string GetStackResourceResult::getStackName()const
+{
+	return stackName_;
+}
+
+std::string GetStackResourceResult::getStackId()const
+{
+	return stackId_;
+}
+

ros/src/model/GetStackResult.cc

@@ -0,0 +1,163 @@
+/*
+ * 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/ros/model/GetStackResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+GetStackResult::GetStackResult() :
+	ServiceResult()
+{}
+
+GetStackResult::GetStackResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetStackResult::~GetStackResult()
+{}
+
+void GetStackResult::parse(const std::string &payload)
+{
+	Json::CharReaderBuilder builder;
+	Json::CharReader *reader = builder.newCharReader();
+	Json::Value *val;
+	Json::Value value;
+	JSONCPP_STRING *errs;
+	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
+	value = *val;
+	setRequestId(value["RequestId"].asString());
+	auto allParameters = value["Parameters"]["Parameter"];
+	for (auto value : allParameters)
+	{
+		Parameter parametersObject;
+		if(!value["ParameterKey"].isNull())
+			parametersObject.parameterKey = value["ParameterKey"].asString();
+		if(!value["ParameterValue"].isNull())
+			parametersObject.parameterValue = value["ParameterValue"].asString();
+		parameters_.push_back(parametersObject);
+	}
+	auto allOutputs = value["Outputs"]["Output"];
+	for (const auto &item : allOutputs)
+		outputs_.push_back(item.asString());
+	auto allNotificationURLs = value["NotificationURLs"]["NotificationURL"];
+	for (const auto &item : allNotificationURLs)
+		notificationURLs_.push_back(item.asString());
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
+	if(!value["DisableRollback"].isNull())
+		disableRollback_ = value["DisableRollback"].asString() == "true";
+	if(!value["RegionId"].isNull())
+		regionId_ = value["RegionId"].asString();
+	if(!value["StackId"].isNull())
+		stackId_ = value["StackId"].asString();
+	if(!value["StackName"].isNull())
+		stackName_ = value["StackName"].asString();
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["StatusReason"].isNull())
+		statusReason_ = value["StatusReason"].asString();
+	if(!value["TemplateDescription"].isNull())
+		templateDescription_ = value["TemplateDescription"].asString();
+	if(!value["TimeoutInMinutes"].isNull())
+		timeoutInMinutes_ = std::stoi(value["TimeoutInMinutes"].asString());
+	if(!value["UpdateTime"].isNull())
+		updateTime_ = value["UpdateTime"].asString();
+	if(!value["ParentStackId"].isNull())
+		parentStackId_ = value["ParentStackId"].asString();
+
+}
+
+std::string GetStackResult::getStatus()const
+{
+	return status_;
+}
+
+std::vector<GetStackResult::Parameter> GetStackResult::getParameters()const
+{
+	return parameters_;
+}
+
+std::string GetStackResult::getDescription()const
+{
+	return description_;
+}
+
+std::string GetStackResult::getStatusReason()const
+{
+	return statusReason_;
+}
+
+std::string GetStackResult::getParentStackId()const
+{
+	return parentStackId_;
+}
+
+std::string GetStackResult::getCreateTime()const
+{
+	return createTime_;
+}
+
+std::string GetStackResult::getTemplateDescription()const
+{
+	return templateDescription_;
+}
+
+std::vector<std::string> GetStackResult::getOutputs()const
+{
+	return outputs_;
+}
+
+std::string GetStackResult::getUpdateTime()const
+{
+	return updateTime_;
+}
+
+std::string GetStackResult::getRegionId()const
+{
+	return regionId_;
+}
+
+std::vector<std::string> GetStackResult::getNotificationURLs()const
+{
+	return notificationURLs_;
+}
+
+bool GetStackResult::getDisableRollback()const
+{
+	return disableRollback_;
+}
+
+std::string GetStackResult::getStackName()const
+{
+	return stackName_;
+}
+
+std::string GetStackResult::getStackId()const
+{
+	return stackId_;
+}
+
+int GetStackResult::getTimeoutInMinutes()const
+{
+	return timeoutInMinutes_;
+}
+

ros/src/model/GetTemplateEstimateCostRequest.cc

@@ -0,0 +1,88 @@
+/*
+ * 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/ros/model/GetTemplateEstimateCostRequest.h>
+
+using AlibabaCloud::ROS::Model::GetTemplateEstimateCostRequest;
+
+GetTemplateEstimateCostRequest::GetTemplateEstimateCostRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "GetTemplateEstimateCost")
+{}
+
+GetTemplateEstimateCostRequest::~GetTemplateEstimateCostRequest()
+{}
+
+std::string GetTemplateEstimateCostRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GetTemplateEstimateCostRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string GetTemplateEstimateCostRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void GetTemplateEstimateCostRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setCoreParameter("ClientToken", clientToken);
+}
+
+std::string GetTemplateEstimateCostRequest::getTemplateBody()const
+{
+	return templateBody_;
+}
+
+void GetTemplateEstimateCostRequest::setTemplateBody(const std::string& templateBody)
+{
+	templateBody_ = templateBody;
+	setCoreParameter("TemplateBody", templateBody);
+}
+
+std::vector<GetTemplateEstimateCostRequest::Parameters> GetTemplateEstimateCostRequest::getParameters()const
+{
+	return parameters_;
+}
+
+void GetTemplateEstimateCostRequest::setParameters(const std::vector<Parameters>& parameters)
+{
+	parameters_ = parameters;
+	int i = 0;
+	for(int i = 0; i!= parameters.size(); i++)	{
+		auto obj = parameters.at(i);
+		std::string str ="Parameters."+ std::to_string(i);
+		setCoreParameter(str + ".ParameterValue", obj.parameterValue);
+		setCoreParameter(str + ".ParameterKey", obj.parameterKey);
+	}
+}
+
+std::string GetTemplateEstimateCostRequest::getTemplateURL()const
+{
+	return templateURL_;
+}
+
+void GetTemplateEstimateCostRequest::setTemplateURL(const std::string& templateURL)
+{
+	templateURL_ = templateURL;
+	setCoreParameter("TemplateURL", templateURL);
+}
+

ros/src/model/GetTemplateEstimateCostResult.cc

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ros/model/GetTemplateEstimateCostResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+GetTemplateEstimateCostResult::GetTemplateEstimateCostResult() :
+	ServiceResult()
+{}
+
+GetTemplateEstimateCostResult::GetTemplateEstimateCostResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetTemplateEstimateCostResult::~GetTemplateEstimateCostResult()
+{}
+
+void GetTemplateEstimateCostResult::parse(const std::string &payload)
+{
+	Json::CharReaderBuilder builder;
+	Json::CharReader *reader = builder.newCharReader();
+	Json::Value *val;
+	Json::Value value;
+	JSONCPP_STRING *errs;
+	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
+	value = *val;
+	setRequestId(value["RequestId"].asString());
+	if(!value["Resources"].isNull())
+		resources_ = value["Resources"].asString();
+
+}
+
+std::string GetTemplateEstimateCostResult::getResources()const
+{
+	return resources_;
+}
+

ros/src/model/GetTemplateRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/ros/model/GetTemplateRequest.h>
+
+using AlibabaCloud::ROS::Model::GetTemplateRequest;
+
+GetTemplateRequest::GetTemplateRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "GetTemplate")
+{}
+
+GetTemplateRequest::~GetTemplateRequest()
+{}
+
+std::string GetTemplateRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GetTemplateRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string GetTemplateRequest::getStackId()const
+{
+	return stackId_;
+}
+
+void GetTemplateRequest::setStackId(const std::string& stackId)
+{
+	stackId_ = stackId;
+	setCoreParameter("StackId", stackId);
+}
+
+std::string GetTemplateRequest::getChangeSetId()const
+{
+	return changeSetId_;
+}
+
+void GetTemplateRequest::setChangeSetId(const std::string& changeSetId)
+{
+	changeSetId_ = changeSetId;
+	setCoreParameter("ChangeSetId", changeSetId);
+}
+

ros/src/model/GetTemplateResult.cc

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ros/model/GetTemplateResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+GetTemplateResult::GetTemplateResult() :
+	ServiceResult()
+{}
+
+GetTemplateResult::GetTemplateResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetTemplateResult::~GetTemplateResult()
+{}
+
+void GetTemplateResult::parse(const std::string &payload)
+{
+	Json::CharReaderBuilder builder;
+	Json::CharReader *reader = builder.newCharReader();
+	Json::Value *val;
+	Json::Value value;
+	JSONCPP_STRING *errs;
+	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
+	value = *val;
+	setRequestId(value["RequestId"].asString());
+	if(!value["TemplateBody"].isNull())
+		templateBody_ = value["TemplateBody"].asString();
+
+}
+
+std::string GetTemplateResult::getTemplateBody()const
+{
+	return templateBody_;
+}
+

ros/src/model/ListChangeSetsRequest.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/ros/model/ListChangeSetsRequest.h>
+
+using AlibabaCloud::ROS::Model::ListChangeSetsRequest;
+
+ListChangeSetsRequest::ListChangeSetsRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "ListChangeSets")
+{}
+
+ListChangeSetsRequest::~ListChangeSetsRequest()
+{}
+
+std::vector<std::string> ListChangeSetsRequest::getExecutionStatus()const
+{
+	return executionStatus_;
+}
+
+void ListChangeSetsRequest::setExecutionStatus(const std::vector<std::string>& executionStatus)
+{
+	executionStatus_ = executionStatus;
+	for(int i = 0; i!= executionStatus.size(); i++)
+		setCoreParameter("ExecutionStatus."+ std::to_string(i), executionStatus.at(i));
+}
+
+std::vector<std::string> ListChangeSetsRequest::getChangeSetName()const
+{
+	return changeSetName_;
+}
+
+void ListChangeSetsRequest::setChangeSetName(const std::vector<std::string>& changeSetName)
+{
+	changeSetName_ = changeSetName;
+	for(int i = 0; i!= changeSetName.size(); i++)
+		setCoreParameter("ChangeSetName."+ std::to_string(i), changeSetName.at(i));
+}
+
+std::string ListChangeSetsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ListChangeSetsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string ListChangeSetsRequest::getStackId()const
+{
+	return stackId_;
+}
+
+void ListChangeSetsRequest::setStackId(const std::string& stackId)
+{
+	stackId_ = stackId;
+	setCoreParameter("StackId", stackId);
+}
+
+long ListChangeSetsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListChangeSetsRequest::setPageSize(long pageSize)
+{
+	pageSize_ = pageSize;
+	setCoreParameter("PageSize", std::to_string(pageSize));
+}
+
+long ListChangeSetsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListChangeSetsRequest::setPageNumber(long pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setCoreParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::vector<std::string> ListChangeSetsRequest::getStatus()const
+{
+	return status_;
+}
+
+void ListChangeSetsRequest::setStatus(const std::vector<std::string>& status)
+{
+	status_ = status;
+	for(int i = 0; i!= status.size(); i++)
+		setCoreParameter("Status."+ std::to_string(i), status.at(i));
+}
+

ros/src/model/ListChangeSetsResult.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/ros/model/ListChangeSetsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+ListChangeSetsResult::ListChangeSetsResult() :
+	ServiceResult()
+{}
+
+ListChangeSetsResult::ListChangeSetsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListChangeSetsResult::~ListChangeSetsResult()
+{}
+
+void ListChangeSetsResult::parse(const std::string &payload)
+{
+	Json::CharReaderBuilder builder;
+	Json::CharReader *reader = builder.newCharReader();
+	Json::Value *val;
+	Json::Value value;
+	JSONCPP_STRING *errs;
+	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
+	value = *val;
+	setRequestId(value["RequestId"].asString());
+	auto allChangeSets = value["ChangeSets"]["ChangeSet"];
+	for (auto value : allChangeSets)
+	{
+		ChangeSet changeSetsObject;
+		if(!value["ChangeSetId"].isNull())
+			changeSetsObject.changeSetId = value["ChangeSetId"].asString();
+		if(!value["ChangeSetName"].isNull())
+			changeSetsObject.changeSetName = value["ChangeSetName"].asString();
+		if(!value["ChangeSetType"].isNull())
+			changeSetsObject.changeSetType = value["ChangeSetType"].asString();
+		if(!value["CreateTime"].isNull())
+			changeSetsObject.createTime = value["CreateTime"].asString();
+		if(!value["Description"].isNull())
+			changeSetsObject.description = value["Description"].asString();
+		if(!value["ExecutionStatus"].isNull())
+			changeSetsObject.executionStatus = value["ExecutionStatus"].asString();
+		if(!value["RegionId"].isNull())
+			changeSetsObject.regionId = value["RegionId"].asString();
+		if(!value["StackId"].isNull())
+			changeSetsObject.stackId = value["StackId"].asString();
+		if(!value["StackName"].isNull())
+			changeSetsObject.stackName = value["StackName"].asString();
+		if(!value["Status"].isNull())
+			changeSetsObject.status = value["Status"].asString();
+		changeSets_.push_back(changeSetsObject);
+	}
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+int ListChangeSetsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int ListChangeSetsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int ListChangeSetsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<ListChangeSetsResult::ChangeSet> ListChangeSetsResult::getChangeSets()const
+{
+	return changeSets_;
+}
+

ros/src/model/ListResourceTypesRequest.cc

@@ -0,0 +1,27 @@
+/*
+ * 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/ros/model/ListResourceTypesRequest.h>
+
+using AlibabaCloud::ROS::Model::ListResourceTypesRequest;
+
+ListResourceTypesRequest::ListResourceTypesRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "ListResourceTypes")
+{}
+
+ListResourceTypesRequest::~ListResourceTypesRequest()
+{}
+

ros/src/model/ListResourceTypesResult.cc

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ros/model/ListResourceTypesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+ListResourceTypesResult::ListResourceTypesResult() :
+	ServiceResult()
+{}
+
+ListResourceTypesResult::ListResourceTypesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListResourceTypesResult::~ListResourceTypesResult()
+{}
+
+void ListResourceTypesResult::parse(const std::string &payload)
+{
+	Json::CharReaderBuilder builder;
+	Json::CharReader *reader = builder.newCharReader();
+	Json::Value *val;
+	Json::Value value;
+	JSONCPP_STRING *errs;
+	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
+	value = *val;
+	setRequestId(value["RequestId"].asString());
+	auto allResourceTypes = value["ResourceTypes"]["ResourceType"];
+	for (const auto &item : allResourceTypes)
+		resourceTypes_.push_back(item.asString());
+
+}
+
+std::vector<std::string> ListResourceTypesResult::getResourceTypes()const
+{
+	return resourceTypes_;
+}
+

ros/src/model/ListStackEventsRequest.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/ros/model/ListStackEventsRequest.h>
+
+using AlibabaCloud::ROS::Model::ListStackEventsRequest;
+
+ListStackEventsRequest::ListStackEventsRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "ListStackEvents")
+{}
+
+ListStackEventsRequest::~ListStackEventsRequest()
+{}
+
+std::string ListStackEventsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ListStackEventsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string ListStackEventsRequest::getStackId()const
+{
+	return stackId_;
+}
+
+void ListStackEventsRequest::setStackId(const std::string& stackId)
+{
+	stackId_ = stackId;
+	setCoreParameter("StackId", stackId);
+}
+
+long ListStackEventsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListStackEventsRequest::setPageSize(long pageSize)
+{
+	pageSize_ = pageSize;
+	setCoreParameter("PageSize", std::to_string(pageSize));
+}
+
+std::vector<std::string> ListStackEventsRequest::getLogicalResourceId()const
+{
+	return logicalResourceId_;
+}
+
+void ListStackEventsRequest::setLogicalResourceId(const std::vector<std::string>& logicalResourceId)
+{
+	logicalResourceId_ = logicalResourceId;
+	for(int i = 0; i!= logicalResourceId.size(); i++)
+		setCoreParameter("LogicalResourceId."+ std::to_string(i), logicalResourceId.at(i));
+}
+
+std::vector<std::string> ListStackEventsRequest::getResourceType()const
+{
+	return resourceType_;
+}
+
+void ListStackEventsRequest::setResourceType(const std::vector<std::string>& resourceType)
+{
+	resourceType_ = resourceType;
+	for(int i = 0; i!= resourceType.size(); i++)
+		setCoreParameter("ResourceType."+ std::to_string(i), resourceType.at(i));
+}
+
+long ListStackEventsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListStackEventsRequest::setPageNumber(long pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setCoreParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::vector<std::string> ListStackEventsRequest::getStatus()const
+{
+	return status_;
+}
+
+void ListStackEventsRequest::setStatus(const std::vector<std::string>& status)
+{
+	status_ = status;
+	for(int i = 0; i!= status.size(); i++)
+		setCoreParameter("Status."+ std::to_string(i), status.at(i));
+}
+

ros/src/model/ListStackEventsResult.cc

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ros/model/ListStackEventsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+ListStackEventsResult::ListStackEventsResult() :
+	ServiceResult()
+{}
+
+ListStackEventsResult::ListStackEventsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListStackEventsResult::~ListStackEventsResult()
+{}
+
+void ListStackEventsResult::parse(const std::string &payload)
+{
+	Json::CharReaderBuilder builder;
+	Json::CharReader *reader = builder.newCharReader();
+	Json::Value *val;
+	Json::Value value;
+	JSONCPP_STRING *errs;
+	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
+	value = *val;
+	setRequestId(value["RequestId"].asString());
+	auto allEvents = value["Events"]["Event"];
+	for (auto value : allEvents)
+	{
+		Event eventsObject;
+		if(!value["CreateTime"].isNull())
+			eventsObject.createTime = value["CreateTime"].asString();
+		if(!value["EventId"].isNull())
+			eventsObject.eventId = value["EventId"].asString();
+		if(!value["LogicalResourceId"].isNull())
+			eventsObject.logicalResourceId = value["LogicalResourceId"].asString();
+		if(!value["PhysicalResourceId"].isNull())
+			eventsObject.physicalResourceId = value["PhysicalResourceId"].asString();
+		if(!value["ResourceType"].isNull())
+			eventsObject.resourceType = value["ResourceType"].asString();
+		if(!value["StackId"].isNull())
+			eventsObject.stackId = value["StackId"].asString();
+		if(!value["StackName"].isNull())
+			eventsObject.stackName = value["StackName"].asString();
+		if(!value["Status"].isNull())
+			eventsObject.status = value["Status"].asString();
+		if(!value["StatusReason"].isNull())
+			eventsObject.statusReason = value["StatusReason"].asString();
+		events_.push_back(eventsObject);
+	}
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+int ListStackEventsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int ListStackEventsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+std::vector<ListStackEventsResult::Event> ListStackEventsResult::getEvents()const
+{
+	return events_;
+}
+
+int ListStackEventsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+

ros/src/model/ListStackResourcesRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/ros/model/ListStackResourcesRequest.h>
+
+using AlibabaCloud::ROS::Model::ListStackResourcesRequest;
+
+ListStackResourcesRequest::ListStackResourcesRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "ListStackResources")
+{}
+
+ListStackResourcesRequest::~ListStackResourcesRequest()
+{}
+
+std::string ListStackResourcesRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ListStackResourcesRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string ListStackResourcesRequest::getStackId()const
+{
+	return stackId_;
+}
+
+void ListStackResourcesRequest::setStackId(const std::string& stackId)
+{
+	stackId_ = stackId;
+	setCoreParameter("StackId", stackId);
+}
+

ros/src/model/ListStackResourcesResult.cc

@@ -0,0 +1,77 @@
+/*
+ * 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/ros/model/ListStackResourcesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+ListStackResourcesResult::ListStackResourcesResult() :
+	ServiceResult()
+{}
+
+ListStackResourcesResult::ListStackResourcesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListStackResourcesResult::~ListStackResourcesResult()
+{}
+
+void ListStackResourcesResult::parse(const std::string &payload)
+{
+	Json::CharReaderBuilder builder;
+	Json::CharReader *reader = builder.newCharReader();
+	Json::Value *val;
+	Json::Value value;
+	JSONCPP_STRING *errs;
+	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
+	value = *val;
+	setRequestId(value["RequestId"].asString());
+	auto allResources = value["Resources"]["Resource"];
+	for (auto value : allResources)
+	{
+		Resource resourcesObject;
+		if(!value["CreateTime"].isNull())
+			resourcesObject.createTime = value["CreateTime"].asString();
+		if(!value["LogicalResourceId"].isNull())
+			resourcesObject.logicalResourceId = value["LogicalResourceId"].asString();
+		if(!value["PhysicalResourceId"].isNull())
+			resourcesObject.physicalResourceId = value["PhysicalResourceId"].asString();
+		if(!value["ResourceType"].isNull())
+			resourcesObject.resourceType = value["ResourceType"].asString();
+		if(!value["StackId"].isNull())
+			resourcesObject.stackId = value["StackId"].asString();
+		if(!value["StackName"].isNull())
+			resourcesObject.stackName = value["StackName"].asString();
+		if(!value["Status"].isNull())
+			resourcesObject.status = value["Status"].asString();
+		if(!value["StatusReason"].isNull())
+			resourcesObject.statusReason = value["StatusReason"].asString();
+		if(!value["UpdateTime"].isNull())
+			resourcesObject.updateTime = value["UpdateTime"].asString();
+		resources_.push_back(resourcesObject);
+	}
+
+}
+
+std::vector<ListStackResourcesResult::Resource> ListStackResourcesResult::getResources()const
+{
+	return resources_;
+}
+

ros/src/model/ListStacksRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/ros/model/ListStacksRequest.h>
+
+using AlibabaCloud::ROS::Model::ListStacksRequest;
+
+ListStacksRequest::ListStacksRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "ListStacks")
+{}
+
+ListStacksRequest::~ListStacksRequest()
+{}
+
+std::string ListStacksRequest::getParentStackId()const
+{
+	return parentStackId_;
+}
+
+void ListStacksRequest::setParentStackId(const std::string& parentStackId)
+{
+	parentStackId_ = parentStackId;
+	setCoreParameter("ParentStackId", parentStackId);
+}
+
+bool ListStacksRequest::getShowNestedStack()const
+{
+	return showNestedStack_;
+}
+
+void ListStacksRequest::setShowNestedStack(bool showNestedStack)
+{
+	showNestedStack_ = showNestedStack;
+	setCoreParameter("ShowNestedStack", showNestedStack ? "true" : "false");
+}
+
+std::string ListStacksRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ListStacksRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+long ListStacksRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListStacksRequest::setPageSize(long pageSize)
+{
+	pageSize_ = pageSize;
+	setCoreParameter("PageSize", std::to_string(pageSize));
+}
+
+std::vector<std::string> ListStacksRequest::getStackName()const
+{
+	return stackName_;
+}
+
+void ListStacksRequest::setStackName(const std::vector<std::string>& stackName)
+{
+	stackName_ = stackName;
+	for(int i = 0; i!= stackName.size(); i++)
+		setCoreParameter("StackName."+ std::to_string(i), stackName.at(i));
+}
+
+long ListStacksRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListStacksRequest::setPageNumber(long pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setCoreParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::vector<std::string> ListStacksRequest::getStatus()const
+{
+	return status_;
+}
+
+void ListStacksRequest::setStatus(const std::vector<std::string>& status)
+{
+	status_ = status;
+	for(int i = 0; i!= status.size(); i++)
+		setCoreParameter("Status."+ std::to_string(i), status.at(i));
+}
+

ros/src/model/ListStacksResult.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/ros/model/ListStacksResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ROS;
+using namespace AlibabaCloud::ROS::Model;
+
+ListStacksResult::ListStacksResult() :
+	ServiceResult()
+{}
+
+ListStacksResult::ListStacksResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListStacksResult::~ListStacksResult()
+{}
+
+void ListStacksResult::parse(const std::string &payload)
+{
+	Json::CharReaderBuilder builder;
+	Json::CharReader *reader = builder.newCharReader();
+	Json::Value *val;
+	Json::Value value;
+	JSONCPP_STRING *errs;
+	reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
+	value = *val;
+	setRequestId(value["RequestId"].asString());
+	auto allStacks = value["Stacks"]["Stack"];
+	for (auto value : allStacks)
+	{
+		Stack stacksObject;
+		if(!value["CreateTime"].isNull())
+			stacksObject.createTime = value["CreateTime"].asString();
+		if(!value["DisableRollback"].isNull())
+			stacksObject.disableRollback = value["DisableRollback"].asString() == "true";
+		if(!value["RegionId"].isNull())
+			stacksObject.regionId = value["RegionId"].asString();
+		if(!value["StackId"].isNull())
+			stacksObject.stackId = value["StackId"].asString();
+		if(!value["StackName"].isNull())
+			stacksObject.stackName = value["StackName"].asString();
+		if(!value["Status"].isNull())
+			stacksObject.status = value["Status"].asString();
+		if(!value["StatusReason"].isNull())
+			stacksObject.statusReason = value["StatusReason"].asString();
+		if(!value["TimeoutInMinutes"].isNull())
+			stacksObject.timeoutInMinutes = std::stoi(value["TimeoutInMinutes"].asString());
+		if(!value["ParentStackId"].isNull())
+			stacksObject.parentStackId = value["ParentStackId"].asString();
+		if(!value["UpdateTime"].isNull())
+			stacksObject.updateTime = value["UpdateTime"].asString();
+		stacks_.push_back(stacksObject);
+	}
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+int ListStacksResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int ListStacksResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int ListStacksResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<ListStacksResult::Stack> ListStacksResult::getStacks()const
+{
+	return stacks_;
+}
+

ros/src/model/PreviewStackRequest.cc

@@ -0,0 +1,143 @@
+/*
+ * 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/ros/model/PreviewStackRequest.h>
+
+using AlibabaCloud::ROS::Model::PreviewStackRequest;
+
+PreviewStackRequest::PreviewStackRequest() :
+	RpcServiceRequest("ros", "2019-09-10", "PreviewStack")
+{}
+
+PreviewStackRequest::~PreviewStackRequest()
+{}
+
+std::string PreviewStackRequest::getStackPolicyURL()const
+{
+	return stackPolicyURL_;
+}
+
+void PreviewStackRequest::setStackPolicyURL(const std::string& stackPolicyURL)
+{
+	stackPolicyURL_ = stackPolicyURL;
+	setCoreParameter("StackPolicyURL", stackPolicyURL);
+}
+
+std::string PreviewStackRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void PreviewStackRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string PreviewStackRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void PreviewStackRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setCoreParameter("ClientToken", clientToken);
+}
+
+std::string PreviewStackRequest::getTemplateBody()const
+{
+	return templateBody_;
+}
+
+void PreviewStackRequest::setTemplateBody(const std::string& templateBody)
+{
+	templateBody_ = templateBody;
+	setCoreParameter("TemplateBody", templateBody);
+}
+
+bool PreviewStackRequest::getDisableRollback()const
+{
+	return disableRollback_;
+}
+
+void PreviewStackRequest::setDisableRollback(bool disableRollback)
+{
+	disableRollback_ = disableRollback;
+	setCoreParameter("DisableRollback", disableRollback ? "true" : "false");
+}
+
+std::string PreviewStackRequest::getStackName()const
+{
+	return stackName_;
+}
+
+void PreviewStackRequest::setStackName(const std::string& stackName)
+{
+	stackName_ = stackName;
+	setCoreParameter("StackName", stackName);
+}
+
+std::vector<PreviewStackRequest::Parameters> PreviewStackRequest::getParameters()const
+{
+	return parameters_;
+}
+
+void PreviewStackRequest::setParameters(const std::vector<Parameters>& parameters)
+{
+	parameters_ = parameters;
+	int i = 0;
+	for(int i = 0; i!= parameters.size(); i++)	{
+		auto obj = parameters.at(i);
+		std::string str ="Parameters."+ std::to_string(i);
+		setCoreParameter(str + ".ParameterValue", obj.parameterValue);
+		setCoreParameter(str + ".ParameterKey", obj.parameterKey);
+	}
+}
+
+std::string PreviewStackRequest::getStackPolicyBody()const
+{
+	return stackPolicyBody_;
+}
+
+void PreviewStackRequest::setStackPolicyBody(const std::string& stackPolicyBody)
+{
+	stackPolicyBody_ = stackPolicyBody;
+	setCoreParameter("StackPolicyBody", stackPolicyBody);
+}
+
+long PreviewStackRequest::getTimeoutInMinutes()const
+{
+	return timeoutInMinutes_;
+}
+
+void PreviewStackRequest::setTimeoutInMinutes(long timeoutInMinutes)
+{
+	timeoutInMinutes_ = timeoutInMinutes;
+	setCoreParameter("TimeoutInMinutes", std::to_string(timeoutInMinutes));
+}
+
+std::string PreviewStackRequest::getTemplateURL()const
+{
+	return templateURL_;
+}
+
+void PreviewStackRequest::setTemplateURL(const std::string& templateURL)
+{
+	templateURL_ = templateURL;
+	setCoreParameter("TemplateURL", templateURL);
+}
+