Support Create Workflow.

VERSION

@@ -1 +1 @@
-1.36.1443
+1.36.1444

schedulerx2/CMakeLists.txt

@@ -33,6 +33,8 @@ set(schedulerx2_public_header_model
 	include/alibabacloud/schedulerx2/model/CreateJobResult.h
 	include/alibabacloud/schedulerx2/model/CreateNamespaceRequest.h
 	include/alibabacloud/schedulerx2/model/CreateNamespaceResult.h
+	include/alibabacloud/schedulerx2/model/CreateWorkflowRequest.h
+	include/alibabacloud/schedulerx2/model/CreateWorkflowResult.h
 	include/alibabacloud/schedulerx2/model/DeleteJobRequest.h
 	include/alibabacloud/schedulerx2/model/DeleteJobResult.h
 	include/alibabacloud/schedulerx2/model/DeleteWorkflowRequest.h
@@ -59,10 +61,14 @@ set(schedulerx2_public_header_model
 	include/alibabacloud/schedulerx2/model/GetJobInstanceResult.h
 	include/alibabacloud/schedulerx2/model/GetJobInstanceListRequest.h
 	include/alibabacloud/schedulerx2/model/GetJobInstanceListResult.h
+	include/alibabacloud/schedulerx2/model/GetLogRequest.h
+	include/alibabacloud/schedulerx2/model/GetLogResult.h
 	include/alibabacloud/schedulerx2/model/GetWorkFlowRequest.h
 	include/alibabacloud/schedulerx2/model/GetWorkFlowResult.h
 	include/alibabacloud/schedulerx2/model/GetWorkerListRequest.h
 	include/alibabacloud/schedulerx2/model/GetWorkerListResult.h
+	include/alibabacloud/schedulerx2/model/GetWorkflowInstanceRequest.h
+	include/alibabacloud/schedulerx2/model/GetWorkflowInstanceResult.h
 	include/alibabacloud/schedulerx2/model/GrantPermissionRequest.h
 	include/alibabacloud/schedulerx2/model/GrantPermissionResult.h
 	include/alibabacloud/schedulerx2/model/ListGroupsRequest.h
@@ -71,12 +77,26 @@ set(schedulerx2_public_header_model
 	include/alibabacloud/schedulerx2/model/ListJobsResult.h
 	include/alibabacloud/schedulerx2/model/ListNamespacesRequest.h
 	include/alibabacloud/schedulerx2/model/ListNamespacesResult.h
+	include/alibabacloud/schedulerx2/model/ListWorkflowInstanceRequest.h
+	include/alibabacloud/schedulerx2/model/ListWorkflowInstanceResult.h
+	include/alibabacloud/schedulerx2/model/RerunJobRequest.h
+	include/alibabacloud/schedulerx2/model/RerunJobResult.h
+	include/alibabacloud/schedulerx2/model/RetryJobInstanceRequest.h
+	include/alibabacloud/schedulerx2/model/RetryJobInstanceResult.h
 	include/alibabacloud/schedulerx2/model/RevokePermissionRequest.h
 	include/alibabacloud/schedulerx2/model/RevokePermissionResult.h
+	include/alibabacloud/schedulerx2/model/SetJobInstanceSuccessRequest.h
+	include/alibabacloud/schedulerx2/model/SetJobInstanceSuccessResult.h
+	include/alibabacloud/schedulerx2/model/SetWfInstanceSuccessRequest.h
+	include/alibabacloud/schedulerx2/model/SetWfInstanceSuccessResult.h
 	include/alibabacloud/schedulerx2/model/StopInstanceRequest.h
 	include/alibabacloud/schedulerx2/model/StopInstanceResult.h
 	include/alibabacloud/schedulerx2/model/UpdateJobRequest.h
-	include/alibabacloud/schedulerx2/model/UpdateJobResult.h )
+	include/alibabacloud/schedulerx2/model/UpdateJobResult.h
+	include/alibabacloud/schedulerx2/model/UpdateWorkflowRequest.h
+	include/alibabacloud/schedulerx2/model/UpdateWorkflowResult.h
+	include/alibabacloud/schedulerx2/model/UpdateWorkflowDagRequest.h
+	include/alibabacloud/schedulerx2/model/UpdateWorkflowDagResult.h )
 
 set(schedulerx2_src 
 	src/Schedulerx2Client.cc
@@ -92,6 +112,8 @@ set(schedulerx2_src
 	src/model/CreateJobResult.cc
 	src/model/CreateNamespaceRequest.cc
 	src/model/CreateNamespaceResult.cc
+	src/model/CreateWorkflowRequest.cc
+	src/model/CreateWorkflowResult.cc
 	src/model/DeleteJobRequest.cc
 	src/model/DeleteJobResult.cc
 	src/model/DeleteWorkflowRequest.cc
@@ -118,10 +140,14 @@ set(schedulerx2_src
 	src/model/GetJobInstanceResult.cc
 	src/model/GetJobInstanceListRequest.cc
 	src/model/GetJobInstanceListResult.cc
+	src/model/GetLogRequest.cc
+	src/model/GetLogResult.cc
 	src/model/GetWorkFlowRequest.cc
 	src/model/GetWorkFlowResult.cc
 	src/model/GetWorkerListRequest.cc
 	src/model/GetWorkerListResult.cc
+	src/model/GetWorkflowInstanceRequest.cc
+	src/model/GetWorkflowInstanceResult.cc
 	src/model/GrantPermissionRequest.cc
 	src/model/GrantPermissionResult.cc
 	src/model/ListGroupsRequest.cc
@@ -130,12 +156,26 @@ set(schedulerx2_src
 	src/model/ListJobsResult.cc
 	src/model/ListNamespacesRequest.cc
 	src/model/ListNamespacesResult.cc
+	src/model/ListWorkflowInstanceRequest.cc
+	src/model/ListWorkflowInstanceResult.cc
+	src/model/RerunJobRequest.cc
+	src/model/RerunJobResult.cc
+	src/model/RetryJobInstanceRequest.cc
+	src/model/RetryJobInstanceResult.cc
 	src/model/RevokePermissionRequest.cc
 	src/model/RevokePermissionResult.cc
+	src/model/SetJobInstanceSuccessRequest.cc
+	src/model/SetJobInstanceSuccessResult.cc
+	src/model/SetWfInstanceSuccessRequest.cc
+	src/model/SetWfInstanceSuccessResult.cc
 	src/model/StopInstanceRequest.cc
 	src/model/StopInstanceResult.cc
 	src/model/UpdateJobRequest.cc
-	src/model/UpdateJobResult.cc )
+	src/model/UpdateJobResult.cc
+	src/model/UpdateWorkflowRequest.cc
+	src/model/UpdateWorkflowResult.cc
+	src/model/UpdateWorkflowDagRequest.cc
+	src/model/UpdateWorkflowDagResult.cc )
 
 add_library(schedulerx2 ${LIB_TYPE}
 	${schedulerx2_public_header}

schedulerx2/include/alibabacloud/schedulerx2/Schedulerx2Client.h

@@ -34,6 +34,8 @@
 #include "model/CreateJobResult.h"
 #include "model/CreateNamespaceRequest.h"
 #include "model/CreateNamespaceResult.h"
+#include "model/CreateWorkflowRequest.h"
+#include "model/CreateWorkflowResult.h"
 #include "model/DeleteJobRequest.h"
 #include "model/DeleteJobResult.h"
 #include "model/DeleteWorkflowRequest.h"
@@ -60,10 +62,14 @@
 #include "model/GetJobInstanceResult.h"
 #include "model/GetJobInstanceListRequest.h"
 #include "model/GetJobInstanceListResult.h"
+#include "model/GetLogRequest.h"
+#include "model/GetLogResult.h"
 #include "model/GetWorkFlowRequest.h"
 #include "model/GetWorkFlowResult.h"
 #include "model/GetWorkerListRequest.h"
 #include "model/GetWorkerListResult.h"
+#include "model/GetWorkflowInstanceRequest.h"
+#include "model/GetWorkflowInstanceResult.h"
 #include "model/GrantPermissionRequest.h"
 #include "model/GrantPermissionResult.h"
 #include "model/ListGroupsRequest.h"
@@ -72,12 +78,26 @@
 #include "model/ListJobsResult.h"
 #include "model/ListNamespacesRequest.h"
 #include "model/ListNamespacesResult.h"
+#include "model/ListWorkflowInstanceRequest.h"
+#include "model/ListWorkflowInstanceResult.h"
+#include "model/RerunJobRequest.h"
+#include "model/RerunJobResult.h"
+#include "model/RetryJobInstanceRequest.h"
+#include "model/RetryJobInstanceResult.h"
 #include "model/RevokePermissionRequest.h"
 #include "model/RevokePermissionResult.h"
+#include "model/SetJobInstanceSuccessRequest.h"
+#include "model/SetJobInstanceSuccessResult.h"
+#include "model/SetWfInstanceSuccessRequest.h"
+#include "model/SetWfInstanceSuccessResult.h"
 #include "model/StopInstanceRequest.h"
 #include "model/StopInstanceResult.h"
 #include "model/UpdateJobRequest.h"
 #include "model/UpdateJobResult.h"
+#include "model/UpdateWorkflowRequest.h"
+#include "model/UpdateWorkflowResult.h"
+#include "model/UpdateWorkflowDagRequest.h"
+#include "model/UpdateWorkflowDagResult.h"
 
 
 namespace AlibabaCloud
@@ -105,6 +125,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateNamespaceResult> CreateNamespaceOutcome;
 			typedef std::future<CreateNamespaceOutcome> CreateNamespaceOutcomeCallable;
 			typedef std::function<void(const Schedulerx2Client*, const Model::CreateNamespaceRequest&, const CreateNamespaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateNamespaceAsyncHandler;
+			typedef Outcome<Error, Model::CreateWorkflowResult> CreateWorkflowOutcome;
+			typedef std::future<CreateWorkflowOutcome> CreateWorkflowOutcomeCallable;
+			typedef std::function<void(const Schedulerx2Client*, const Model::CreateWorkflowRequest&, const CreateWorkflowOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateWorkflowAsyncHandler;
 			typedef Outcome<Error, Model::DeleteJobResult> DeleteJobOutcome;
 			typedef std::future<DeleteJobOutcome> DeleteJobOutcomeCallable;
 			typedef std::function<void(const Schedulerx2Client*, const Model::DeleteJobRequest&, const DeleteJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteJobAsyncHandler;
@@ -144,12 +167,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetJobInstanceListResult> GetJobInstanceListOutcome;
 			typedef std::future<GetJobInstanceListOutcome> GetJobInstanceListOutcomeCallable;
 			typedef std::function<void(const Schedulerx2Client*, const Model::GetJobInstanceListRequest&, const GetJobInstanceListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetJobInstanceListAsyncHandler;
+			typedef Outcome<Error, Model::GetLogResult> GetLogOutcome;
+			typedef std::future<GetLogOutcome> GetLogOutcomeCallable;
+			typedef std::function<void(const Schedulerx2Client*, const Model::GetLogRequest&, const GetLogOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetLogAsyncHandler;
 			typedef Outcome<Error, Model::GetWorkFlowResult> GetWorkFlowOutcome;
 			typedef std::future<GetWorkFlowOutcome> GetWorkFlowOutcomeCallable;
 			typedef std::function<void(const Schedulerx2Client*, const Model::GetWorkFlowRequest&, const GetWorkFlowOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetWorkFlowAsyncHandler;
 			typedef Outcome<Error, Model::GetWorkerListResult> GetWorkerListOutcome;
 			typedef std::future<GetWorkerListOutcome> GetWorkerListOutcomeCallable;
 			typedef std::function<void(const Schedulerx2Client*, const Model::GetWorkerListRequest&, const GetWorkerListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetWorkerListAsyncHandler;
+			typedef Outcome<Error, Model::GetWorkflowInstanceResult> GetWorkflowInstanceOutcome;
+			typedef std::future<GetWorkflowInstanceOutcome> GetWorkflowInstanceOutcomeCallable;
+			typedef std::function<void(const Schedulerx2Client*, const Model::GetWorkflowInstanceRequest&, const GetWorkflowInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetWorkflowInstanceAsyncHandler;
 			typedef Outcome<Error, Model::GrantPermissionResult> GrantPermissionOutcome;
 			typedef std::future<GrantPermissionOutcome> GrantPermissionOutcomeCallable;
 			typedef std::function<void(const Schedulerx2Client*, const Model::GrantPermissionRequest&, const GrantPermissionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GrantPermissionAsyncHandler;
@@ -162,15 +191,36 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListNamespacesResult> ListNamespacesOutcome;
 			typedef std::future<ListNamespacesOutcome> ListNamespacesOutcomeCallable;
 			typedef std::function<void(const Schedulerx2Client*, const Model::ListNamespacesRequest&, const ListNamespacesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListNamespacesAsyncHandler;
+			typedef Outcome<Error, Model::ListWorkflowInstanceResult> ListWorkflowInstanceOutcome;
+			typedef std::future<ListWorkflowInstanceOutcome> ListWorkflowInstanceOutcomeCallable;
+			typedef std::function<void(const Schedulerx2Client*, const Model::ListWorkflowInstanceRequest&, const ListWorkflowInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListWorkflowInstanceAsyncHandler;
+			typedef Outcome<Error, Model::RerunJobResult> RerunJobOutcome;
+			typedef std::future<RerunJobOutcome> RerunJobOutcomeCallable;
+			typedef std::function<void(const Schedulerx2Client*, const Model::RerunJobRequest&, const RerunJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RerunJobAsyncHandler;
+			typedef Outcome<Error, Model::RetryJobInstanceResult> RetryJobInstanceOutcome;
+			typedef std::future<RetryJobInstanceOutcome> RetryJobInstanceOutcomeCallable;
+			typedef std::function<void(const Schedulerx2Client*, const Model::RetryJobInstanceRequest&, const RetryJobInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RetryJobInstanceAsyncHandler;
 			typedef Outcome<Error, Model::RevokePermissionResult> RevokePermissionOutcome;
 			typedef std::future<RevokePermissionOutcome> RevokePermissionOutcomeCallable;
 			typedef std::function<void(const Schedulerx2Client*, const Model::RevokePermissionRequest&, const RevokePermissionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RevokePermissionAsyncHandler;
+			typedef Outcome<Error, Model::SetJobInstanceSuccessResult> SetJobInstanceSuccessOutcome;
+			typedef std::future<SetJobInstanceSuccessOutcome> SetJobInstanceSuccessOutcomeCallable;
+			typedef std::function<void(const Schedulerx2Client*, const Model::SetJobInstanceSuccessRequest&, const SetJobInstanceSuccessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetJobInstanceSuccessAsyncHandler;
+			typedef Outcome<Error, Model::SetWfInstanceSuccessResult> SetWfInstanceSuccessOutcome;
+			typedef std::future<SetWfInstanceSuccessOutcome> SetWfInstanceSuccessOutcomeCallable;
+			typedef std::function<void(const Schedulerx2Client*, const Model::SetWfInstanceSuccessRequest&, const SetWfInstanceSuccessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetWfInstanceSuccessAsyncHandler;
 			typedef Outcome<Error, Model::StopInstanceResult> StopInstanceOutcome;
 			typedef std::future<StopInstanceOutcome> StopInstanceOutcomeCallable;
 			typedef std::function<void(const Schedulerx2Client*, const Model::StopInstanceRequest&, const StopInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopInstanceAsyncHandler;
 			typedef Outcome<Error, Model::UpdateJobResult> UpdateJobOutcome;
 			typedef std::future<UpdateJobOutcome> UpdateJobOutcomeCallable;
 			typedef std::function<void(const Schedulerx2Client*, const Model::UpdateJobRequest&, const UpdateJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateJobAsyncHandler;
+			typedef Outcome<Error, Model::UpdateWorkflowResult> UpdateWorkflowOutcome;
+			typedef std::future<UpdateWorkflowOutcome> UpdateWorkflowOutcomeCallable;
+			typedef std::function<void(const Schedulerx2Client*, const Model::UpdateWorkflowRequest&, const UpdateWorkflowOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateWorkflowAsyncHandler;
+			typedef Outcome<Error, Model::UpdateWorkflowDagResult> UpdateWorkflowDagOutcome;
+			typedef std::future<UpdateWorkflowDagOutcome> UpdateWorkflowDagOutcomeCallable;
+			typedef std::function<void(const Schedulerx2Client*, const Model::UpdateWorkflowDagRequest&, const UpdateWorkflowDagOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateWorkflowDagAsyncHandler;
 
 			Schedulerx2Client(const Credentials &credentials, const ClientConfiguration &configuration);
 			Schedulerx2Client(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
@@ -194,6 +244,9 @@ namespace AlibabaCloud
 			CreateNamespaceOutcome createNamespace(const Model::CreateNamespaceRequest &request)const;
 			void createNamespaceAsync(const Model::CreateNamespaceRequest& request, const CreateNamespaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateNamespaceOutcomeCallable createNamespaceCallable(const Model::CreateNamespaceRequest& request) const;
+			CreateWorkflowOutcome createWorkflow(const Model::CreateWorkflowRequest &request)const;
+			void createWorkflowAsync(const Model::CreateWorkflowRequest& request, const CreateWorkflowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateWorkflowOutcomeCallable createWorkflowCallable(const Model::CreateWorkflowRequest& request) const;
 			DeleteJobOutcome deleteJob(const Model::DeleteJobRequest &request)const;
 			void deleteJobAsync(const Model::DeleteJobRequest& request, const DeleteJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteJobOutcomeCallable deleteJobCallable(const Model::DeleteJobRequest& request) const;
@@ -233,12 +286,18 @@ namespace AlibabaCloud
 			GetJobInstanceListOutcome getJobInstanceList(const Model::GetJobInstanceListRequest &request)const;
 			void getJobInstanceListAsync(const Model::GetJobInstanceListRequest& request, const GetJobInstanceListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetJobInstanceListOutcomeCallable getJobInstanceListCallable(const Model::GetJobInstanceListRequest& request) const;
+			GetLogOutcome getLog(const Model::GetLogRequest &request)const;
+			void getLogAsync(const Model::GetLogRequest& request, const GetLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetLogOutcomeCallable getLogCallable(const Model::GetLogRequest& request) const;
 			GetWorkFlowOutcome getWorkFlow(const Model::GetWorkFlowRequest &request)const;
 			void getWorkFlowAsync(const Model::GetWorkFlowRequest& request, const GetWorkFlowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetWorkFlowOutcomeCallable getWorkFlowCallable(const Model::GetWorkFlowRequest& request) const;
 			GetWorkerListOutcome getWorkerList(const Model::GetWorkerListRequest &request)const;
 			void getWorkerListAsync(const Model::GetWorkerListRequest& request, const GetWorkerListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetWorkerListOutcomeCallable getWorkerListCallable(const Model::GetWorkerListRequest& request) const;
+			GetWorkflowInstanceOutcome getWorkflowInstance(const Model::GetWorkflowInstanceRequest &request)const;
+			void getWorkflowInstanceAsync(const Model::GetWorkflowInstanceRequest& request, const GetWorkflowInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetWorkflowInstanceOutcomeCallable getWorkflowInstanceCallable(const Model::GetWorkflowInstanceRequest& request) const;
 			GrantPermissionOutcome grantPermission(const Model::GrantPermissionRequest &request)const;
 			void grantPermissionAsync(const Model::GrantPermissionRequest& request, const GrantPermissionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GrantPermissionOutcomeCallable grantPermissionCallable(const Model::GrantPermissionRequest& request) const;
@@ -251,15 +310,36 @@ namespace AlibabaCloud
 			ListNamespacesOutcome listNamespaces(const Model::ListNamespacesRequest &request)const;
 			void listNamespacesAsync(const Model::ListNamespacesRequest& request, const ListNamespacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListNamespacesOutcomeCallable listNamespacesCallable(const Model::ListNamespacesRequest& request) const;
+			ListWorkflowInstanceOutcome listWorkflowInstance(const Model::ListWorkflowInstanceRequest &request)const;
+			void listWorkflowInstanceAsync(const Model::ListWorkflowInstanceRequest& request, const ListWorkflowInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListWorkflowInstanceOutcomeCallable listWorkflowInstanceCallable(const Model::ListWorkflowInstanceRequest& request) const;
+			RerunJobOutcome rerunJob(const Model::RerunJobRequest &request)const;
+			void rerunJobAsync(const Model::RerunJobRequest& request, const RerunJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RerunJobOutcomeCallable rerunJobCallable(const Model::RerunJobRequest& request) const;
+			RetryJobInstanceOutcome retryJobInstance(const Model::RetryJobInstanceRequest &request)const;
+			void retryJobInstanceAsync(const Model::RetryJobInstanceRequest& request, const RetryJobInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RetryJobInstanceOutcomeCallable retryJobInstanceCallable(const Model::RetryJobInstanceRequest& request) const;
 			RevokePermissionOutcome revokePermission(const Model::RevokePermissionRequest &request)const;
 			void revokePermissionAsync(const Model::RevokePermissionRequest& request, const RevokePermissionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RevokePermissionOutcomeCallable revokePermissionCallable(const Model::RevokePermissionRequest& request) const;
+			SetJobInstanceSuccessOutcome setJobInstanceSuccess(const Model::SetJobInstanceSuccessRequest &request)const;
+			void setJobInstanceSuccessAsync(const Model::SetJobInstanceSuccessRequest& request, const SetJobInstanceSuccessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetJobInstanceSuccessOutcomeCallable setJobInstanceSuccessCallable(const Model::SetJobInstanceSuccessRequest& request) const;
+			SetWfInstanceSuccessOutcome setWfInstanceSuccess(const Model::SetWfInstanceSuccessRequest &request)const;
+			void setWfInstanceSuccessAsync(const Model::SetWfInstanceSuccessRequest& request, const SetWfInstanceSuccessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetWfInstanceSuccessOutcomeCallable setWfInstanceSuccessCallable(const Model::SetWfInstanceSuccessRequest& request) const;
 			StopInstanceOutcome stopInstance(const Model::StopInstanceRequest &request)const;
 			void stopInstanceAsync(const Model::StopInstanceRequest& request, const StopInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StopInstanceOutcomeCallable stopInstanceCallable(const Model::StopInstanceRequest& request) const;
 			UpdateJobOutcome updateJob(const Model::UpdateJobRequest &request)const;
 			void updateJobAsync(const Model::UpdateJobRequest& request, const UpdateJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateJobOutcomeCallable updateJobCallable(const Model::UpdateJobRequest& request) const;
+			UpdateWorkflowOutcome updateWorkflow(const Model::UpdateWorkflowRequest &request)const;
+			void updateWorkflowAsync(const Model::UpdateWorkflowRequest& request, const UpdateWorkflowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateWorkflowOutcomeCallable updateWorkflowCallable(const Model::UpdateWorkflowRequest& request) const;
+			UpdateWorkflowDagOutcome updateWorkflowDag(const Model::UpdateWorkflowDagRequest &request)const;
+			void updateWorkflowDagAsync(const Model::UpdateWorkflowDagRequest& request, const UpdateWorkflowDagAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateWorkflowDagOutcomeCallable updateWorkflowDagCallable(const Model::UpdateWorkflowDagRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

schedulerx2/include/alibabacloud/schedulerx2/model/CreateAppGroupRequest.h

@@ -52,8 +52,6 @@ public:
 	void setMetricsThresholdJson(const std::string &metricsThresholdJson);
 	std::string getGroupId() const;
 	void setGroupId(const std::string &groupId);
-	int getAppType() const;
-	void setAppType(int appType);
 	std::string getMonitorConfigJson() const;
 	void setMonitorConfigJson(const std::string &monitorConfigJson);
 	std::string get_Namespace() const;
@@ -73,7 +71,6 @@ private:
 	int maxJobs_;
 	std::string metricsThresholdJson_;
 	std::string groupId_;
-	int appType_;
 	std::string monitorConfigJson_;
 	std::string _namespace_;
 	std::string appKey_;

schedulerx2/include/alibabacloud/schedulerx2/model/CreateJobRequest.h

@@ -38,14 +38,16 @@ public:
 	~CreateJobRequest();
 	int getAttemptInterval() const;
 	void setAttemptInterval(int attemptInterval);
+	int getFailTimes() const;
+	void setFailTimes(int failTimes);
 	int getConsumerSize() const;
 	void setConsumerSize(int consumerSize);
 	std::string getJarUrl() const;
 	void setJarUrl(const std::string &jarUrl);
-	int getDataOffset() const;
-	void setDataOffset(int dataOffset);
 	std::string getGroupId() const;
 	void setGroupId(const std::string &groupId);
+	int getDataOffset() const;
+	void setDataOffset(int dataOffset);
 	int getTaskMaxAttempt() const;
 	void setTaskMaxAttempt(int taskMaxAttempt);
 	int getDispatcherSize() const;
@@ -94,6 +96,8 @@ public:
 	void setMaxAttempt(int maxAttempt);
 	bool getMissWorkerEnable() const;
 	void setMissWorkerEnable(bool missWorkerEnable);
+	bool getSuccessNoticeEnable() const;
+	void setSuccessNoticeEnable(bool successNoticeEnable);
 	int getQueueSize() const;
 	void setQueueSize(int queueSize);
 	std::string getClassName() const;
@@ -107,10 +111,11 @@ public:
 
 private:
 	int attemptInterval_;
+	int failTimes_;
 	int consumerSize_;
 	std::string jarUrl_;
-	int dataOffset_;
 	std::string groupId_;
+	int dataOffset_;
 	int taskMaxAttempt_;
 	int dispatcherSize_;
 	std::string jobType_;
@@ -135,6 +140,7 @@ private:
 	std::string sendChannel_;
 	int maxAttempt_;
 	bool missWorkerEnable_;
+	bool successNoticeEnable_;
 	int queueSize_;
 	std::string className_;
 	std::string _namespace_;

schedulerx2/include/alibabacloud/schedulerx2/model/CreateWorkflowRequest.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_SCHEDULERX2_MODEL_CREATEWORKFLOWREQUEST_H_
+#define ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEWORKFLOWREQUEST_H_
+
+#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Schedulerx2 {
+namespace Model {
+class ALIBABACLOUD_SCHEDULERX2_EXPORT CreateWorkflowRequest : public RpcServiceRequest {
+public:
+	CreateWorkflowRequest();
+	~CreateWorkflowRequest();
+	std::string getNamespaceSource() const;
+	void setNamespaceSource(const std::string &namespaceSource);
+	std::string getTimezone() const;
+	void setTimezone(const std::string &timezone);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getGroupId() const;
+	void setGroupId(const std::string &groupId);
+	std::string getTimeExpression() const;
+	void setTimeExpression(const std::string &timeExpression);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
+	std::string getName() const;
+	void setName(const std::string &name);
+	int getMaxConcurrency() const;
+	void setMaxConcurrency(int maxConcurrency);
+	int getTimeType() const;
+	void setTimeType(int timeType);
+
+private:
+	std::string namespaceSource_;
+	std::string timezone_;
+	std::string description_;
+	std::string regionId_;
+	std::string groupId_;
+	std::string timeExpression_;
+	std::string _namespace_;
+	std::string name_;
+	int maxConcurrency_;
+	int timeType_;
+};
+} // namespace Model
+} // namespace Schedulerx2
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEWORKFLOWREQUEST_H_

schedulerx2/include/alibabacloud/schedulerx2/model/CreateWorkflowResult.h

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

schedulerx2/include/alibabacloud/schedulerx2/model/ExecuteWorkflowRequest.h

@@ -34,6 +34,8 @@ public:
 	void setNamespaceSource(const std::string &namespaceSource);
 	std::string getGroupId() const;
 	void setGroupId(const std::string &groupId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
 	std::string get_Namespace() const;
 	void set_Namespace(const std::string &_namespace);
 	long getWorkflowId() const;
@@ -44,6 +46,7 @@ public:
 private:
 	std::string namespaceSource_;
 	std::string groupId_;
+	std::string regionId_;
 	std::string _namespace_;
 	long workflowId_;
 	std::string instanceParameters_;

schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInstanceListRequest.h

@@ -34,19 +34,28 @@ public:
 	void setNamespaceSource(const std::string &namespaceSource);
 	std::string getGroupId() const;
 	void setGroupId(const std::string &groupId);
+	long getStartTimestamp() const;
+	void setStartTimestamp(long startTimestamp);
+	long getEndTimestamp() const;
+	void setEndTimestamp(long endTimestamp);
 	long getJobId() const;
 	void setJobId(long jobId);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 	std::string get_Namespace() const;
 	void set_Namespace(const std::string &_namespace);
+	int getStatus() const;
+	void setStatus(int status);
 
 private:
 	std::string namespaceSource_;
 	std::string groupId_;
+	long startTimestamp_;
+	long endTimestamp_;
 	long jobId_;
 	std::string regionId_;
 	std::string _namespace_;
+	int status_;
 };
 } // namespace Model
 } // namespace Schedulerx2

schedulerx2/include/alibabacloud/schedulerx2/model/GetLogRequest.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_GETLOGREQUEST_H_
+#define ALIBABACLOUD_SCHEDULERX2_MODEL_GETLOGREQUEST_H_
+
+#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Schedulerx2 {
+namespace Model {
+class ALIBABACLOUD_SCHEDULERX2_EXPORT GetLogRequest : public RpcServiceRequest {
+public:
+	GetLogRequest();
+	~GetLogRequest();
+	std::string getNamespaceSource() const;
+	void setNamespaceSource(const std::string &namespaceSource);
+	int getLine() const;
+	void setLine(int line);
+	long getStartTimestamp() const;
+	void setStartTimestamp(long startTimestamp);
+	long getEndTimestamp() const;
+	void setEndTimestamp(long endTimestamp);
+	std::string getJobId() const;
+	void setJobId(const std::string &jobId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getKeyword() const;
+	void setKeyword(const std::string &keyword);
+	int getOffset() const;
+	void setOffset(int offset);
+	std::string getGroupId() const;
+	void setGroupId(const std::string &groupId);
+	bool getReverse() const;
+	void setReverse(bool reverse);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
+	std::string getJobInstanceId() const;
+	void setJobInstanceId(const std::string &jobInstanceId);
+
+private:
+	std::string namespaceSource_;
+	int line_;
+	long startTimestamp_;
+	long endTimestamp_;
+	std::string jobId_;
+	std::string regionId_;
+	std::string keyword_;
+	int offset_;
+	std::string groupId_;
+	bool reverse_;
+	std::string _namespace_;
+	std::string jobInstanceId_;
+};
+} // namespace Model
+} // namespace Schedulerx2
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GETLOGREQUEST_H_

schedulerx2/include/alibabacloud/schedulerx2/model/GetLogResult.h

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

schedulerx2/include/alibabacloud/schedulerx2/model/GetWorkflowInstanceRequest.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_SCHEDULERX2_MODEL_GETWORKFLOWINSTANCEREQUEST_H_
+#define ALIBABACLOUD_SCHEDULERX2_MODEL_GETWORKFLOWINSTANCEREQUEST_H_
+
+#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Schedulerx2 {
+namespace Model {
+class ALIBABACLOUD_SCHEDULERX2_EXPORT GetWorkflowInstanceRequest : public RpcServiceRequest {
+public:
+	GetWorkflowInstanceRequest();
+	~GetWorkflowInstanceRequest();
+	std::string getNamespaceSource() const;
+	void setNamespaceSource(const std::string &namespaceSource);
+	std::string getGroupId() const;
+	void setGroupId(const std::string &groupId);
+	long getWfInstanceId() const;
+	void setWfInstanceId(long wfInstanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
+	long getWorkflowId() const;
+	void setWorkflowId(long workflowId);
+
+private:
+	std::string namespaceSource_;
+	std::string groupId_;
+	long wfInstanceId_;
+	std::string regionId_;
+	std::string _namespace_;
+	long workflowId_;
+};
+} // namespace Model
+} // namespace Schedulerx2
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GETWORKFLOWINSTANCEREQUEST_H_

schedulerx2/include/alibabacloud/schedulerx2/model/GetWorkflowInstanceResult.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_SCHEDULERX2_MODEL_GETWORKFLOWINSTANCERESULT_H_
+#define ALIBABACLOUD_SCHEDULERX2_MODEL_GETWORKFLOWINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
+
+namespace AlibabaCloud
+{
+	namespace Schedulerx2
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCHEDULERX2_EXPORT GetWorkflowInstanceResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct WfInstanceInfo
+					{
+						int status;
+						std::string endTime;
+						std::string scheduleTime;
+						std::string startTime;
+						std::string dataTime;
+					};
+					struct WfInstanceDag
+					{
+						struct Node
+						{
+							std::string endTime;
+							std::string scheduleTime;
+							int attempt;
+							long jobInstanceId;
+							std::string workAddr;
+							std::string startTime;
+							std::string dataTime;
+							long jobId;
+							std::string result;
+						};
+						struct Edge
+						{
+							long target;
+							long source;
+						};
+						std::vector<Edge> edges;
+						std::vector<Node> nodes;
+					};
+					WfInstanceInfo wfInstanceInfo;
+					WfInstanceDag wfInstanceDag;
+				};
+
+
+				GetWorkflowInstanceResult();
+				explicit GetWorkflowInstanceResult(const std::string &payload);
+				~GetWorkflowInstanceResult();
+				std::string getMessage()const;
+				Data getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GETWORKFLOWINSTANCERESULT_H_

schedulerx2/include/alibabacloud/schedulerx2/model/ListGroupsResult.h

@@ -37,6 +37,7 @@ namespace AlibabaCloud
 					struct AppGroup
 					{
 						std::string description;
+						long appGroupId;
 						std::string appKey;
 						std::string appName;
 						std::string groupId;

schedulerx2/include/alibabacloud/schedulerx2/model/ListWorkflowInstanceRequest.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_SCHEDULERX2_MODEL_LISTWORKFLOWINSTANCEREQUEST_H_
+#define ALIBABACLOUD_SCHEDULERX2_MODEL_LISTWORKFLOWINSTANCEREQUEST_H_
+
+#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Schedulerx2 {
+namespace Model {
+class ALIBABACLOUD_SCHEDULERX2_EXPORT ListWorkflowInstanceRequest : public RpcServiceRequest {
+public:
+	ListWorkflowInstanceRequest();
+	~ListWorkflowInstanceRequest();
+	std::string getNamespaceSource() const;
+	void setNamespaceSource(const std::string &namespaceSource);
+	std::string getGroupId() const;
+	void setGroupId(const std::string &groupId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
+	std::string getWorkflowId() const;
+	void setWorkflowId(const std::string &workflowId);
+
+private:
+	std::string namespaceSource_;
+	std::string groupId_;
+	std::string regionId_;
+	std::string _namespace_;
+	std::string workflowId_;
+};
+} // namespace Model
+} // namespace Schedulerx2
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_LISTWORKFLOWINSTANCEREQUEST_H_

schedulerx2/include/alibabacloud/schedulerx2/model/ListWorkflowInstanceResult.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_LISTWORKFLOWINSTANCERESULT_H_
+#define ALIBABACLOUD_SCHEDULERX2_MODEL_LISTWORKFLOWINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
+
+namespace AlibabaCloud
+{
+	namespace Schedulerx2
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCHEDULERX2_EXPORT ListWorkflowInstanceResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct WfInstanceInfosItem
+					{
+						int status;
+						std::string endTime;
+						std::string scheduleTime;
+						std::string startTime;
+						std::string dataTime;
+						long wfInstanceId;
+						long workflowId;
+					};
+					std::vector<WfInstanceInfosItem> wfInstanceInfos;
+				};
+
+
+				ListWorkflowInstanceResult();
+				explicit ListWorkflowInstanceResult(const std::string &payload);
+				~ListWorkflowInstanceResult();
+				std::string getMessage()const;
+				Data getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_LISTWORKFLOWINSTANCERESULT_H_

schedulerx2/include/alibabacloud/schedulerx2/model/RerunJobRequest.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_SCHEDULERX2_MODEL_RERUNJOBREQUEST_H_
+#define ALIBABACLOUD_SCHEDULERX2_MODEL_RERUNJOBREQUEST_H_
+
+#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Schedulerx2 {
+namespace Model {
+class ALIBABACLOUD_SCHEDULERX2_EXPORT RerunJobRequest : public RpcServiceRequest {
+public:
+	RerunJobRequest();
+	~RerunJobRequest();
+	std::string getNamespaceSource() const;
+	void setNamespaceSource(const std::string &namespaceSource);
+	std::string getDataTime() const;
+	void setDataTime(const std::string &dataTime);
+	std::string getGroupId() const;
+	void setGroupId(const std::string &groupId);
+	long getStartDate() const;
+	void setStartDate(long startDate);
+	long getJobId() const;
+	void setJobId(long jobId);
+	long getEndDate() const;
+	void setEndDate(long endDate);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
+
+private:
+	std::string namespaceSource_;
+	std::string dataTime_;
+	std::string groupId_;
+	long startDate_;
+	long jobId_;
+	long endDate_;
+	std::string regionId_;
+	std::string _namespace_;
+};
+} // namespace Model
+} // namespace Schedulerx2
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_RERUNJOBREQUEST_H_

schedulerx2/include/alibabacloud/schedulerx2/model/RerunJobResult.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_SCHEDULERX2_MODEL_RERUNJOBRESULT_H_
+#define ALIBABACLOUD_SCHEDULERX2_MODEL_RERUNJOBRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
+
+namespace AlibabaCloud
+{
+	namespace Schedulerx2
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCHEDULERX2_EXPORT RerunJobResult : public ServiceResult
+			{
+			public:
+
+
+				RerunJobResult();
+				explicit RerunJobResult(const std::string &payload);
+				~RerunJobResult();
+				std::string getMessage()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_RERUNJOBRESULT_H_

schedulerx2/include/alibabacloud/schedulerx2/model/RetryJobInstanceRequest.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_SCHEDULERX2_MODEL_RETRYJOBINSTANCEREQUEST_H_
+#define ALIBABACLOUD_SCHEDULERX2_MODEL_RETRYJOBINSTANCEREQUEST_H_
+
+#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Schedulerx2 {
+namespace Model {
+class ALIBABACLOUD_SCHEDULERX2_EXPORT RetryJobInstanceRequest : public RpcServiceRequest {
+public:
+	RetryJobInstanceRequest();
+	~RetryJobInstanceRequest();
+	std::string getNamespaceSource() const;
+	void setNamespaceSource(const std::string &namespaceSource);
+	std::string getGroupId() const;
+	void setGroupId(const std::string &groupId);
+	long getJobId() const;
+	void setJobId(long jobId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
+	long getJobInstanceId() const;
+	void setJobInstanceId(long jobInstanceId);
+
+private:
+	std::string namespaceSource_;
+	std::string groupId_;
+	long jobId_;
+	std::string regionId_;
+	std::string _namespace_;
+	long jobInstanceId_;
+};
+} // namespace Model
+} // namespace Schedulerx2
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_RETRYJOBINSTANCEREQUEST_H_

schedulerx2/include/alibabacloud/schedulerx2/model/RetryJobInstanceResult.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_SCHEDULERX2_MODEL_RETRYJOBINSTANCERESULT_H_
+#define ALIBABACLOUD_SCHEDULERX2_MODEL_RETRYJOBINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
+
+namespace AlibabaCloud
+{
+	namespace Schedulerx2
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCHEDULERX2_EXPORT RetryJobInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				RetryJobInstanceResult();
+				explicit RetryJobInstanceResult(const std::string &payload);
+				~RetryJobInstanceResult();
+				std::string getMessage()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_RETRYJOBINSTANCERESULT_H_

schedulerx2/include/alibabacloud/schedulerx2/model/SetJobInstanceSuccessRequest.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_SCHEDULERX2_MODEL_SETJOBINSTANCESUCCESSREQUEST_H_
+#define ALIBABACLOUD_SCHEDULERX2_MODEL_SETJOBINSTANCESUCCESSREQUEST_H_
+
+#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Schedulerx2 {
+namespace Model {
+class ALIBABACLOUD_SCHEDULERX2_EXPORT SetJobInstanceSuccessRequest : public RpcServiceRequest {
+public:
+	SetJobInstanceSuccessRequest();
+	~SetJobInstanceSuccessRequest();
+	std::string getNamespaceSource() const;
+	void setNamespaceSource(const std::string &namespaceSource);
+	std::string getGroupId() const;
+	void setGroupId(const std::string &groupId);
+	long getJobId() const;
+	void setJobId(long jobId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
+	long getJobInstanceId() const;
+	void setJobInstanceId(long jobInstanceId);
+
+private:
+	std::string namespaceSource_;
+	std::string groupId_;
+	long jobId_;
+	std::string regionId_;
+	std::string _namespace_;
+	long jobInstanceId_;
+};
+} // namespace Model
+} // namespace Schedulerx2
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_SETJOBINSTANCESUCCESSREQUEST_H_

schedulerx2/include/alibabacloud/schedulerx2/model/SetJobInstanceSuccessResult.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_SCHEDULERX2_MODEL_SETJOBINSTANCESUCCESSRESULT_H_
+#define ALIBABACLOUD_SCHEDULERX2_MODEL_SETJOBINSTANCESUCCESSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
+
+namespace AlibabaCloud
+{
+	namespace Schedulerx2
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCHEDULERX2_EXPORT SetJobInstanceSuccessResult : public ServiceResult
+			{
+			public:
+
+
+				SetJobInstanceSuccessResult();
+				explicit SetJobInstanceSuccessResult(const std::string &payload);
+				~SetJobInstanceSuccessResult();
+				std::string getMessage()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_SETJOBINSTANCESUCCESSRESULT_H_

schedulerx2/include/alibabacloud/schedulerx2/model/SetWfInstanceSuccessRequest.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_SCHEDULERX2_MODEL_SETWFINSTANCESUCCESSREQUEST_H_
+#define ALIBABACLOUD_SCHEDULERX2_MODEL_SETWFINSTANCESUCCESSREQUEST_H_
+
+#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Schedulerx2 {
+namespace Model {
+class ALIBABACLOUD_SCHEDULERX2_EXPORT SetWfInstanceSuccessRequest : public RpcServiceRequest {
+public:
+	SetWfInstanceSuccessRequest();
+	~SetWfInstanceSuccessRequest();
+	std::string getNamespaceSource() const;
+	void setNamespaceSource(const std::string &namespaceSource);
+	std::string getGroupId() const;
+	void setGroupId(const std::string &groupId);
+	long getWfInstanceId() const;
+	void setWfInstanceId(long wfInstanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
+	long getWorkflowId() const;
+	void setWorkflowId(long workflowId);
+
+private:
+	std::string namespaceSource_;
+	std::string groupId_;
+	long wfInstanceId_;
+	std::string regionId_;
+	std::string _namespace_;
+	long workflowId_;
+};
+} // namespace Model
+} // namespace Schedulerx2
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_SETWFINSTANCESUCCESSREQUEST_H_

schedulerx2/include/alibabacloud/schedulerx2/model/SetWfInstanceSuccessResult.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_SCHEDULERX2_MODEL_SETWFINSTANCESUCCESSRESULT_H_
+#define ALIBABACLOUD_SCHEDULERX2_MODEL_SETWFINSTANCESUCCESSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
+
+namespace AlibabaCloud
+{
+	namespace Schedulerx2
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCHEDULERX2_EXPORT SetWfInstanceSuccessResult : public ServiceResult
+			{
+			public:
+
+
+				SetWfInstanceSuccessResult();
+				explicit SetWfInstanceSuccessResult(const std::string &payload);
+				~SetWfInstanceSuccessResult();
+				std::string getMessage()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_SETWFINSTANCESUCCESSRESULT_H_

schedulerx2/include/alibabacloud/schedulerx2/model/UpdateJobRequest.h

@@ -36,104 +36,110 @@ public:
 	};
 	UpdateJobRequest();
 	~UpdateJobRequest();
+	int getAttemptInterval() const;
+	void setAttemptInterval(int attemptInterval);
+	int getFailTimes() const;
+	void setFailTimes(int failTimes);
+	long getJobId() const;
+	void setJobId(long jobId);
+	int getConsumerSize() const;
+	void setConsumerSize(int consumerSize);
+	std::string getJarUrl() const;
+	void setJarUrl(const std::string &jarUrl);
+	std::string getGroupId() const;
+	void setGroupId(const std::string &groupId);
+	int getTaskMaxAttempt() const;
+	void setTaskMaxAttempt(int taskMaxAttempt);
+	int getDataOffset() const;
+	void setDataOffset(int dataOffset);
+	int getDispatcherSize() const;
+	void setDispatcherSize(int dispatcherSize);
+	int getTaskAttemptInterval() const;
+	void setTaskAttemptInterval(int taskAttemptInterval);
+	std::string getExecuteMode() const;
+	void setExecuteMode(const std::string &executeMode);
+	std::string getTimeExpression() const;
+	void setTimeExpression(const std::string &timeExpression);
+	bool getTimeoutEnable() const;
+	void setTimeoutEnable(bool timeoutEnable);
+	std::vector<ContactInfo> getContactInfo() const;
+	void setContactInfo(const std::vector<ContactInfo> &contactInfo);
+	std::string getName() const;
+	void setName(const std::string &name);
+	int getTimeType() const;
+	void setTimeType(int timeType);
+	std::string getParameters() const;
+	void setParameters(const std::string &parameters);
 	std::string getNamespaceSource() const;
 	void setNamespaceSource(const std::string &namespaceSource);
 	std::string getDescription() const;
 	void setDescription(const std::string &description);
-	int getAttemptInterval() const;
-	void setAttemptInterval(int attemptInterval);
 	std::string getContent() const;
 	void setContent(const std::string &content);
 	long getTimeout() const;
 	void setTimeout(long timeout);
 	bool getTimeoutKillEnable() const;
 	void setTimeoutKillEnable(bool timeoutKillEnable);
-	long getJobId() const;
-	void setJobId(long jobId);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 	int getPageSize() const;
 	void setPageSize(int pageSize);
-	int getConsumerSize() const;
-	void setConsumerSize(int consumerSize);
-	std::string getJarUrl() const;
-	void setJarUrl(const std::string &jarUrl);
 	std::string getCalendar() const;
 	void setCalendar(const std::string &calendar);
 	bool getFailEnable() const;
 	void setFailEnable(bool failEnable);
 	std::string getSendChannel() const;
 	void setSendChannel(const std::string &sendChannel);
-	int getDataOffset() const;
-	void setDataOffset(int dataOffset);
-	std::string getGroupId() const;
-	void setGroupId(const std::string &groupId);
-	int getTaskMaxAttempt() const;
-	void setTaskMaxAttempt(int taskMaxAttempt);
 	int getMaxAttempt() const;
 	void setMaxAttempt(int maxAttempt);
 	bool getMissWorkerEnable() const;
 	void setMissWorkerEnable(bool missWorkerEnable);
-	int getDispatcherSize() const;
-	void setDispatcherSize(int dispatcherSize);
-	int getTaskAttemptInterval() const;
-	void setTaskAttemptInterval(int taskAttemptInterval);
-	std::string getExecuteMode() const;
-	void setExecuteMode(const std::string &executeMode);
+	bool getSuccessNoticeEnable() const;
+	void setSuccessNoticeEnable(bool successNoticeEnable);
 	int getQueueSize() const;
 	void setQueueSize(int queueSize);
-	std::string getTimeExpression() const;
-	void setTimeExpression(const std::string &timeExpression);
 	std::string getClassName() const;
 	void setClassName(const std::string &className);
-	bool getTimeoutEnable() const;
-	void setTimeoutEnable(bool timeoutEnable);
-	std::vector<ContactInfo> getContactInfo() const;
-	void setContactInfo(const std::vector<ContactInfo> &contactInfo);
-	std::string getName() const;
-	void setName(const std::string &name);
 	std::string get_Namespace() const;
 	void set_Namespace(const std::string &_namespace);
 	int getMaxConcurrency() const;
 	void setMaxConcurrency(int maxConcurrency);
-	int getTimeType() const;
-	void setTimeType(int timeType);
-	std::string getParameters() const;
-	void setParameters(const std::string &parameters);
 
 private:
+	int attemptInterval_;
+	int failTimes_;
+	long jobId_;
+	int consumerSize_;
+	std::string jarUrl_;
+	std::string groupId_;
+	int taskMaxAttempt_;
+	int dataOffset_;
+	int dispatcherSize_;
+	int taskAttemptInterval_;
+	std::string executeMode_;
+	std::string timeExpression_;
+	bool timeoutEnable_;
+	std::vector<ContactInfo> contactInfo_;
+	std::string name_;
+	int timeType_;
+	std::string parameters_;
 	std::string namespaceSource_;
 	std::string description_;
-	int attemptInterval_;
 	std::string content_;
 	long timeout_;
 	bool timeoutKillEnable_;
-	long jobId_;
 	std::string regionId_;
 	int pageSize_;
-	int consumerSize_;
-	std::string jarUrl_;
 	std::string calendar_;
 	bool failEnable_;
 	std::string sendChannel_;
-	int dataOffset_;
-	std::string groupId_;
-	int taskMaxAttempt_;
 	int maxAttempt_;
 	bool missWorkerEnable_;
-	int dispatcherSize_;
-	int taskAttemptInterval_;
-	std::string executeMode_;
+	bool successNoticeEnable_;
 	int queueSize_;
-	std::string timeExpression_;
 	std::string className_;
-	bool timeoutEnable_;
-	std::vector<ContactInfo> contactInfo_;
-	std::string name_;
 	std::string _namespace_;
 	int maxConcurrency_;
-	int timeType_;
-	std::string parameters_;
 };
 } // namespace Model
 } // namespace Schedulerx2

schedulerx2/include/alibabacloud/schedulerx2/model/UpdateWorkflowDagRequest.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_SCHEDULERX2_MODEL_UPDATEWORKFLOWDAGREQUEST_H_
+#define ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEWORKFLOWDAGREQUEST_H_
+
+#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Schedulerx2 {
+namespace Model {
+class ALIBABACLOUD_SCHEDULERX2_EXPORT UpdateWorkflowDagRequest : public RpcServiceRequest {
+public:
+	UpdateWorkflowDagRequest();
+	~UpdateWorkflowDagRequest();
+	std::string getDagJson() const;
+	void setDagJson(const std::string &dagJson);
+	std::string getNamespaceSource() const;
+	void setNamespaceSource(const std::string &namespaceSource);
+	std::string getGroupId() const;
+	void setGroupId(const std::string &groupId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
+	std::string getWorkflowId() const;
+	void setWorkflowId(const std::string &workflowId);
+
+private:
+	std::string dagJson_;
+	std::string namespaceSource_;
+	std::string groupId_;
+	std::string regionId_;
+	std::string _namespace_;
+	std::string workflowId_;
+};
+} // namespace Model
+} // namespace Schedulerx2
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEWORKFLOWDAGREQUEST_H_

schedulerx2/include/alibabacloud/schedulerx2/model/UpdateWorkflowDagResult.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_SCHEDULERX2_MODEL_UPDATEWORKFLOWDAGRESULT_H_
+#define ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEWORKFLOWDAGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
+
+namespace AlibabaCloud
+{
+	namespace Schedulerx2
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCHEDULERX2_EXPORT UpdateWorkflowDagResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateWorkflowDagResult();
+				explicit UpdateWorkflowDagResult(const std::string &payload);
+				~UpdateWorkflowDagResult();
+				std::string getMessage()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEWORKFLOWDAGRESULT_H_

schedulerx2/include/alibabacloud/schedulerx2/model/UpdateWorkflowRequest.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_SCHEDULERX2_MODEL_UPDATEWORKFLOWREQUEST_H_
+#define ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEWORKFLOWREQUEST_H_
+
+#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Schedulerx2 {
+namespace Model {
+class ALIBABACLOUD_SCHEDULERX2_EXPORT UpdateWorkflowRequest : public RpcServiceRequest {
+public:
+	UpdateWorkflowRequest();
+	~UpdateWorkflowRequest();
+	std::string getNamespaceSource() const;
+	void setNamespaceSource(const std::string &namespaceSource);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getWorkflowId() const;
+	void setWorkflowId(const std::string &workflowId);
+	std::string getGroupId() const;
+	void setGroupId(const std::string &groupId);
+	std::string getTimeExpression() const;
+	void setTimeExpression(const std::string &timeExpression);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
+	std::string getName() const;
+	void setName(const std::string &name);
+	int getTimeType() const;
+	void setTimeType(int timeType);
+
+private:
+	std::string namespaceSource_;
+	std::string description_;
+	std::string regionId_;
+	std::string workflowId_;
+	std::string groupId_;
+	std::string timeExpression_;
+	std::string _namespace_;
+	std::string name_;
+	int timeType_;
+};
+} // namespace Model
+} // namespace Schedulerx2
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEWORKFLOWREQUEST_H_

schedulerx2/include/alibabacloud/schedulerx2/model/UpdateWorkflowResult.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_SCHEDULERX2_MODEL_UPDATEWORKFLOWRESULT_H_
+#define ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEWORKFLOWRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/schedulerx2/Schedulerx2Export.h>
+
+namespace AlibabaCloud
+{
+	namespace Schedulerx2
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCHEDULERX2_EXPORT UpdateWorkflowResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateWorkflowResult();
+				explicit UpdateWorkflowResult(const std::string &payload);
+				~UpdateWorkflowResult();
+				std::string getMessage()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEWORKFLOWRESULT_H_

schedulerx2/src/Schedulerx2Client.cc

@@ -267,6 +267,42 @@ Schedulerx2Client::CreateNamespaceOutcomeCallable Schedulerx2Client::createNames
 	return task->get_future();
 }
 
+Schedulerx2Client::CreateWorkflowOutcome Schedulerx2Client::createWorkflow(const CreateWorkflowRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateWorkflowOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateWorkflowOutcome(CreateWorkflowResult(outcome.result()));
+	else
+		return CreateWorkflowOutcome(outcome.error());
+}
+
+void Schedulerx2Client::createWorkflowAsync(const CreateWorkflowRequest& request, const CreateWorkflowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createWorkflow(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Schedulerx2Client::CreateWorkflowOutcomeCallable Schedulerx2Client::createWorkflowCallable(const CreateWorkflowRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateWorkflowOutcome()>>(
+			[this, request]()
+			{
+			return this->createWorkflow(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Schedulerx2Client::DeleteJobOutcome Schedulerx2Client::deleteJob(const DeleteJobRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -735,6 +771,42 @@ Schedulerx2Client::GetJobInstanceListOutcomeCallable Schedulerx2Client::getJobIn
 	return task->get_future();
 }
 
+Schedulerx2Client::GetLogOutcome Schedulerx2Client::getLog(const GetLogRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetLogOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetLogOutcome(GetLogResult(outcome.result()));
+	else
+		return GetLogOutcome(outcome.error());
+}
+
+void Schedulerx2Client::getLogAsync(const GetLogRequest& request, const GetLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getLog(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Schedulerx2Client::GetLogOutcomeCallable Schedulerx2Client::getLogCallable(const GetLogRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetLogOutcome()>>(
+			[this, request]()
+			{
+			return this->getLog(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Schedulerx2Client::GetWorkFlowOutcome Schedulerx2Client::getWorkFlow(const GetWorkFlowRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -807,6 +879,42 @@ Schedulerx2Client::GetWorkerListOutcomeCallable Schedulerx2Client::getWorkerList
 	return task->get_future();
 }
 
+Schedulerx2Client::GetWorkflowInstanceOutcome Schedulerx2Client::getWorkflowInstance(const GetWorkflowInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetWorkflowInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetWorkflowInstanceOutcome(GetWorkflowInstanceResult(outcome.result()));
+	else
+		return GetWorkflowInstanceOutcome(outcome.error());
+}
+
+void Schedulerx2Client::getWorkflowInstanceAsync(const GetWorkflowInstanceRequest& request, const GetWorkflowInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getWorkflowInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Schedulerx2Client::GetWorkflowInstanceOutcomeCallable Schedulerx2Client::getWorkflowInstanceCallable(const GetWorkflowInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetWorkflowInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->getWorkflowInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Schedulerx2Client::GrantPermissionOutcome Schedulerx2Client::grantPermission(const GrantPermissionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -951,6 +1059,114 @@ Schedulerx2Client::ListNamespacesOutcomeCallable Schedulerx2Client::listNamespac
 	return task->get_future();
 }
 
+Schedulerx2Client::ListWorkflowInstanceOutcome Schedulerx2Client::listWorkflowInstance(const ListWorkflowInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListWorkflowInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListWorkflowInstanceOutcome(ListWorkflowInstanceResult(outcome.result()));
+	else
+		return ListWorkflowInstanceOutcome(outcome.error());
+}
+
+void Schedulerx2Client::listWorkflowInstanceAsync(const ListWorkflowInstanceRequest& request, const ListWorkflowInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listWorkflowInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Schedulerx2Client::ListWorkflowInstanceOutcomeCallable Schedulerx2Client::listWorkflowInstanceCallable(const ListWorkflowInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListWorkflowInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->listWorkflowInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Schedulerx2Client::RerunJobOutcome Schedulerx2Client::rerunJob(const RerunJobRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RerunJobOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RerunJobOutcome(RerunJobResult(outcome.result()));
+	else
+		return RerunJobOutcome(outcome.error());
+}
+
+void Schedulerx2Client::rerunJobAsync(const RerunJobRequest& request, const RerunJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, rerunJob(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Schedulerx2Client::RerunJobOutcomeCallable Schedulerx2Client::rerunJobCallable(const RerunJobRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RerunJobOutcome()>>(
+			[this, request]()
+			{
+			return this->rerunJob(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Schedulerx2Client::RetryJobInstanceOutcome Schedulerx2Client::retryJobInstance(const RetryJobInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RetryJobInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RetryJobInstanceOutcome(RetryJobInstanceResult(outcome.result()));
+	else
+		return RetryJobInstanceOutcome(outcome.error());
+}
+
+void Schedulerx2Client::retryJobInstanceAsync(const RetryJobInstanceRequest& request, const RetryJobInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, retryJobInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Schedulerx2Client::RetryJobInstanceOutcomeCallable Schedulerx2Client::retryJobInstanceCallable(const RetryJobInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RetryJobInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->retryJobInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Schedulerx2Client::RevokePermissionOutcome Schedulerx2Client::revokePermission(const RevokePermissionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -987,6 +1203,78 @@ Schedulerx2Client::RevokePermissionOutcomeCallable Schedulerx2Client::revokePerm
 	return task->get_future();
 }
 
+Schedulerx2Client::SetJobInstanceSuccessOutcome Schedulerx2Client::setJobInstanceSuccess(const SetJobInstanceSuccessRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetJobInstanceSuccessOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetJobInstanceSuccessOutcome(SetJobInstanceSuccessResult(outcome.result()));
+	else
+		return SetJobInstanceSuccessOutcome(outcome.error());
+}
+
+void Schedulerx2Client::setJobInstanceSuccessAsync(const SetJobInstanceSuccessRequest& request, const SetJobInstanceSuccessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setJobInstanceSuccess(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Schedulerx2Client::SetJobInstanceSuccessOutcomeCallable Schedulerx2Client::setJobInstanceSuccessCallable(const SetJobInstanceSuccessRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetJobInstanceSuccessOutcome()>>(
+			[this, request]()
+			{
+			return this->setJobInstanceSuccess(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Schedulerx2Client::SetWfInstanceSuccessOutcome Schedulerx2Client::setWfInstanceSuccess(const SetWfInstanceSuccessRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetWfInstanceSuccessOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetWfInstanceSuccessOutcome(SetWfInstanceSuccessResult(outcome.result()));
+	else
+		return SetWfInstanceSuccessOutcome(outcome.error());
+}
+
+void Schedulerx2Client::setWfInstanceSuccessAsync(const SetWfInstanceSuccessRequest& request, const SetWfInstanceSuccessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setWfInstanceSuccess(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Schedulerx2Client::SetWfInstanceSuccessOutcomeCallable Schedulerx2Client::setWfInstanceSuccessCallable(const SetWfInstanceSuccessRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetWfInstanceSuccessOutcome()>>(
+			[this, request]()
+			{
+			return this->setWfInstanceSuccess(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Schedulerx2Client::StopInstanceOutcome Schedulerx2Client::stopInstance(const StopInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1059,3 +1347,75 @@ Schedulerx2Client::UpdateJobOutcomeCallable Schedulerx2Client::updateJobCallable
 	return task->get_future();
 }
 
+Schedulerx2Client::UpdateWorkflowOutcome Schedulerx2Client::updateWorkflow(const UpdateWorkflowRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateWorkflowOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateWorkflowOutcome(UpdateWorkflowResult(outcome.result()));
+	else
+		return UpdateWorkflowOutcome(outcome.error());
+}
+
+void Schedulerx2Client::updateWorkflowAsync(const UpdateWorkflowRequest& request, const UpdateWorkflowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateWorkflow(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Schedulerx2Client::UpdateWorkflowOutcomeCallable Schedulerx2Client::updateWorkflowCallable(const UpdateWorkflowRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateWorkflowOutcome()>>(
+			[this, request]()
+			{
+			return this->updateWorkflow(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Schedulerx2Client::UpdateWorkflowDagOutcome Schedulerx2Client::updateWorkflowDag(const UpdateWorkflowDagRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateWorkflowDagOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateWorkflowDagOutcome(UpdateWorkflowDagResult(outcome.result()));
+	else
+		return UpdateWorkflowDagOutcome(outcome.error());
+}
+
+void Schedulerx2Client::updateWorkflowDagAsync(const UpdateWorkflowDagRequest& request, const UpdateWorkflowDagAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateWorkflowDag(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Schedulerx2Client::UpdateWorkflowDagOutcomeCallable Schedulerx2Client::updateWorkflowDagCallable(const UpdateWorkflowDagRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateWorkflowDagOutcome()>>(
+			[this, request]()
+			{
+			return this->updateWorkflowDag(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

schedulerx2/src/model/CreateAppGroupRequest.cc

@@ -124,15 +124,6 @@ void CreateAppGroupRequest::setGroupId(const std::string &groupId) {
   setParameter(std::string("GroupId"), groupId);
 }
 
-int CreateAppGroupRequest::getAppType() const {
-  return appType_;
-}
-
-void CreateAppGroupRequest::setAppType(int appType) {
-  appType_ = appType;
-  setParameter(std::string("AppType"), std::to_string(appType));
-}
-
 std::string CreateAppGroupRequest::getMonitorConfigJson() const {
   return monitorConfigJson_;
 }

schedulerx2/src/model/CreateJobRequest.cc

@@ -34,6 +34,15 @@ void CreateJobRequest::setAttemptInterval(int attemptInterval) {
   setBodyParameter(std::string("AttemptInterval"), std::to_string(attemptInterval));
 }
 
+int CreateJobRequest::getFailTimes() const {
+  return failTimes_;
+}
+
+void CreateJobRequest::setFailTimes(int failTimes) {
+  failTimes_ = failTimes;
+  setBodyParameter(std::string("FailTimes"), std::to_string(failTimes));
+}
+
 int CreateJobRequest::getConsumerSize() const {
   return consumerSize_;
 }
@@ -52,15 +61,6 @@ void CreateJobRequest::setJarUrl(const std::string &jarUrl) {
   setBodyParameter(std::string("JarUrl"), jarUrl);
 }
 
-int CreateJobRequest::getDataOffset() const {
-  return dataOffset_;
-}
-
-void CreateJobRequest::setDataOffset(int dataOffset) {
-  dataOffset_ = dataOffset;
-  setBodyParameter(std::string("DataOffset"), std::to_string(dataOffset));
-}
-
 std::string CreateJobRequest::getGroupId() const {
   return groupId_;
 }
@@ -70,6 +70,15 @@ void CreateJobRequest::setGroupId(const std::string &groupId) {
   setBodyParameter(std::string("GroupId"), groupId);
 }
 
+int CreateJobRequest::getDataOffset() const {
+  return dataOffset_;
+}
+
+void CreateJobRequest::setDataOffset(int dataOffset) {
+  dataOffset_ = dataOffset;
+  setBodyParameter(std::string("DataOffset"), std::to_string(dataOffset));
+}
+
 int CreateJobRequest::getTaskMaxAttempt() const {
   return taskMaxAttempt_;
 }
@@ -293,6 +302,15 @@ void CreateJobRequest::setMissWorkerEnable(bool missWorkerEnable) {
   setBodyParameter(std::string("MissWorkerEnable"), missWorkerEnable ? "true" : "false");
 }
 
+bool CreateJobRequest::getSuccessNoticeEnable() const {
+  return successNoticeEnable_;
+}
+
+void CreateJobRequest::setSuccessNoticeEnable(bool successNoticeEnable) {
+  successNoticeEnable_ = successNoticeEnable;
+  setBodyParameter(std::string("SuccessNoticeEnable"), successNoticeEnable ? "true" : "false");
+}
+
 int CreateJobRequest::getQueueSize() const {
   return queueSize_;
 }

schedulerx2/src/model/CreateWorkflowRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/schedulerx2/model/CreateWorkflowRequest.h>
+
+using AlibabaCloud::Schedulerx2::Model::CreateWorkflowRequest;
+
+CreateWorkflowRequest::CreateWorkflowRequest()
+    : RpcServiceRequest("schedulerx2", "2019-04-30", "CreateWorkflow") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateWorkflowRequest::~CreateWorkflowRequest() {}
+
+std::string CreateWorkflowRequest::getNamespaceSource() const {
+  return namespaceSource_;
+}
+
+void CreateWorkflowRequest::setNamespaceSource(const std::string &namespaceSource) {
+  namespaceSource_ = namespaceSource;
+  setBodyParameter(std::string("NamespaceSource"), namespaceSource);
+}
+
+std::string CreateWorkflowRequest::getTimezone() const {
+  return timezone_;
+}
+
+void CreateWorkflowRequest::setTimezone(const std::string &timezone) {
+  timezone_ = timezone;
+  setBodyParameter(std::string("Timezone"), timezone);
+}
+
+std::string CreateWorkflowRequest::getDescription() const {
+  return description_;
+}
+
+void CreateWorkflowRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setBodyParameter(std::string("Description"), description);
+}
+
+std::string CreateWorkflowRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateWorkflowRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setBodyParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateWorkflowRequest::getGroupId() const {
+  return groupId_;
+}
+
+void CreateWorkflowRequest::setGroupId(const std::string &groupId) {
+  groupId_ = groupId;
+  setBodyParameter(std::string("GroupId"), groupId);
+}
+
+std::string CreateWorkflowRequest::getTimeExpression() const {
+  return timeExpression_;
+}
+
+void CreateWorkflowRequest::setTimeExpression(const std::string &timeExpression) {
+  timeExpression_ = timeExpression;
+  setBodyParameter(std::string("TimeExpression"), timeExpression);
+}
+
+std::string CreateWorkflowRequest::get_Namespace() const {
+  return _namespace_;
+}
+
+void CreateWorkflowRequest::set_Namespace(const std::string &_namespace) {
+  _namespace_ = _namespace;
+  setBodyParameter(std::string("Namespace"), _namespace);
+}
+
+std::string CreateWorkflowRequest::getName() const {
+  return name_;
+}
+
+void CreateWorkflowRequest::setName(const std::string &name) {
+  name_ = name;
+  setBodyParameter(std::string("Name"), name);
+}
+
+int CreateWorkflowRequest::getMaxConcurrency() const {
+  return maxConcurrency_;
+}
+
+void CreateWorkflowRequest::setMaxConcurrency(int maxConcurrency) {
+  maxConcurrency_ = maxConcurrency;
+  setBodyParameter(std::string("MaxConcurrency"), std::to_string(maxConcurrency));
+}
+
+int CreateWorkflowRequest::getTimeType() const {
+  return timeType_;
+}
+
+void CreateWorkflowRequest::setTimeType(int timeType) {
+  timeType_ = timeType;
+  setBodyParameter(std::string("TimeType"), std::to_string(timeType));
+}
+

schedulerx2/src/model/CreateWorkflowResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/schedulerx2/model/CreateWorkflowResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Schedulerx2;
+using namespace AlibabaCloud::Schedulerx2::Model;
+
+CreateWorkflowResult::CreateWorkflowResult() :
+	ServiceResult()
+{}
+
+CreateWorkflowResult::CreateWorkflowResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateWorkflowResult::~CreateWorkflowResult()
+{}
+
+void CreateWorkflowResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["WorkflowId"].isNull())
+		data_.workflowId = std::stol(dataNode["WorkflowId"].asString());
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string CreateWorkflowResult::getMessage()const
+{
+	return message_;
+}
+
+CreateWorkflowResult::Data CreateWorkflowResult::getData()const
+{
+	return data_;
+}
+
+std::string CreateWorkflowResult::getCode()const
+{
+	return code_;
+}
+
+bool CreateWorkflowResult::getSuccess()const
+{
+	return success_;
+}
+

schedulerx2/src/model/ExecuteWorkflowRequest.cc

@@ -43,6 +43,15 @@ void ExecuteWorkflowRequest::setGroupId(const std::string &groupId) {
   setParameter(std::string("GroupId"), groupId);
 }
 
+std::string ExecuteWorkflowRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ExecuteWorkflowRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
 std::string ExecuteWorkflowRequest::get_Namespace() const {
   return _namespace_;
 }

schedulerx2/src/model/GetJobInstanceListRequest.cc

@@ -43,6 +43,24 @@ void GetJobInstanceListRequest::setGroupId(const std::string &groupId) {
   setParameter(std::string("GroupId"), groupId);
 }
 
+long GetJobInstanceListRequest::getStartTimestamp() const {
+  return startTimestamp_;
+}
+
+void GetJobInstanceListRequest::setStartTimestamp(long startTimestamp) {
+  startTimestamp_ = startTimestamp;
+  setParameter(std::string("StartTimestamp"), std::to_string(startTimestamp));
+}
+
+long GetJobInstanceListRequest::getEndTimestamp() const {
+  return endTimestamp_;
+}
+
+void GetJobInstanceListRequest::setEndTimestamp(long endTimestamp) {
+  endTimestamp_ = endTimestamp;
+  setParameter(std::string("EndTimestamp"), std::to_string(endTimestamp));
+}
+
 long GetJobInstanceListRequest::getJobId() const {
   return jobId_;
 }
@@ -70,3 +88,12 @@ void GetJobInstanceListRequest::set_Namespace(const std::string &_namespace) {
   setParameter(std::string("Namespace"), _namespace);
 }
 
+int GetJobInstanceListRequest::getStatus() const {
+  return status_;
+}
+
+void GetJobInstanceListRequest::setStatus(int status) {
+  status_ = status;
+  setParameter(std::string("Status"), std::to_string(status));
+}
+

schedulerx2/src/model/GetLogRequest.cc

@@ -0,0 +1,135 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/schedulerx2/model/GetLogRequest.h>
+
+using AlibabaCloud::Schedulerx2::Model::GetLogRequest;
+
+GetLogRequest::GetLogRequest()
+    : RpcServiceRequest("schedulerx2", "2019-04-30", "GetLog") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+GetLogRequest::~GetLogRequest() {}
+
+std::string GetLogRequest::getNamespaceSource() const {
+  return namespaceSource_;
+}
+
+void GetLogRequest::setNamespaceSource(const std::string &namespaceSource) {
+  namespaceSource_ = namespaceSource;
+  setParameter(std::string("NamespaceSource"), namespaceSource);
+}
+
+int GetLogRequest::getLine() const {
+  return line_;
+}
+
+void GetLogRequest::setLine(int line) {
+  line_ = line;
+  setParameter(std::string("Line"), std::to_string(line));
+}
+
+long GetLogRequest::getStartTimestamp() const {
+  return startTimestamp_;
+}
+
+void GetLogRequest::setStartTimestamp(long startTimestamp) {
+  startTimestamp_ = startTimestamp;
+  setParameter(std::string("StartTimestamp"), std::to_string(startTimestamp));
+}
+
+long GetLogRequest::getEndTimestamp() const {
+  return endTimestamp_;
+}
+
+void GetLogRequest::setEndTimestamp(long endTimestamp) {
+  endTimestamp_ = endTimestamp;
+  setParameter(std::string("EndTimestamp"), std::to_string(endTimestamp));
+}
+
+std::string GetLogRequest::getJobId() const {
+  return jobId_;
+}
+
+void GetLogRequest::setJobId(const std::string &jobId) {
+  jobId_ = jobId;
+  setParameter(std::string("JobId"), jobId);
+}
+
+std::string GetLogRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetLogRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string GetLogRequest::getKeyword() const {
+  return keyword_;
+}
+
+void GetLogRequest::setKeyword(const std::string &keyword) {
+  keyword_ = keyword;
+  setParameter(std::string("Keyword"), keyword);
+}
+
+int GetLogRequest::getOffset() const {
+  return offset_;
+}
+
+void GetLogRequest::setOffset(int offset) {
+  offset_ = offset;
+  setParameter(std::string("Offset"), std::to_string(offset));
+}
+
+std::string GetLogRequest::getGroupId() const {
+  return groupId_;
+}
+
+void GetLogRequest::setGroupId(const std::string &groupId) {
+  groupId_ = groupId;
+  setParameter(std::string("GroupId"), groupId);
+}
+
+bool GetLogRequest::getReverse() const {
+  return reverse_;
+}
+
+void GetLogRequest::setReverse(bool reverse) {
+  reverse_ = reverse;
+  setParameter(std::string("Reverse"), reverse ? "true" : "false");
+}
+
+std::string GetLogRequest::get_Namespace() const {
+  return _namespace_;
+}
+
+void GetLogRequest::set_Namespace(const std::string &_namespace) {
+  _namespace_ = _namespace;
+  setParameter(std::string("Namespace"), _namespace);
+}
+
+std::string GetLogRequest::getJobInstanceId() const {
+  return jobInstanceId_;
+}
+
+void GetLogRequest::setJobInstanceId(const std::string &jobInstanceId) {
+  jobInstanceId_ = jobInstanceId;
+  setParameter(std::string("JobInstanceId"), jobInstanceId);
+}
+

schedulerx2/src/model/GetLogResult.cc

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/schedulerx2/model/GetLogResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Schedulerx2;
+using namespace AlibabaCloud::Schedulerx2::Model;
+
+GetLogResult::GetLogResult() :
+	ServiceResult()
+{}
+
+GetLogResult::GetLogResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetLogResult::~GetLogResult()
+{}
+
+void GetLogResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+		auto allLogs = dataNode["Logs"]["Logs"];
+		for (auto value : allLogs)
+			data_.logs.push_back(value.asString());
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string GetLogResult::getMessage()const
+{
+	return message_;
+}
+
+GetLogResult::Data GetLogResult::getData()const
+{
+	return data_;
+}
+
+int GetLogResult::getCode()const
+{
+	return code_;
+}
+
+bool GetLogResult::getSuccess()const
+{
+	return success_;
+}
+

schedulerx2/src/model/GetWorkflowInstanceRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/schedulerx2/model/GetWorkflowInstanceRequest.h>
+
+using AlibabaCloud::Schedulerx2::Model::GetWorkflowInstanceRequest;
+
+GetWorkflowInstanceRequest::GetWorkflowInstanceRequest()
+    : RpcServiceRequest("schedulerx2", "2019-04-30", "GetWorkflowInstance") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+GetWorkflowInstanceRequest::~GetWorkflowInstanceRequest() {}
+
+std::string GetWorkflowInstanceRequest::getNamespaceSource() const {
+  return namespaceSource_;
+}
+
+void GetWorkflowInstanceRequest::setNamespaceSource(const std::string &namespaceSource) {
+  namespaceSource_ = namespaceSource;
+  setParameter(std::string("NamespaceSource"), namespaceSource);
+}
+
+std::string GetWorkflowInstanceRequest::getGroupId() const {
+  return groupId_;
+}
+
+void GetWorkflowInstanceRequest::setGroupId(const std::string &groupId) {
+  groupId_ = groupId;
+  setParameter(std::string("GroupId"), groupId);
+}
+
+long GetWorkflowInstanceRequest::getWfInstanceId() const {
+  return wfInstanceId_;
+}
+
+void GetWorkflowInstanceRequest::setWfInstanceId(long wfInstanceId) {
+  wfInstanceId_ = wfInstanceId;
+  setParameter(std::string("WfInstanceId"), std::to_string(wfInstanceId));
+}
+
+std::string GetWorkflowInstanceRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetWorkflowInstanceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string GetWorkflowInstanceRequest::get_Namespace() const {
+  return _namespace_;
+}
+
+void GetWorkflowInstanceRequest::set_Namespace(const std::string &_namespace) {
+  _namespace_ = _namespace;
+  setParameter(std::string("Namespace"), _namespace);
+}
+
+long GetWorkflowInstanceRequest::getWorkflowId() const {
+  return workflowId_;
+}
+
+void GetWorkflowInstanceRequest::setWorkflowId(long workflowId) {
+  workflowId_ = workflowId;
+  setParameter(std::string("WorkflowId"), std::to_string(workflowId));
+}
+

schedulerx2/src/model/GetWorkflowInstanceResult.cc

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/schedulerx2/model/GetWorkflowInstanceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Schedulerx2;
+using namespace AlibabaCloud::Schedulerx2::Model;
+
+GetWorkflowInstanceResult::GetWorkflowInstanceResult() :
+	ServiceResult()
+{}
+
+GetWorkflowInstanceResult::GetWorkflowInstanceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetWorkflowInstanceResult::~GetWorkflowInstanceResult()
+{}
+
+void GetWorkflowInstanceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto wfInstanceInfoNode = dataNode["WfInstanceInfo"];
+	if(!wfInstanceInfoNode["Status"].isNull())
+		data_.wfInstanceInfo.status = std::stoi(wfInstanceInfoNode["Status"].asString());
+	if(!wfInstanceInfoNode["StartTime"].isNull())
+		data_.wfInstanceInfo.startTime = wfInstanceInfoNode["StartTime"].asString();
+	if(!wfInstanceInfoNode["EndTime"].isNull())
+		data_.wfInstanceInfo.endTime = wfInstanceInfoNode["EndTime"].asString();
+	if(!wfInstanceInfoNode["ScheduleTime"].isNull())
+		data_.wfInstanceInfo.scheduleTime = wfInstanceInfoNode["ScheduleTime"].asString();
+	if(!wfInstanceInfoNode["DataTime"].isNull())
+		data_.wfInstanceInfo.dataTime = wfInstanceInfoNode["DataTime"].asString();
+	auto wfInstanceDagNode = dataNode["WfInstanceDag"];
+	auto allNodesNode = wfInstanceDagNode["Nodes"]["Node"];
+	for (auto wfInstanceDagNodeNodesNode : allNodesNode)
+	{
+		Data::WfInstanceDag::Node nodeObject;
+		if(!wfInstanceDagNodeNodesNode["JobInstanceId"].isNull())
+			nodeObject.jobInstanceId = std::stol(wfInstanceDagNodeNodesNode["JobInstanceId"].asString());
+		if(!wfInstanceDagNodeNodesNode["JobId"].isNull())
+			nodeObject.jobId = std::stol(wfInstanceDagNodeNodesNode["JobId"].asString());
+		if(!wfInstanceDagNodeNodesNode["StartTime"].isNull())
+			nodeObject.startTime = wfInstanceDagNodeNodesNode["StartTime"].asString();
+		if(!wfInstanceDagNodeNodesNode["EndTime"].isNull())
+			nodeObject.endTime = wfInstanceDagNodeNodesNode["EndTime"].asString();
+		if(!wfInstanceDagNodeNodesNode["ScheduleTime"].isNull())
+			nodeObject.scheduleTime = wfInstanceDagNodeNodesNode["ScheduleTime"].asString();
+		if(!wfInstanceDagNodeNodesNode["DataTime"].isNull())
+			nodeObject.dataTime = wfInstanceDagNodeNodesNode["DataTime"].asString();
+		if(!wfInstanceDagNodeNodesNode["WorkAddr"].isNull())
+			nodeObject.workAddr = wfInstanceDagNodeNodesNode["WorkAddr"].asString();
+		if(!wfInstanceDagNodeNodesNode["Result"].isNull())
+			nodeObject.result = wfInstanceDagNodeNodesNode["Result"].asString();
+		if(!wfInstanceDagNodeNodesNode["Attempt"].isNull())
+			nodeObject.attempt = std::stoi(wfInstanceDagNodeNodesNode["Attempt"].asString());
+		data_.wfInstanceDag.nodes.push_back(nodeObject);
+	}
+	auto allEdgesNode = wfInstanceDagNode["Edges"]["Edge"];
+	for (auto wfInstanceDagNodeEdgesEdge : allEdgesNode)
+	{
+		Data::WfInstanceDag::Edge edgeObject;
+		if(!wfInstanceDagNodeEdgesEdge["Source"].isNull())
+			edgeObject.source = std::stol(wfInstanceDagNodeEdgesEdge["Source"].asString());
+		if(!wfInstanceDagNodeEdgesEdge["Target"].isNull())
+			edgeObject.target = std::stol(wfInstanceDagNodeEdgesEdge["Target"].asString());
+		data_.wfInstanceDag.edges.push_back(edgeObject);
+	}
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string GetWorkflowInstanceResult::getMessage()const
+{
+	return message_;
+}
+
+GetWorkflowInstanceResult::Data GetWorkflowInstanceResult::getData()const
+{
+	return data_;
+}
+
+int GetWorkflowInstanceResult::getCode()const
+{
+	return code_;
+}
+
+bool GetWorkflowInstanceResult::getSuccess()const
+{
+	return success_;
+}
+

schedulerx2/src/model/ListGroupsResult.cc

@@ -44,6 +44,8 @@ void ListGroupsResult::parse(const std::string &payload)
 	for (auto dataNodeAppGroupsAppGroup : allAppGroupsNode)
 	{
 		Data::AppGroup appGroupObject;
+		if(!dataNodeAppGroupsAppGroup["AppGroupId"].isNull())
+			appGroupObject.appGroupId = std::stol(dataNodeAppGroupsAppGroup["AppGroupId"].asString());
 		if(!dataNodeAppGroupsAppGroup["AppName"].isNull())
 			appGroupObject.appName = dataNodeAppGroupsAppGroup["AppName"].asString();
 		if(!dataNodeAppGroupsAppGroup["AppKey"].isNull())

schedulerx2/src/model/ListWorkflowInstanceRequest.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/schedulerx2/model/ListWorkflowInstanceRequest.h>
+
+using AlibabaCloud::Schedulerx2::Model::ListWorkflowInstanceRequest;
+
+ListWorkflowInstanceRequest::ListWorkflowInstanceRequest()
+    : RpcServiceRequest("schedulerx2", "2019-04-30", "ListWorkflowInstance") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+ListWorkflowInstanceRequest::~ListWorkflowInstanceRequest() {}
+
+std::string ListWorkflowInstanceRequest::getNamespaceSource() const {
+  return namespaceSource_;
+}
+
+void ListWorkflowInstanceRequest::setNamespaceSource(const std::string &namespaceSource) {
+  namespaceSource_ = namespaceSource;
+  setParameter(std::string("NamespaceSource"), namespaceSource);
+}
+
+std::string ListWorkflowInstanceRequest::getGroupId() const {
+  return groupId_;
+}
+
+void ListWorkflowInstanceRequest::setGroupId(const std::string &groupId) {
+  groupId_ = groupId;
+  setParameter(std::string("GroupId"), groupId);
+}
+
+std::string ListWorkflowInstanceRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ListWorkflowInstanceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string ListWorkflowInstanceRequest::get_Namespace() const {
+  return _namespace_;
+}
+
+void ListWorkflowInstanceRequest::set_Namespace(const std::string &_namespace) {
+  _namespace_ = _namespace;
+  setParameter(std::string("Namespace"), _namespace);
+}
+
+std::string ListWorkflowInstanceRequest::getWorkflowId() const {
+  return workflowId_;
+}
+
+void ListWorkflowInstanceRequest::setWorkflowId(const std::string &workflowId) {
+  workflowId_ = workflowId;
+  setParameter(std::string("WorkflowId"), workflowId);
+}
+

schedulerx2/src/model/ListWorkflowInstanceResult.cc

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/schedulerx2/model/ListWorkflowInstanceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Schedulerx2;
+using namespace AlibabaCloud::Schedulerx2::Model;
+
+ListWorkflowInstanceResult::ListWorkflowInstanceResult() :
+	ServiceResult()
+{}
+
+ListWorkflowInstanceResult::ListWorkflowInstanceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListWorkflowInstanceResult::~ListWorkflowInstanceResult()
+{}
+
+void ListWorkflowInstanceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto allWfInstanceInfosNode = dataNode["WfInstanceInfos"]["WfInstanceInfosItem"];
+	for (auto dataNodeWfInstanceInfosWfInstanceInfosItem : allWfInstanceInfosNode)
+	{
+		Data::WfInstanceInfosItem wfInstanceInfosItemObject;
+		if(!dataNodeWfInstanceInfosWfInstanceInfosItem["WfInstanceId"].isNull())
+			wfInstanceInfosItemObject.wfInstanceId = std::stol(dataNodeWfInstanceInfosWfInstanceInfosItem["WfInstanceId"].asString());
+		if(!dataNodeWfInstanceInfosWfInstanceInfosItem["WorkflowId"].isNull())
+			wfInstanceInfosItemObject.workflowId = std::stol(dataNodeWfInstanceInfosWfInstanceInfosItem["WorkflowId"].asString());
+		if(!dataNodeWfInstanceInfosWfInstanceInfosItem["Status"].isNull())
+			wfInstanceInfosItemObject.status = std::stoi(dataNodeWfInstanceInfosWfInstanceInfosItem["Status"].asString());
+		if(!dataNodeWfInstanceInfosWfInstanceInfosItem["StartTime"].isNull())
+			wfInstanceInfosItemObject.startTime = dataNodeWfInstanceInfosWfInstanceInfosItem["StartTime"].asString();
+		if(!dataNodeWfInstanceInfosWfInstanceInfosItem["EndTime"].isNull())
+			wfInstanceInfosItemObject.endTime = dataNodeWfInstanceInfosWfInstanceInfosItem["EndTime"].asString();
+		if(!dataNodeWfInstanceInfosWfInstanceInfosItem["ScheduleTime"].isNull())
+			wfInstanceInfosItemObject.scheduleTime = dataNodeWfInstanceInfosWfInstanceInfosItem["ScheduleTime"].asString();
+		if(!dataNodeWfInstanceInfosWfInstanceInfosItem["DataTime"].isNull())
+			wfInstanceInfosItemObject.dataTime = dataNodeWfInstanceInfosWfInstanceInfosItem["DataTime"].asString();
+		data_.wfInstanceInfos.push_back(wfInstanceInfosItemObject);
+	}
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string ListWorkflowInstanceResult::getMessage()const
+{
+	return message_;
+}
+
+ListWorkflowInstanceResult::Data ListWorkflowInstanceResult::getData()const
+{
+	return data_;
+}
+
+int ListWorkflowInstanceResult::getCode()const
+{
+	return code_;
+}
+
+bool ListWorkflowInstanceResult::getSuccess()const
+{
+	return success_;
+}
+

schedulerx2/src/model/RerunJobRequest.cc

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/schedulerx2/model/RerunJobRequest.h>
+
+using AlibabaCloud::Schedulerx2::Model::RerunJobRequest;
+
+RerunJobRequest::RerunJobRequest()
+    : RpcServiceRequest("schedulerx2", "2019-04-30", "RerunJob") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+RerunJobRequest::~RerunJobRequest() {}
+
+std::string RerunJobRequest::getNamespaceSource() const {
+  return namespaceSource_;
+}
+
+void RerunJobRequest::setNamespaceSource(const std::string &namespaceSource) {
+  namespaceSource_ = namespaceSource;
+  setBodyParameter(std::string("NamespaceSource"), namespaceSource);
+}
+
+std::string RerunJobRequest::getDataTime() const {
+  return dataTime_;
+}
+
+void RerunJobRequest::setDataTime(const std::string &dataTime) {
+  dataTime_ = dataTime;
+  setBodyParameter(std::string("DataTime"), dataTime);
+}
+
+std::string RerunJobRequest::getGroupId() const {
+  return groupId_;
+}
+
+void RerunJobRequest::setGroupId(const std::string &groupId) {
+  groupId_ = groupId;
+  setBodyParameter(std::string("GroupId"), groupId);
+}
+
+long RerunJobRequest::getStartDate() const {
+  return startDate_;
+}
+
+void RerunJobRequest::setStartDate(long startDate) {
+  startDate_ = startDate;
+  setBodyParameter(std::string("StartDate"), std::to_string(startDate));
+}
+
+long RerunJobRequest::getJobId() const {
+  return jobId_;
+}
+
+void RerunJobRequest::setJobId(long jobId) {
+  jobId_ = jobId;
+  setBodyParameter(std::string("JobId"), std::to_string(jobId));
+}
+
+long RerunJobRequest::getEndDate() const {
+  return endDate_;
+}
+
+void RerunJobRequest::setEndDate(long endDate) {
+  endDate_ = endDate;
+  setBodyParameter(std::string("EndDate"), std::to_string(endDate));
+}
+
+std::string RerunJobRequest::getRegionId() const {
+  return regionId_;
+}
+
+void RerunJobRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setBodyParameter(std::string("RegionId"), regionId);
+}
+
+std::string RerunJobRequest::get_Namespace() const {
+  return _namespace_;
+}
+
+void RerunJobRequest::set_Namespace(const std::string &_namespace) {
+  _namespace_ = _namespace;
+  setBodyParameter(std::string("Namespace"), _namespace);
+}
+

schedulerx2/src/model/RerunJobResult.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/schedulerx2/model/RerunJobResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Schedulerx2;
+using namespace AlibabaCloud::Schedulerx2::Model;
+
+RerunJobResult::RerunJobResult() :
+	ServiceResult()
+{}
+
+RerunJobResult::RerunJobResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+RerunJobResult::~RerunJobResult()
+{}
+
+void RerunJobResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string RerunJobResult::getMessage()const
+{
+	return message_;
+}
+
+int RerunJobResult::getCode()const
+{
+	return code_;
+}
+
+bool RerunJobResult::getSuccess()const
+{
+	return success_;
+}
+

schedulerx2/src/model/RetryJobInstanceRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/schedulerx2/model/RetryJobInstanceRequest.h>
+
+using AlibabaCloud::Schedulerx2::Model::RetryJobInstanceRequest;
+
+RetryJobInstanceRequest::RetryJobInstanceRequest()
+    : RpcServiceRequest("schedulerx2", "2019-04-30", "RetryJobInstance") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+RetryJobInstanceRequest::~RetryJobInstanceRequest() {}
+
+std::string RetryJobInstanceRequest::getNamespaceSource() const {
+  return namespaceSource_;
+}
+
+void RetryJobInstanceRequest::setNamespaceSource(const std::string &namespaceSource) {
+  namespaceSource_ = namespaceSource;
+  setParameter(std::string("NamespaceSource"), namespaceSource);
+}
+
+std::string RetryJobInstanceRequest::getGroupId() const {
+  return groupId_;
+}
+
+void RetryJobInstanceRequest::setGroupId(const std::string &groupId) {
+  groupId_ = groupId;
+  setParameter(std::string("GroupId"), groupId);
+}
+
+long RetryJobInstanceRequest::getJobId() const {
+  return jobId_;
+}
+
+void RetryJobInstanceRequest::setJobId(long jobId) {
+  jobId_ = jobId;
+  setParameter(std::string("JobId"), std::to_string(jobId));
+}
+
+std::string RetryJobInstanceRequest::getRegionId() const {
+  return regionId_;
+}
+
+void RetryJobInstanceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string RetryJobInstanceRequest::get_Namespace() const {
+  return _namespace_;
+}
+
+void RetryJobInstanceRequest::set_Namespace(const std::string &_namespace) {
+  _namespace_ = _namespace;
+  setParameter(std::string("Namespace"), _namespace);
+}
+
+long RetryJobInstanceRequest::getJobInstanceId() const {
+  return jobInstanceId_;
+}
+
+void RetryJobInstanceRequest::setJobInstanceId(long jobInstanceId) {
+  jobInstanceId_ = jobInstanceId;
+  setParameter(std::string("JobInstanceId"), std::to_string(jobInstanceId));
+}
+

schedulerx2/src/model/RetryJobInstanceResult.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/schedulerx2/model/RetryJobInstanceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Schedulerx2;
+using namespace AlibabaCloud::Schedulerx2::Model;
+
+RetryJobInstanceResult::RetryJobInstanceResult() :
+	ServiceResult()
+{}
+
+RetryJobInstanceResult::RetryJobInstanceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+RetryJobInstanceResult::~RetryJobInstanceResult()
+{}
+
+void RetryJobInstanceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string RetryJobInstanceResult::getMessage()const
+{
+	return message_;
+}
+
+int RetryJobInstanceResult::getCode()const
+{
+	return code_;
+}
+
+bool RetryJobInstanceResult::getSuccess()const
+{
+	return success_;
+}
+

schedulerx2/src/model/SetJobInstanceSuccessRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/schedulerx2/model/SetJobInstanceSuccessRequest.h>
+
+using AlibabaCloud::Schedulerx2::Model::SetJobInstanceSuccessRequest;
+
+SetJobInstanceSuccessRequest::SetJobInstanceSuccessRequest()
+    : RpcServiceRequest("schedulerx2", "2019-04-30", "SetJobInstanceSuccess") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+SetJobInstanceSuccessRequest::~SetJobInstanceSuccessRequest() {}
+
+std::string SetJobInstanceSuccessRequest::getNamespaceSource() const {
+  return namespaceSource_;
+}
+
+void SetJobInstanceSuccessRequest::setNamespaceSource(const std::string &namespaceSource) {
+  namespaceSource_ = namespaceSource;
+  setParameter(std::string("NamespaceSource"), namespaceSource);
+}
+
+std::string SetJobInstanceSuccessRequest::getGroupId() const {
+  return groupId_;
+}
+
+void SetJobInstanceSuccessRequest::setGroupId(const std::string &groupId) {
+  groupId_ = groupId;
+  setParameter(std::string("GroupId"), groupId);
+}
+
+long SetJobInstanceSuccessRequest::getJobId() const {
+  return jobId_;
+}
+
+void SetJobInstanceSuccessRequest::setJobId(long jobId) {
+  jobId_ = jobId;
+  setParameter(std::string("JobId"), std::to_string(jobId));
+}
+
+std::string SetJobInstanceSuccessRequest::getRegionId() const {
+  return regionId_;
+}
+
+void SetJobInstanceSuccessRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string SetJobInstanceSuccessRequest::get_Namespace() const {
+  return _namespace_;
+}
+
+void SetJobInstanceSuccessRequest::set_Namespace(const std::string &_namespace) {
+  _namespace_ = _namespace;
+  setParameter(std::string("Namespace"), _namespace);
+}
+
+long SetJobInstanceSuccessRequest::getJobInstanceId() const {
+  return jobInstanceId_;
+}
+
+void SetJobInstanceSuccessRequest::setJobInstanceId(long jobInstanceId) {
+  jobInstanceId_ = jobInstanceId;
+  setParameter(std::string("JobInstanceId"), std::to_string(jobInstanceId));
+}
+

schedulerx2/src/model/SetJobInstanceSuccessResult.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/schedulerx2/model/SetJobInstanceSuccessResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Schedulerx2;
+using namespace AlibabaCloud::Schedulerx2::Model;
+
+SetJobInstanceSuccessResult::SetJobInstanceSuccessResult() :
+	ServiceResult()
+{}
+
+SetJobInstanceSuccessResult::SetJobInstanceSuccessResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SetJobInstanceSuccessResult::~SetJobInstanceSuccessResult()
+{}
+
+void SetJobInstanceSuccessResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string SetJobInstanceSuccessResult::getMessage()const
+{
+	return message_;
+}
+
+int SetJobInstanceSuccessResult::getCode()const
+{
+	return code_;
+}
+
+bool SetJobInstanceSuccessResult::getSuccess()const
+{
+	return success_;
+}
+

schedulerx2/src/model/SetWfInstanceSuccessRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/schedulerx2/model/SetWfInstanceSuccessRequest.h>
+
+using AlibabaCloud::Schedulerx2::Model::SetWfInstanceSuccessRequest;
+
+SetWfInstanceSuccessRequest::SetWfInstanceSuccessRequest()
+    : RpcServiceRequest("schedulerx2", "2019-04-30", "SetWfInstanceSuccess") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+SetWfInstanceSuccessRequest::~SetWfInstanceSuccessRequest() {}
+
+std::string SetWfInstanceSuccessRequest::getNamespaceSource() const {
+  return namespaceSource_;
+}
+
+void SetWfInstanceSuccessRequest::setNamespaceSource(const std::string &namespaceSource) {
+  namespaceSource_ = namespaceSource;
+  setParameter(std::string("NamespaceSource"), namespaceSource);
+}
+
+std::string SetWfInstanceSuccessRequest::getGroupId() const {
+  return groupId_;
+}
+
+void SetWfInstanceSuccessRequest::setGroupId(const std::string &groupId) {
+  groupId_ = groupId;
+  setParameter(std::string("GroupId"), groupId);
+}
+
+long SetWfInstanceSuccessRequest::getWfInstanceId() const {
+  return wfInstanceId_;
+}
+
+void SetWfInstanceSuccessRequest::setWfInstanceId(long wfInstanceId) {
+  wfInstanceId_ = wfInstanceId;
+  setParameter(std::string("WfInstanceId"), std::to_string(wfInstanceId));
+}
+
+std::string SetWfInstanceSuccessRequest::getRegionId() const {
+  return regionId_;
+}
+
+void SetWfInstanceSuccessRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string SetWfInstanceSuccessRequest::get_Namespace() const {
+  return _namespace_;
+}
+
+void SetWfInstanceSuccessRequest::set_Namespace(const std::string &_namespace) {
+  _namespace_ = _namespace;
+  setParameter(std::string("Namespace"), _namespace);
+}
+
+long SetWfInstanceSuccessRequest::getWorkflowId() const {
+  return workflowId_;
+}
+
+void SetWfInstanceSuccessRequest::setWorkflowId(long workflowId) {
+  workflowId_ = workflowId;
+  setParameter(std::string("WorkflowId"), std::to_string(workflowId));
+}
+

schedulerx2/src/model/SetWfInstanceSuccessResult.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/schedulerx2/model/SetWfInstanceSuccessResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Schedulerx2;
+using namespace AlibabaCloud::Schedulerx2::Model;
+
+SetWfInstanceSuccessResult::SetWfInstanceSuccessResult() :
+	ServiceResult()
+{}
+
+SetWfInstanceSuccessResult::SetWfInstanceSuccessResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SetWfInstanceSuccessResult::~SetWfInstanceSuccessResult()
+{}
+
+void SetWfInstanceSuccessResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string SetWfInstanceSuccessResult::getMessage()const
+{
+	return message_;
+}
+
+int SetWfInstanceSuccessResult::getCode()const
+{
+	return code_;
+}
+
+bool SetWfInstanceSuccessResult::getSuccess()const
+{
+	return success_;
+}
+

schedulerx2/src/model/UpdateJobRequest.cc

@@ -25,24 +25,6 @@ UpdateJobRequest::UpdateJobRequest()
 
 UpdateJobRequest::~UpdateJobRequest() {}
 
-std::string UpdateJobRequest::getNamespaceSource() const {
-  return namespaceSource_;
-}
-
-void UpdateJobRequest::setNamespaceSource(const std::string &namespaceSource) {
-  namespaceSource_ = namespaceSource;
-  setBodyParameter(std::string("NamespaceSource"), namespaceSource);
-}
-
-std::string UpdateJobRequest::getDescription() const {
-  return description_;
-}
-
-void UpdateJobRequest::setDescription(const std::string &description) {
-  description_ = description;
-  setBodyParameter(std::string("Description"), description);
-}
-
 int UpdateJobRequest::getAttemptInterval() const {
   return attemptInterval_;
 }
@@ -52,31 +34,13 @@ void UpdateJobRequest::setAttemptInterval(int attemptInterval) {
   setBodyParameter(std::string("AttemptInterval"), std::to_string(attemptInterval));
 }
 
-std::string UpdateJobRequest::getContent() const {
-  return content_;
-}
-
-void UpdateJobRequest::setContent(const std::string &content) {
-  content_ = content;
-  setBodyParameter(std::string("Content"), content);
+int UpdateJobRequest::getFailTimes() const {
+  return failTimes_;
 }
 
-long UpdateJobRequest::getTimeout() const {
-  return timeout_;
-}
-
-void UpdateJobRequest::setTimeout(long timeout) {
-  timeout_ = timeout;
-  setBodyParameter(std::string("Timeout"), std::to_string(timeout));
-}
-
-bool UpdateJobRequest::getTimeoutKillEnable() const {
-  return timeoutKillEnable_;
-}
-
-void UpdateJobRequest::setTimeoutKillEnable(bool timeoutKillEnable) {
-  timeoutKillEnable_ = timeoutKillEnable;
-  setBodyParameter(std::string("TimeoutKillEnable"), timeoutKillEnable ? "true" : "false");
+void UpdateJobRequest::setFailTimes(int failTimes) {
+  failTimes_ = failTimes;
+  setBodyParameter(std::string("FailTimes"), std::to_string(failTimes));
 }
 
 long UpdateJobRequest::getJobId() const {
@@ -88,24 +52,6 @@ void UpdateJobRequest::setJobId(long jobId) {
   setBodyParameter(std::string("JobId"), std::to_string(jobId));
 }
 
-std::string UpdateJobRequest::getRegionId() const {
-  return regionId_;
-}
-
-void UpdateJobRequest::setRegionId(const std::string &regionId) {
-  regionId_ = regionId;
-  setParameter(std::string("RegionId"), regionId);
-}
-
-int UpdateJobRequest::getPageSize() const {
-  return pageSize_;
-}
-
-void UpdateJobRequest::setPageSize(int pageSize) {
-  pageSize_ = pageSize;
-  setBodyParameter(std::string("PageSize"), std::to_string(pageSize));
-}
-
 int UpdateJobRequest::getConsumerSize() const {
   return consumerSize_;
 }
@@ -124,42 +70,6 @@ void UpdateJobRequest::setJarUrl(const std::string &jarUrl) {
   setBodyParameter(std::string("JarUrl"), jarUrl);
 }
 
-std::string UpdateJobRequest::getCalendar() const {
-  return calendar_;
-}
-
-void UpdateJobRequest::setCalendar(const std::string &calendar) {
-  calendar_ = calendar;
-  setBodyParameter(std::string("Calendar"), calendar);
-}
-
-bool UpdateJobRequest::getFailEnable() const {
-  return failEnable_;
-}
-
-void UpdateJobRequest::setFailEnable(bool failEnable) {
-  failEnable_ = failEnable;
-  setBodyParameter(std::string("FailEnable"), failEnable ? "true" : "false");
-}
-
-std::string UpdateJobRequest::getSendChannel() const {
-  return sendChannel_;
-}
-
-void UpdateJobRequest::setSendChannel(const std::string &sendChannel) {
-  sendChannel_ = sendChannel;
-  setBodyParameter(std::string("SendChannel"), sendChannel);
-}
-
-int UpdateJobRequest::getDataOffset() const {
-  return dataOffset_;
-}
-
-void UpdateJobRequest::setDataOffset(int dataOffset) {
-  dataOffset_ = dataOffset;
-  setBodyParameter(std::string("DataOffset"), std::to_string(dataOffset));
-}
-
 std::string UpdateJobRequest::getGroupId() const {
   return groupId_;
 }
@@ -178,22 +88,13 @@ void UpdateJobRequest::setTaskMaxAttempt(int taskMaxAttempt) {
   setBodyParameter(std::string("TaskMaxAttempt"), std::to_string(taskMaxAttempt));
 }
 
-int UpdateJobRequest::getMaxAttempt() const {
-  return maxAttempt_;
-}
-
-void UpdateJobRequest::setMaxAttempt(int maxAttempt) {
-  maxAttempt_ = maxAttempt;
-  setBodyParameter(std::string("MaxAttempt"), std::to_string(maxAttempt));
-}
-
-bool UpdateJobRequest::getMissWorkerEnable() const {
-  return missWorkerEnable_;
+int UpdateJobRequest::getDataOffset() const {
+  return dataOffset_;
 }
 
-void UpdateJobRequest::setMissWorkerEnable(bool missWorkerEnable) {
-  missWorkerEnable_ = missWorkerEnable;
-  setBodyParameter(std::string("MissWorkerEnable"), missWorkerEnable ? "true" : "false");
+void UpdateJobRequest::setDataOffset(int dataOffset) {
+  dataOffset_ = dataOffset;
+  setBodyParameter(std::string("DataOffset"), std::to_string(dataOffset));
 }
 
 int UpdateJobRequest::getDispatcherSize() const {
@@ -223,15 +124,6 @@ void UpdateJobRequest::setExecuteMode(const std::string &executeMode) {
   setBodyParameter(std::string("ExecuteMode"), executeMode);
 }
 
-int UpdateJobRequest::getQueueSize() const {
-  return queueSize_;
-}
-
-void UpdateJobRequest::setQueueSize(int queueSize) {
-  queueSize_ = queueSize;
-  setBodyParameter(std::string("QueueSize"), std::to_string(queueSize));
-}
-
 std::string UpdateJobRequest::getTimeExpression() const {
   return timeExpression_;
 }
@@ -241,15 +133,6 @@ void UpdateJobRequest::setTimeExpression(const std::string &timeExpression) {
   setBodyParameter(std::string("TimeExpression"), timeExpression);
 }
 
-std::string UpdateJobRequest::getClassName() const {
-  return className_;
-}
-
-void UpdateJobRequest::setClassName(const std::string &className) {
-  className_ = className;
-  setBodyParameter(std::string("ClassName"), className);
-}
-
 bool UpdateJobRequest::getTimeoutEnable() const {
   return timeoutEnable_;
 }
@@ -284,24 +167,6 @@ void UpdateJobRequest::setName(const std::string &name) {
   setBodyParameter(std::string("Name"), name);
 }
 
-std::string UpdateJobRequest::get_Namespace() const {
-  return _namespace_;
-}
-
-void UpdateJobRequest::set_Namespace(const std::string &_namespace) {
-  _namespace_ = _namespace;
-  setBodyParameter(std::string("Namespace"), _namespace);
-}
-
-int UpdateJobRequest::getMaxConcurrency() const {
-  return maxConcurrency_;
-}
-
-void UpdateJobRequest::setMaxConcurrency(int maxConcurrency) {
-  maxConcurrency_ = maxConcurrency;
-  setBodyParameter(std::string("MaxConcurrency"), std::to_string(maxConcurrency));
-}
-
 int UpdateJobRequest::getTimeType() const {
   return timeType_;
 }
@@ -320,3 +185,156 @@ void UpdateJobRequest::setParameters(const std::string &parameters) {
   setBodyParameter(std::string("Parameters"), parameters);
 }
 
+std::string UpdateJobRequest::getNamespaceSource() const {
+  return namespaceSource_;
+}
+
+void UpdateJobRequest::setNamespaceSource(const std::string &namespaceSource) {
+  namespaceSource_ = namespaceSource;
+  setBodyParameter(std::string("NamespaceSource"), namespaceSource);
+}
+
+std::string UpdateJobRequest::getDescription() const {
+  return description_;
+}
+
+void UpdateJobRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setBodyParameter(std::string("Description"), description);
+}
+
+std::string UpdateJobRequest::getContent() const {
+  return content_;
+}
+
+void UpdateJobRequest::setContent(const std::string &content) {
+  content_ = content;
+  setBodyParameter(std::string("Content"), content);
+}
+
+long UpdateJobRequest::getTimeout() const {
+  return timeout_;
+}
+
+void UpdateJobRequest::setTimeout(long timeout) {
+  timeout_ = timeout;
+  setBodyParameter(std::string("Timeout"), std::to_string(timeout));
+}
+
+bool UpdateJobRequest::getTimeoutKillEnable() const {
+  return timeoutKillEnable_;
+}
+
+void UpdateJobRequest::setTimeoutKillEnable(bool timeoutKillEnable) {
+  timeoutKillEnable_ = timeoutKillEnable;
+  setBodyParameter(std::string("TimeoutKillEnable"), timeoutKillEnable ? "true" : "false");
+}
+
+std::string UpdateJobRequest::getRegionId() const {
+  return regionId_;
+}
+
+void UpdateJobRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+int UpdateJobRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void UpdateJobRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setBodyParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string UpdateJobRequest::getCalendar() const {
+  return calendar_;
+}
+
+void UpdateJobRequest::setCalendar(const std::string &calendar) {
+  calendar_ = calendar;
+  setBodyParameter(std::string("Calendar"), calendar);
+}
+
+bool UpdateJobRequest::getFailEnable() const {
+  return failEnable_;
+}
+
+void UpdateJobRequest::setFailEnable(bool failEnable) {
+  failEnable_ = failEnable;
+  setBodyParameter(std::string("FailEnable"), failEnable ? "true" : "false");
+}
+
+std::string UpdateJobRequest::getSendChannel() const {
+  return sendChannel_;
+}
+
+void UpdateJobRequest::setSendChannel(const std::string &sendChannel) {
+  sendChannel_ = sendChannel;
+  setBodyParameter(std::string("SendChannel"), sendChannel);
+}
+
+int UpdateJobRequest::getMaxAttempt() const {
+  return maxAttempt_;
+}
+
+void UpdateJobRequest::setMaxAttempt(int maxAttempt) {
+  maxAttempt_ = maxAttempt;
+  setBodyParameter(std::string("MaxAttempt"), std::to_string(maxAttempt));
+}
+
+bool UpdateJobRequest::getMissWorkerEnable() const {
+  return missWorkerEnable_;
+}
+
+void UpdateJobRequest::setMissWorkerEnable(bool missWorkerEnable) {
+  missWorkerEnable_ = missWorkerEnable;
+  setBodyParameter(std::string("MissWorkerEnable"), missWorkerEnable ? "true" : "false");
+}
+
+bool UpdateJobRequest::getSuccessNoticeEnable() const {
+  return successNoticeEnable_;
+}
+
+void UpdateJobRequest::setSuccessNoticeEnable(bool successNoticeEnable) {
+  successNoticeEnable_ = successNoticeEnable;
+  setBodyParameter(std::string("SuccessNoticeEnable"), successNoticeEnable ? "true" : "false");
+}
+
+int UpdateJobRequest::getQueueSize() const {
+  return queueSize_;
+}
+
+void UpdateJobRequest::setQueueSize(int queueSize) {
+  queueSize_ = queueSize;
+  setBodyParameter(std::string("QueueSize"), std::to_string(queueSize));
+}
+
+std::string UpdateJobRequest::getClassName() const {
+  return className_;
+}
+
+void UpdateJobRequest::setClassName(const std::string &className) {
+  className_ = className;
+  setBodyParameter(std::string("ClassName"), className);
+}
+
+std::string UpdateJobRequest::get_Namespace() const {
+  return _namespace_;
+}
+
+void UpdateJobRequest::set_Namespace(const std::string &_namespace) {
+  _namespace_ = _namespace;
+  setBodyParameter(std::string("Namespace"), _namespace);
+}
+
+int UpdateJobRequest::getMaxConcurrency() const {
+  return maxConcurrency_;
+}
+
+void UpdateJobRequest::setMaxConcurrency(int maxConcurrency) {
+  maxConcurrency_ = maxConcurrency;
+  setBodyParameter(std::string("MaxConcurrency"), std::to_string(maxConcurrency));
+}
+

schedulerx2/src/model/UpdateWorkflowDagRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/schedulerx2/model/UpdateWorkflowDagRequest.h>
+
+using AlibabaCloud::Schedulerx2::Model::UpdateWorkflowDagRequest;
+
+UpdateWorkflowDagRequest::UpdateWorkflowDagRequest()
+    : RpcServiceRequest("schedulerx2", "2019-04-30", "UpdateWorkflowDag") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateWorkflowDagRequest::~UpdateWorkflowDagRequest() {}
+
+std::string UpdateWorkflowDagRequest::getDagJson() const {
+  return dagJson_;
+}
+
+void UpdateWorkflowDagRequest::setDagJson(const std::string &dagJson) {
+  dagJson_ = dagJson;
+  setBodyParameter(std::string("DagJson"), dagJson);
+}
+
+std::string UpdateWorkflowDagRequest::getNamespaceSource() const {
+  return namespaceSource_;
+}
+
+void UpdateWorkflowDagRequest::setNamespaceSource(const std::string &namespaceSource) {
+  namespaceSource_ = namespaceSource;
+  setBodyParameter(std::string("NamespaceSource"), namespaceSource);
+}
+
+std::string UpdateWorkflowDagRequest::getGroupId() const {
+  return groupId_;
+}
+
+void UpdateWorkflowDagRequest::setGroupId(const std::string &groupId) {
+  groupId_ = groupId;
+  setBodyParameter(std::string("GroupId"), groupId);
+}
+
+std::string UpdateWorkflowDagRequest::getRegionId() const {
+  return regionId_;
+}
+
+void UpdateWorkflowDagRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string UpdateWorkflowDagRequest::get_Namespace() const {
+  return _namespace_;
+}
+
+void UpdateWorkflowDagRequest::set_Namespace(const std::string &_namespace) {
+  _namespace_ = _namespace;
+  setBodyParameter(std::string("Namespace"), _namespace);
+}
+
+std::string UpdateWorkflowDagRequest::getWorkflowId() const {
+  return workflowId_;
+}
+
+void UpdateWorkflowDagRequest::setWorkflowId(const std::string &workflowId) {
+  workflowId_ = workflowId;
+  setBodyParameter(std::string("WorkflowId"), workflowId);
+}
+

schedulerx2/src/model/UpdateWorkflowDagResult.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/schedulerx2/model/UpdateWorkflowDagResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Schedulerx2;
+using namespace AlibabaCloud::Schedulerx2::Model;
+
+UpdateWorkflowDagResult::UpdateWorkflowDagResult() :
+	ServiceResult()
+{}
+
+UpdateWorkflowDagResult::UpdateWorkflowDagResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateWorkflowDagResult::~UpdateWorkflowDagResult()
+{}
+
+void UpdateWorkflowDagResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string UpdateWorkflowDagResult::getMessage()const
+{
+	return message_;
+}
+
+int UpdateWorkflowDagResult::getCode()const
+{
+	return code_;
+}
+
+bool UpdateWorkflowDagResult::getSuccess()const
+{
+	return success_;
+}
+

schedulerx2/src/model/UpdateWorkflowRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/schedulerx2/model/UpdateWorkflowRequest.h>
+
+using AlibabaCloud::Schedulerx2::Model::UpdateWorkflowRequest;
+
+UpdateWorkflowRequest::UpdateWorkflowRequest()
+    : RpcServiceRequest("schedulerx2", "2019-04-30", "UpdateWorkflow") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateWorkflowRequest::~UpdateWorkflowRequest() {}
+
+std::string UpdateWorkflowRequest::getNamespaceSource() const {
+  return namespaceSource_;
+}
+
+void UpdateWorkflowRequest::setNamespaceSource(const std::string &namespaceSource) {
+  namespaceSource_ = namespaceSource;
+  setBodyParameter(std::string("NamespaceSource"), namespaceSource);
+}
+
+std::string UpdateWorkflowRequest::getDescription() const {
+  return description_;
+}
+
+void UpdateWorkflowRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setBodyParameter(std::string("Description"), description);
+}
+
+std::string UpdateWorkflowRequest::getRegionId() const {
+  return regionId_;
+}
+
+void UpdateWorkflowRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string UpdateWorkflowRequest::getWorkflowId() const {
+  return workflowId_;
+}
+
+void UpdateWorkflowRequest::setWorkflowId(const std::string &workflowId) {
+  workflowId_ = workflowId;
+  setBodyParameter(std::string("WorkflowId"), workflowId);
+}
+
+std::string UpdateWorkflowRequest::getGroupId() const {
+  return groupId_;
+}
+
+void UpdateWorkflowRequest::setGroupId(const std::string &groupId) {
+  groupId_ = groupId;
+  setBodyParameter(std::string("GroupId"), groupId);
+}
+
+std::string UpdateWorkflowRequest::getTimeExpression() const {
+  return timeExpression_;
+}
+
+void UpdateWorkflowRequest::setTimeExpression(const std::string &timeExpression) {
+  timeExpression_ = timeExpression;
+  setBodyParameter(std::string("TimeExpression"), timeExpression);
+}
+
+std::string UpdateWorkflowRequest::get_Namespace() const {
+  return _namespace_;
+}
+
+void UpdateWorkflowRequest::set_Namespace(const std::string &_namespace) {
+  _namespace_ = _namespace;
+  setBodyParameter(std::string("Namespace"), _namespace);
+}
+
+std::string UpdateWorkflowRequest::getName() const {
+  return name_;
+}
+
+void UpdateWorkflowRequest::setName(const std::string &name) {
+  name_ = name;
+  setBodyParameter(std::string("Name"), name);
+}
+
+int UpdateWorkflowRequest::getTimeType() const {
+  return timeType_;
+}
+
+void UpdateWorkflowRequest::setTimeType(int timeType) {
+  timeType_ = timeType;
+  setBodyParameter(std::string("TimeType"), std::to_string(timeType));
+}
+

schedulerx2/src/model/UpdateWorkflowResult.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/schedulerx2/model/UpdateWorkflowResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Schedulerx2;
+using namespace AlibabaCloud::Schedulerx2::Model;
+
+UpdateWorkflowResult::UpdateWorkflowResult() :
+	ServiceResult()
+{}
+
+UpdateWorkflowResult::UpdateWorkflowResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateWorkflowResult::~UpdateWorkflowResult()
+{}
+
+void UpdateWorkflowResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string UpdateWorkflowResult::getMessage()const
+{
+	return message_;
+}
+
+int UpdateWorkflowResult::getCode()const
+{
+	return code_;
+}
+
+bool UpdateWorkflowResult::getSuccess()const
+{
+	return success_;
+}
+