Add some console API operations.

CHANGELOG

@@ -1,3 +1,6 @@
+2020-12-28 Version: patch
+- Add some console API operations.
+
 2020-12-25 Version: patch
 - Generated 2016-04-08 for `Emr`.
 

nlp-automl/CMakeLists.txt

@@ -21,12 +21,44 @@ set(nlp-automl_public_header
 	include/alibabacloud/nlp-automl/Nlp_automlExport.h )
 
 set(nlp-automl_public_header_model 
+	include/alibabacloud/nlp-automl/model/AddMTInterveneWordRequest.h
+	include/alibabacloud/nlp-automl/model/AddMTInterveneWordResult.h
+	include/alibabacloud/nlp-automl/model/AddMtIntervenePackageRequest.h
+	include/alibabacloud/nlp-automl/model/AddMtIntervenePackageResult.h
+	include/alibabacloud/nlp-automl/model/BindIntervenePackageAndModelRequest.h
+	include/alibabacloud/nlp-automl/model/BindIntervenePackageAndModelResult.h
 	include/alibabacloud/nlp-automl/model/CreateAsyncPredictRequest.h
 	include/alibabacloud/nlp-automl/model/CreateAsyncPredictResult.h
+	include/alibabacloud/nlp-automl/model/CreateDatasetRequest.h
+	include/alibabacloud/nlp-automl/model/CreateDatasetResult.h
+	include/alibabacloud/nlp-automl/model/CreateDatasetRecordRequest.h
+	include/alibabacloud/nlp-automl/model/CreateDatasetRecordResult.h
+	include/alibabacloud/nlp-automl/model/CreateModelRequest.h
+	include/alibabacloud/nlp-automl/model/CreateModelResult.h
+	include/alibabacloud/nlp-automl/model/CreateProjectRequest.h
+	include/alibabacloud/nlp-automl/model/CreateProjectResult.h
+	include/alibabacloud/nlp-automl/model/DeleteModelRequest.h
+	include/alibabacloud/nlp-automl/model/DeleteModelResult.h
+	include/alibabacloud/nlp-automl/model/DeployModelRequest.h
+	include/alibabacloud/nlp-automl/model/DeployModelResult.h
 	include/alibabacloud/nlp-automl/model/GetAsyncPredictRequest.h
 	include/alibabacloud/nlp-automl/model/GetAsyncPredictResult.h
+	include/alibabacloud/nlp-automl/model/GetModelRequest.h
+	include/alibabacloud/nlp-automl/model/GetModelResult.h
+	include/alibabacloud/nlp-automl/model/GetPredictDocRequest.h
+	include/alibabacloud/nlp-automl/model/GetPredictDocResult.h
 	include/alibabacloud/nlp-automl/model/GetPredictResultRequest.h
 	include/alibabacloud/nlp-automl/model/GetPredictResultResult.h
+	include/alibabacloud/nlp-automl/model/InvokeActionRequest.h
+	include/alibabacloud/nlp-automl/model/InvokeActionResult.h
+	include/alibabacloud/nlp-automl/model/ListDatasetRequest.h
+	include/alibabacloud/nlp-automl/model/ListDatasetResult.h
+	include/alibabacloud/nlp-automl/model/ListModelsRequest.h
+	include/alibabacloud/nlp-automl/model/ListModelsResult.h
+	include/alibabacloud/nlp-automl/model/PredictMTModelRequest.h
+	include/alibabacloud/nlp-automl/model/PredictMTModelResult.h
+	include/alibabacloud/nlp-automl/model/PredictMTModelByDocRequest.h
+	include/alibabacloud/nlp-automl/model/PredictMTModelByDocResult.h
 	include/alibabacloud/nlp-automl/model/RunContactReviewRequest.h
 	include/alibabacloud/nlp-automl/model/RunContactReviewResult.h
 	include/alibabacloud/nlp-automl/model/RunPreTrainServiceRequest.h
@@ -36,12 +68,44 @@ set(nlp-automl_public_header_model
 
 set(nlp-automl_src 
 	src/Nlp-automlClient.cc
+	src/model/AddMTInterveneWordRequest.cc
+	src/model/AddMTInterveneWordResult.cc
+	src/model/AddMtIntervenePackageRequest.cc
+	src/model/AddMtIntervenePackageResult.cc
+	src/model/BindIntervenePackageAndModelRequest.cc
+	src/model/BindIntervenePackageAndModelResult.cc
 	src/model/CreateAsyncPredictRequest.cc
 	src/model/CreateAsyncPredictResult.cc
+	src/model/CreateDatasetRequest.cc
+	src/model/CreateDatasetResult.cc
+	src/model/CreateDatasetRecordRequest.cc
+	src/model/CreateDatasetRecordResult.cc
+	src/model/CreateModelRequest.cc
+	src/model/CreateModelResult.cc
+	src/model/CreateProjectRequest.cc
+	src/model/CreateProjectResult.cc
+	src/model/DeleteModelRequest.cc
+	src/model/DeleteModelResult.cc
+	src/model/DeployModelRequest.cc
+	src/model/DeployModelResult.cc
 	src/model/GetAsyncPredictRequest.cc
 	src/model/GetAsyncPredictResult.cc
+	src/model/GetModelRequest.cc
+	src/model/GetModelResult.cc
+	src/model/GetPredictDocRequest.cc
+	src/model/GetPredictDocResult.cc
 	src/model/GetPredictResultRequest.cc
 	src/model/GetPredictResultResult.cc
+	src/model/InvokeActionRequest.cc
+	src/model/InvokeActionResult.cc
+	src/model/ListDatasetRequest.cc
+	src/model/ListDatasetResult.cc
+	src/model/ListModelsRequest.cc
+	src/model/ListModelsResult.cc
+	src/model/PredictMTModelRequest.cc
+	src/model/PredictMTModelResult.cc
+	src/model/PredictMTModelByDocRequest.cc
+	src/model/PredictMTModelByDocResult.cc
 	src/model/RunContactReviewRequest.cc
 	src/model/RunContactReviewResult.cc
 	src/model/RunPreTrainServiceRequest.cc

nlp-automl/include/alibabacloud/nlp-automl/Nlp_automlClient.h

@@ -22,12 +22,44 @@
 #include <alibabacloud/core/EndpointProvider.h>
 #include <alibabacloud/core/RpcServiceClient.h>
 #include "Nlp_automlExport.h"
+#include "model/AddMTInterveneWordRequest.h"
+#include "model/AddMTInterveneWordResult.h"
+#include "model/AddMtIntervenePackageRequest.h"
+#include "model/AddMtIntervenePackageResult.h"
+#include "model/BindIntervenePackageAndModelRequest.h"
+#include "model/BindIntervenePackageAndModelResult.h"
 #include "model/CreateAsyncPredictRequest.h"
 #include "model/CreateAsyncPredictResult.h"
+#include "model/CreateDatasetRequest.h"
+#include "model/CreateDatasetResult.h"
+#include "model/CreateDatasetRecordRequest.h"
+#include "model/CreateDatasetRecordResult.h"
+#include "model/CreateModelRequest.h"
+#include "model/CreateModelResult.h"
+#include "model/CreateProjectRequest.h"
+#include "model/CreateProjectResult.h"
+#include "model/DeleteModelRequest.h"
+#include "model/DeleteModelResult.h"
+#include "model/DeployModelRequest.h"
+#include "model/DeployModelResult.h"
 #include "model/GetAsyncPredictRequest.h"
 #include "model/GetAsyncPredictResult.h"
+#include "model/GetModelRequest.h"
+#include "model/GetModelResult.h"
+#include "model/GetPredictDocRequest.h"
+#include "model/GetPredictDocResult.h"
 #include "model/GetPredictResultRequest.h"
 #include "model/GetPredictResultResult.h"
+#include "model/InvokeActionRequest.h"
+#include "model/InvokeActionResult.h"
+#include "model/ListDatasetRequest.h"
+#include "model/ListDatasetResult.h"
+#include "model/ListModelsRequest.h"
+#include "model/ListModelsResult.h"
+#include "model/PredictMTModelRequest.h"
+#include "model/PredictMTModelResult.h"
+#include "model/PredictMTModelByDocRequest.h"
+#include "model/PredictMTModelByDocResult.h"
 #include "model/RunContactReviewRequest.h"
 #include "model/RunContactReviewResult.h"
 #include "model/RunPreTrainServiceRequest.h"
@@ -43,15 +75,63 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_NLP_AUTOML_EXPORT Nlp_automlClient : public RpcServiceClient
 		{
 		public:
+			typedef Outcome<Error, Model::AddMTInterveneWordResult> AddMTInterveneWordOutcome;
+			typedef std::future<AddMTInterveneWordOutcome> AddMTInterveneWordOutcomeCallable;
+			typedef std::function<void(const Nlp_automlClient*, const Model::AddMTInterveneWordRequest&, const AddMTInterveneWordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddMTInterveneWordAsyncHandler;
+			typedef Outcome<Error, Model::AddMtIntervenePackageResult> AddMtIntervenePackageOutcome;
+			typedef std::future<AddMtIntervenePackageOutcome> AddMtIntervenePackageOutcomeCallable;
+			typedef std::function<void(const Nlp_automlClient*, const Model::AddMtIntervenePackageRequest&, const AddMtIntervenePackageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddMtIntervenePackageAsyncHandler;
+			typedef Outcome<Error, Model::BindIntervenePackageAndModelResult> BindIntervenePackageAndModelOutcome;
+			typedef std::future<BindIntervenePackageAndModelOutcome> BindIntervenePackageAndModelOutcomeCallable;
+			typedef std::function<void(const Nlp_automlClient*, const Model::BindIntervenePackageAndModelRequest&, const BindIntervenePackageAndModelOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BindIntervenePackageAndModelAsyncHandler;
 			typedef Outcome<Error, Model::CreateAsyncPredictResult> CreateAsyncPredictOutcome;
 			typedef std::future<CreateAsyncPredictOutcome> CreateAsyncPredictOutcomeCallable;
 			typedef std::function<void(const Nlp_automlClient*, const Model::CreateAsyncPredictRequest&, const CreateAsyncPredictOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAsyncPredictAsyncHandler;
+			typedef Outcome<Error, Model::CreateDatasetResult> CreateDatasetOutcome;
+			typedef std::future<CreateDatasetOutcome> CreateDatasetOutcomeCallable;
+			typedef std::function<void(const Nlp_automlClient*, const Model::CreateDatasetRequest&, const CreateDatasetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDatasetAsyncHandler;
+			typedef Outcome<Error, Model::CreateDatasetRecordResult> CreateDatasetRecordOutcome;
+			typedef std::future<CreateDatasetRecordOutcome> CreateDatasetRecordOutcomeCallable;
+			typedef std::function<void(const Nlp_automlClient*, const Model::CreateDatasetRecordRequest&, const CreateDatasetRecordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDatasetRecordAsyncHandler;
+			typedef Outcome<Error, Model::CreateModelResult> CreateModelOutcome;
+			typedef std::future<CreateModelOutcome> CreateModelOutcomeCallable;
+			typedef std::function<void(const Nlp_automlClient*, const Model::CreateModelRequest&, const CreateModelOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateModelAsyncHandler;
+			typedef Outcome<Error, Model::CreateProjectResult> CreateProjectOutcome;
+			typedef std::future<CreateProjectOutcome> CreateProjectOutcomeCallable;
+			typedef std::function<void(const Nlp_automlClient*, const Model::CreateProjectRequest&, const CreateProjectOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateProjectAsyncHandler;
+			typedef Outcome<Error, Model::DeleteModelResult> DeleteModelOutcome;
+			typedef std::future<DeleteModelOutcome> DeleteModelOutcomeCallable;
+			typedef std::function<void(const Nlp_automlClient*, const Model::DeleteModelRequest&, const DeleteModelOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteModelAsyncHandler;
+			typedef Outcome<Error, Model::DeployModelResult> DeployModelOutcome;
+			typedef std::future<DeployModelOutcome> DeployModelOutcomeCallable;
+			typedef std::function<void(const Nlp_automlClient*, const Model::DeployModelRequest&, const DeployModelOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeployModelAsyncHandler;
 			typedef Outcome<Error, Model::GetAsyncPredictResult> GetAsyncPredictOutcome;
 			typedef std::future<GetAsyncPredictOutcome> GetAsyncPredictOutcomeCallable;
 			typedef std::function<void(const Nlp_automlClient*, const Model::GetAsyncPredictRequest&, const GetAsyncPredictOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAsyncPredictAsyncHandler;
+			typedef Outcome<Error, Model::GetModelResult> GetModelOutcome;
+			typedef std::future<GetModelOutcome> GetModelOutcomeCallable;
+			typedef std::function<void(const Nlp_automlClient*, const Model::GetModelRequest&, const GetModelOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetModelAsyncHandler;
+			typedef Outcome<Error, Model::GetPredictDocResult> GetPredictDocOutcome;
+			typedef std::future<GetPredictDocOutcome> GetPredictDocOutcomeCallable;
+			typedef std::function<void(const Nlp_automlClient*, const Model::GetPredictDocRequest&, const GetPredictDocOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPredictDocAsyncHandler;
 			typedef Outcome<Error, Model::GetPredictResultResult> GetPredictResultOutcome;
 			typedef std::future<GetPredictResultOutcome> GetPredictResultOutcomeCallable;
 			typedef std::function<void(const Nlp_automlClient*, const Model::GetPredictResultRequest&, const GetPredictResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPredictResultAsyncHandler;
+			typedef Outcome<Error, Model::InvokeActionResult> InvokeActionOutcome;
+			typedef std::future<InvokeActionOutcome> InvokeActionOutcomeCallable;
+			typedef std::function<void(const Nlp_automlClient*, const Model::InvokeActionRequest&, const InvokeActionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> InvokeActionAsyncHandler;
+			typedef Outcome<Error, Model::ListDatasetResult> ListDatasetOutcome;
+			typedef std::future<ListDatasetOutcome> ListDatasetOutcomeCallable;
+			typedef std::function<void(const Nlp_automlClient*, const Model::ListDatasetRequest&, const ListDatasetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDatasetAsyncHandler;
+			typedef Outcome<Error, Model::ListModelsResult> ListModelsOutcome;
+			typedef std::future<ListModelsOutcome> ListModelsOutcomeCallable;
+			typedef std::function<void(const Nlp_automlClient*, const Model::ListModelsRequest&, const ListModelsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListModelsAsyncHandler;
+			typedef Outcome<Error, Model::PredictMTModelResult> PredictMTModelOutcome;
+			typedef std::future<PredictMTModelOutcome> PredictMTModelOutcomeCallable;
+			typedef std::function<void(const Nlp_automlClient*, const Model::PredictMTModelRequest&, const PredictMTModelOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PredictMTModelAsyncHandler;
+			typedef Outcome<Error, Model::PredictMTModelByDocResult> PredictMTModelByDocOutcome;
+			typedef std::future<PredictMTModelByDocOutcome> PredictMTModelByDocOutcomeCallable;
+			typedef std::function<void(const Nlp_automlClient*, const Model::PredictMTModelByDocRequest&, const PredictMTModelByDocOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PredictMTModelByDocAsyncHandler;
 			typedef Outcome<Error, Model::RunContactReviewResult> RunContactReviewOutcome;
 			typedef std::future<RunContactReviewOutcome> RunContactReviewOutcomeCallable;
 			typedef std::function<void(const Nlp_automlClient*, const Model::RunContactReviewRequest&, const RunContactReviewOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RunContactReviewAsyncHandler;
@@ -66,15 +146,63 @@ namespace AlibabaCloud
 			Nlp_automlClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
 			Nlp_automlClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
 			~Nlp_automlClient();
+			AddMTInterveneWordOutcome addMTInterveneWord(const Model::AddMTInterveneWordRequest &request)const;
+			void addMTInterveneWordAsync(const Model::AddMTInterveneWordRequest& request, const AddMTInterveneWordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddMTInterveneWordOutcomeCallable addMTInterveneWordCallable(const Model::AddMTInterveneWordRequest& request) const;
+			AddMtIntervenePackageOutcome addMtIntervenePackage(const Model::AddMtIntervenePackageRequest &request)const;
+			void addMtIntervenePackageAsync(const Model::AddMtIntervenePackageRequest& request, const AddMtIntervenePackageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddMtIntervenePackageOutcomeCallable addMtIntervenePackageCallable(const Model::AddMtIntervenePackageRequest& request) const;
+			BindIntervenePackageAndModelOutcome bindIntervenePackageAndModel(const Model::BindIntervenePackageAndModelRequest &request)const;
+			void bindIntervenePackageAndModelAsync(const Model::BindIntervenePackageAndModelRequest& request, const BindIntervenePackageAndModelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			BindIntervenePackageAndModelOutcomeCallable bindIntervenePackageAndModelCallable(const Model::BindIntervenePackageAndModelRequest& request) const;
 			CreateAsyncPredictOutcome createAsyncPredict(const Model::CreateAsyncPredictRequest &request)const;
 			void createAsyncPredictAsync(const Model::CreateAsyncPredictRequest& request, const CreateAsyncPredictAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateAsyncPredictOutcomeCallable createAsyncPredictCallable(const Model::CreateAsyncPredictRequest& request) const;
+			CreateDatasetOutcome createDataset(const Model::CreateDatasetRequest &request)const;
+			void createDatasetAsync(const Model::CreateDatasetRequest& request, const CreateDatasetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateDatasetOutcomeCallable createDatasetCallable(const Model::CreateDatasetRequest& request) const;
+			CreateDatasetRecordOutcome createDatasetRecord(const Model::CreateDatasetRecordRequest &request)const;
+			void createDatasetRecordAsync(const Model::CreateDatasetRecordRequest& request, const CreateDatasetRecordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateDatasetRecordOutcomeCallable createDatasetRecordCallable(const Model::CreateDatasetRecordRequest& request) const;
+			CreateModelOutcome createModel(const Model::CreateModelRequest &request)const;
+			void createModelAsync(const Model::CreateModelRequest& request, const CreateModelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateModelOutcomeCallable createModelCallable(const Model::CreateModelRequest& request) const;
+			CreateProjectOutcome createProject(const Model::CreateProjectRequest &request)const;
+			void createProjectAsync(const Model::CreateProjectRequest& request, const CreateProjectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateProjectOutcomeCallable createProjectCallable(const Model::CreateProjectRequest& request) const;
+			DeleteModelOutcome deleteModel(const Model::DeleteModelRequest &request)const;
+			void deleteModelAsync(const Model::DeleteModelRequest& request, const DeleteModelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteModelOutcomeCallable deleteModelCallable(const Model::DeleteModelRequest& request) const;
+			DeployModelOutcome deployModel(const Model::DeployModelRequest &request)const;
+			void deployModelAsync(const Model::DeployModelRequest& request, const DeployModelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeployModelOutcomeCallable deployModelCallable(const Model::DeployModelRequest& request) const;
 			GetAsyncPredictOutcome getAsyncPredict(const Model::GetAsyncPredictRequest &request)const;
 			void getAsyncPredictAsync(const Model::GetAsyncPredictRequest& request, const GetAsyncPredictAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetAsyncPredictOutcomeCallable getAsyncPredictCallable(const Model::GetAsyncPredictRequest& request) const;
+			GetModelOutcome getModel(const Model::GetModelRequest &request)const;
+			void getModelAsync(const Model::GetModelRequest& request, const GetModelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetModelOutcomeCallable getModelCallable(const Model::GetModelRequest& request) const;
+			GetPredictDocOutcome getPredictDoc(const Model::GetPredictDocRequest &request)const;
+			void getPredictDocAsync(const Model::GetPredictDocRequest& request, const GetPredictDocAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetPredictDocOutcomeCallable getPredictDocCallable(const Model::GetPredictDocRequest& request) const;
 			GetPredictResultOutcome getPredictResult(const Model::GetPredictResultRequest &request)const;
 			void getPredictResultAsync(const Model::GetPredictResultRequest& request, const GetPredictResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetPredictResultOutcomeCallable getPredictResultCallable(const Model::GetPredictResultRequest& request) const;
+			InvokeActionOutcome invokeAction(const Model::InvokeActionRequest &request)const;
+			void invokeActionAsync(const Model::InvokeActionRequest& request, const InvokeActionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			InvokeActionOutcomeCallable invokeActionCallable(const Model::InvokeActionRequest& request) const;
+			ListDatasetOutcome listDataset(const Model::ListDatasetRequest &request)const;
+			void listDatasetAsync(const Model::ListDatasetRequest& request, const ListDatasetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListDatasetOutcomeCallable listDatasetCallable(const Model::ListDatasetRequest& request) const;
+			ListModelsOutcome listModels(const Model::ListModelsRequest &request)const;
+			void listModelsAsync(const Model::ListModelsRequest& request, const ListModelsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListModelsOutcomeCallable listModelsCallable(const Model::ListModelsRequest& request) const;
+			PredictMTModelOutcome predictMTModel(const Model::PredictMTModelRequest &request)const;
+			void predictMTModelAsync(const Model::PredictMTModelRequest& request, const PredictMTModelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PredictMTModelOutcomeCallable predictMTModelCallable(const Model::PredictMTModelRequest& request) const;
+			PredictMTModelByDocOutcome predictMTModelByDoc(const Model::PredictMTModelByDocRequest &request)const;
+			void predictMTModelByDocAsync(const Model::PredictMTModelByDocRequest& request, const PredictMTModelByDocAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PredictMTModelByDocOutcomeCallable predictMTModelByDocCallable(const Model::PredictMTModelByDocRequest& request) const;
 			RunContactReviewOutcome runContactReview(const Model::RunContactReviewRequest &request)const;
 			void runContactReviewAsync(const Model::RunContactReviewRequest& request, const RunContactReviewAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RunContactReviewOutcomeCallable runContactReviewCallable(const Model::RunContactReviewRequest& request) const;

nlp-automl/include/alibabacloud/nlp-automl/model/AddMTInterveneWordRequest.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_NLP_AUTOML_MODEL_ADDMTINTERVENEWORDREQUEST_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_ADDMTINTERVENEWORDREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT AddMTInterveneWordRequest : public RpcServiceRequest
+			{
+
+			public:
+				AddMTInterveneWordRequest();
+				~AddMTInterveneWordRequest();
+
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				std::string getSourceText()const;
+				void setSourceText(const std::string& sourceText);
+				std::string getPackageId()const;
+				void setPackageId(const std::string& packageId);
+				std::string getTargetText()const;
+				void setTargetText(const std::string& targetText);
+				int getTenantId()const;
+				void setTenantId(int tenantId);
+				std::string getProjectId()const;
+				void setProjectId(const std::string& projectId);
+
+            private:
+				std::string product_;
+				std::string sourceText_;
+				std::string packageId_;
+				std::string targetText_;
+				int tenantId_;
+				std::string projectId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_ADDMTINTERVENEWORDREQUEST_H_

nlp-automl/include/alibabacloud/nlp-automl/model/AddMTInterveneWordResult.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_NLP_AUTOML_MODEL_ADDMTINTERVENEWORDRESULT_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_ADDMTINTERVENEWORDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT AddMTInterveneWordResult : public ServiceResult
+			{
+			public:
+
+
+				AddMTInterveneWordResult();
+				explicit AddMTInterveneWordResult(const std::string &payload);
+				~AddMTInterveneWordResult();
+				std::string getWordId()const;
+				int getMessage()const;
+				int getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string wordId_;
+				int message_;
+				int code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_ADDMTINTERVENEWORDRESULT_H_

nlp-automl/include/alibabacloud/nlp-automl/model/AddMtIntervenePackageRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_NLP_AUTOML_MODEL_ADDMTINTERVENEPACKAGEREQUEST_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_ADDMTINTERVENEPACKAGEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT AddMtIntervenePackageRequest : public RpcServiceRequest
+			{
+
+			public:
+				AddMtIntervenePackageRequest();
+				~AddMtIntervenePackageRequest();
+
+				std::string getSourceLanguage()const;
+				void setSourceLanguage(const std::string& sourceLanguage);
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				std::string getPackageName()const;
+				void setPackageName(const std::string& packageName);
+				int getTenantId()const;
+				void setTenantId(int tenantId);
+				std::string getProjectType()const;
+				void setProjectType(const std::string& projectType);
+				std::string getSourceType()const;
+				void setSourceType(const std::string& sourceType);
+				std::string getTargetLanguage()const;
+				void setTargetLanguage(const std::string& targetLanguage);
+				std::string getCategory()const;
+				void setCategory(const std::string& category);
+				int getProjectId()const;
+				void setProjectId(int projectId);
+
+            private:
+				std::string sourceLanguage_;
+				std::string product_;
+				std::string packageName_;
+				int tenantId_;
+				std::string projectType_;
+				std::string sourceType_;
+				std::string targetLanguage_;
+				std::string category_;
+				int projectId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_ADDMTINTERVENEPACKAGEREQUEST_H_

nlp-automl/include/alibabacloud/nlp-automl/model/AddMtIntervenePackageResult.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_NLP_AUTOML_MODEL_ADDMTINTERVENEPACKAGERESULT_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_ADDMTINTERVENEPACKAGERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT AddMtIntervenePackageResult : public ServiceResult
+			{
+			public:
+
+
+				AddMtIntervenePackageResult();
+				explicit AddMtIntervenePackageResult(const std::string &payload);
+				~AddMtIntervenePackageResult();
+				int getMessage()const;
+				std::string getPackageId()const;
+				int getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int message_;
+				std::string packageId_;
+				int code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_ADDMTINTERVENEPACKAGERESULT_H_

nlp-automl/include/alibabacloud/nlp-automl/model/BindIntervenePackageAndModelRequest.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_NLP_AUTOML_MODEL_BINDINTERVENEPACKAGEANDMODELREQUEST_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_BINDINTERVENEPACKAGEANDMODELREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT BindIntervenePackageAndModelRequest : public RpcServiceRequest
+			{
+
+			public:
+				BindIntervenePackageAndModelRequest();
+				~BindIntervenePackageAndModelRequest();
+
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				long getModelId()const;
+				void setModelId(long modelId);
+				long getPackageId()const;
+				void setPackageId(long packageId);
+				long getTenantId()const;
+				void setTenantId(long tenantId);
+				long getProjectId()const;
+				void setProjectId(long projectId);
+				std::string getModelVersion()const;
+				void setModelVersion(const std::string& modelVersion);
+
+            private:
+				std::string product_;
+				long modelId_;
+				long packageId_;
+				long tenantId_;
+				long projectId_;
+				std::string modelVersion_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_BINDINTERVENEPACKAGEANDMODELREQUEST_H_

nlp-automl/include/alibabacloud/nlp-automl/model/BindIntervenePackageAndModelResult.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_NLP_AUTOML_MODEL_BINDINTERVENEPACKAGEANDMODELRESULT_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_BINDINTERVENEPACKAGEANDMODELRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT BindIntervenePackageAndModelResult : public ServiceResult
+			{
+			public:
+
+
+				BindIntervenePackageAndModelResult();
+				explicit BindIntervenePackageAndModelResult(const std::string &payload);
+				~BindIntervenePackageAndModelResult();
+				int getMessage()const;
+				int getCode()const;
+				std::string getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int message_;
+				int code_;
+				std::string success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_BINDINTERVENEPACKAGEANDMODELRESULT_H_

nlp-automl/include/alibabacloud/nlp-automl/model/CreateAsyncPredictRequest.h

@@ -47,6 +47,8 @@ namespace AlibabaCloud
 				void setContent(const std::string& content);
 				std::string getFileContent()const;
 				void setFileContent(const std::string& fileContent);
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
 				int getModelId()const;
 				void setModelId(int modelId);
 				std::string getFileUrl()const;
@@ -61,6 +63,7 @@ namespace AlibabaCloud
 				std::string fetchContent_;
 				std::string content_;
 				std::string fileContent_;
+				std::string product_;
 				int modelId_;
 				std::string fileUrl_;
 				std::string modelVersion_;

nlp-automl/include/alibabacloud/nlp-automl/model/CreateDatasetRecordRequest.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_NLP_AUTOML_MODEL_CREATEDATASETRECORDREQUEST_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_CREATEDATASETRECORDREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT CreateDatasetRecordRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateDatasetRecordRequest();
+				~CreateDatasetRecordRequest();
+
+				std::string getDatasetRecord()const;
+				void setDatasetRecord(const std::string& datasetRecord);
+				long getDatasetId()const;
+				void setDatasetId(long datasetId);
+				long getProjectId()const;
+				void setProjectId(long projectId);
+
+            private:
+				std::string datasetRecord_;
+				long datasetId_;
+				long projectId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_CREATEDATASETRECORDREQUEST_H_

nlp-automl/include/alibabacloud/nlp-automl/model/CreateDatasetRecordResult.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_NLP_AUTOML_MODEL_CREATEDATASETRECORDRESULT_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_CREATEDATASETRECORDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT CreateDatasetRecordResult : public ServiceResult
+			{
+			public:
+
+
+				CreateDatasetRecordResult();
+				explicit CreateDatasetRecordResult(const std::string &payload);
+				~CreateDatasetRecordResult();
+				std::string getMessage()const;
+				std::string getDatasetRecordId()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string datasetRecordId_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_CREATEDATASETRECORDRESULT_H_

nlp-automl/include/alibabacloud/nlp-automl/model/CreateDatasetRequest.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_NLP_AUTOML_MODEL_CREATEDATASETREQUEST_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_CREATEDATASETREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT CreateDatasetRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateDatasetRequest();
+				~CreateDatasetRequest();
+
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				std::string getDatasetName()const;
+				void setDatasetName(const std::string& datasetName);
+				long getProjectId()const;
+				void setProjectId(long projectId);
+
+            private:
+				std::string product_;
+				std::string datasetName_;
+				long projectId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_CREATEDATASETREQUEST_H_

nlp-automl/include/alibabacloud/nlp-automl/model/CreateDatasetResult.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_NLP_AUTOML_MODEL_CREATEDATASETRESULT_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_CREATEDATASETRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT CreateDatasetResult : public ServiceResult
+			{
+			public:
+
+
+				CreateDatasetResult();
+				explicit CreateDatasetResult(const std::string &payload);
+				~CreateDatasetResult();
+				std::string getMessage()const;
+				int getCode()const;
+				bool getSuccess()const;
+				std::string getDatasetId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int code_;
+				bool success_;
+				std::string datasetId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_CREATEDATASETRESULT_H_

nlp-automl/include/alibabacloud/nlp-automl/model/CreateModelRequest.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_NLP_AUTOML_MODEL_CREATEMODELREQUEST_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_CREATEMODELREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT CreateModelRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateModelRequest();
+				~CreateModelRequest();
+
+				std::string getIsIncrementalTrain()const;
+				void setIsIncrementalTrain(const std::string& isIncrementalTrain);
+				std::string getModelName()const;
+				void setModelName(const std::string& modelName);
+				std::map<std::string, std::string> getDatasetIdList()const;
+				void setDatasetIdList(const std::map<std::string, std::string>& datasetIdList);
+				std::map<std::string, std::string> getTestDatasetIdList()const;
+				void setTestDatasetIdList(const std::map<std::string, std::string>& testDatasetIdList);
+				std::string getModelType()const;
+				void setModelType(const std::string& modelType);
+				long getProjectId()const;
+				void setProjectId(long projectId);
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				long getModelId()const;
+				void setModelId(long modelId);
+
+            private:
+				std::string isIncrementalTrain_;
+				std::string modelName_;
+				std::map<std::string, std::string> datasetIdList_;
+				std::map<std::string, std::string> testDatasetIdList_;
+				std::string modelType_;
+				long projectId_;
+				std::string product_;
+				long modelId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_CREATEMODELREQUEST_H_

nlp-automl/include/alibabacloud/nlp-automl/model/CreateModelResult.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_NLP_AUTOML_MODEL_CREATEMODELRESULT_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_CREATEMODELRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT CreateModelResult : public ServiceResult
+			{
+			public:
+
+
+				CreateModelResult();
+				explicit CreateModelResult(const std::string &payload);
+				~CreateModelResult();
+				std::string getMessage()const;
+				std::string getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_CREATEMODELRESULT_H_

nlp-automl/include/alibabacloud/nlp-automl/model/CreateProjectRequest.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_NLP_AUTOML_MODEL_CREATEPROJECTREQUEST_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_CREATEPROJECTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT CreateProjectRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateProjectRequest();
+				~CreateProjectRequest();
+
+				std::string getProjectName()const;
+				void setProjectName(const std::string& projectName);
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				std::string getProjectDescription()const;
+				void setProjectDescription(const std::string& projectDescription);
+				std::string getProjectType()const;
+				void setProjectType(const std::string& projectType);
+
+            private:
+				std::string projectName_;
+				std::string product_;
+				std::string projectDescription_;
+				std::string projectType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_CREATEPROJECTREQUEST_H_

nlp-automl/include/alibabacloud/nlp-automl/model/CreateProjectResult.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_NLP_AUTOML_MODEL_CREATEPROJECTRESULT_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_CREATEPROJECTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT CreateProjectResult : public ServiceResult
+			{
+			public:
+
+
+				CreateProjectResult();
+				explicit CreateProjectResult(const std::string &payload);
+				~CreateProjectResult();
+				std::string getMessage()const;
+				std::string getProjectId()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string projectId_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_CREATEPROJECTRESULT_H_

nlp-automl/include/alibabacloud/nlp-automl/model/DeleteModelRequest.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_NLP_AUTOML_MODEL_DELETEMODELREQUEST_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_DELETEMODELREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT DeleteModelRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteModelRequest();
+				~DeleteModelRequest();
+
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				long getModelId()const;
+				void setModelId(long modelId);
+				long getProjectId()const;
+				void setProjectId(long projectId);
+
+            private:
+				std::string product_;
+				long modelId_;
+				long projectId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_DELETEMODELREQUEST_H_

nlp-automl/include/alibabacloud/nlp-automl/model/DeleteModelResult.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_NLP_AUTOML_MODEL_DELETEMODELRESULT_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_DELETEMODELRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT DeleteModelResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteModelResult();
+				explicit DeleteModelResult(const std::string &payload);
+				~DeleteModelResult();
+				std::string getMessage()const;
+				std::string getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_DELETEMODELRESULT_H_

nlp-automl/include/alibabacloud/nlp-automl/model/DeployModelRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NLP_AUTOML_MODEL_DEPLOYMODELREQUEST_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_DEPLOYMODELREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT DeployModelRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeployModelRequest();
+				~DeployModelRequest();
+
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				long getModelId()const;
+				void setModelId(long modelId);
+				std::string getOptType()const;
+				void setOptType(const std::string& optType);
+				long getProjectId()const;
+				void setProjectId(long projectId);
+				std::string getModelVersion()const;
+				void setModelVersion(const std::string& modelVersion);
+
+            private:
+				std::string product_;
+				long modelId_;
+				std::string optType_;
+				long projectId_;
+				std::string modelVersion_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_DEPLOYMODELREQUEST_H_

nlp-automl/include/alibabacloud/nlp-automl/model/DeployModelResult.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_NLP_AUTOML_MODEL_DEPLOYMODELRESULT_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_DEPLOYMODELRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT DeployModelResult : public ServiceResult
+			{
+			public:
+
+
+				DeployModelResult();
+				explicit DeployModelResult(const std::string &payload);
+				~DeployModelResult();
+				std::string getMessage()const;
+				std::string getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_DEPLOYMODELRESULT_H_

nlp-automl/include/alibabacloud/nlp-automl/model/GetAsyncPredictRequest.h

@@ -35,10 +35,13 @@ namespace AlibabaCloud
 				GetAsyncPredictRequest();
 				~GetAsyncPredictRequest();
 
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
 				int getAsyncPredictId()const;
 				void setAsyncPredictId(int asyncPredictId);
 
             private:
+				std::string product_;
 				int asyncPredictId_;
 
 			};

nlp-automl/include/alibabacloud/nlp-automl/model/GetModelRequest.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_NLP_AUTOML_MODEL_GETMODELREQUEST_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_GETMODELREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT GetModelRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetModelRequest();
+				~GetModelRequest();
+
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				long getModelId()const;
+				void setModelId(long modelId);
+				long getProjectId()const;
+				void setProjectId(long projectId);
+				std::string getModelVersion()const;
+				void setModelVersion(const std::string& modelVersion);
+
+            private:
+				std::string product_;
+				long modelId_;
+				long projectId_;
+				std::string modelVersion_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_GETMODELREQUEST_H_

nlp-automl/include/alibabacloud/nlp-automl/model/GetModelResult.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_NLP_AUTOML_MODEL_GETMODELRESULT_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_GETMODELRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT GetModelResult : public ServiceResult
+			{
+			public:
+
+
+				GetModelResult();
+				explicit GetModelResult(const std::string &payload);
+				~GetModelResult();
+				std::string getMessage()const;
+				std::string getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_GETMODELRESULT_H_

nlp-automl/include/alibabacloud/nlp-automl/model/GetPredictDocRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NLP_AUTOML_MODEL_GETPREDICTDOCREQUEST_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_GETPREDICTDOCREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT GetPredictDocRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetPredictDocRequest();
+				~GetPredictDocRequest();
+
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				long getDocId()const;
+				void setDocId(long docId);
+
+            private:
+				std::string product_;
+				long docId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_GETPREDICTDOCREQUEST_H_

nlp-automl/include/alibabacloud/nlp-automl/model/GetPredictDocResult.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_NLP_AUTOML_MODEL_GETPREDICTDOCRESULT_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_GETPREDICTDOCRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT GetPredictDocResult : public ServiceResult
+			{
+			public:
+
+
+				GetPredictDocResult();
+				explicit GetPredictDocResult(const std::string &payload);
+				~GetPredictDocResult();
+				int getStatus()const;
+				std::string getXLIFFInfo()const;
+				std::string getResultContent()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int status_;
+				std::string xLIFFInfo_;
+				std::string resultContent_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_GETPREDICTDOCRESULT_H_

nlp-automl/include/alibabacloud/nlp-automl/model/GetPredictResultRequest.h

@@ -37,6 +37,8 @@ namespace AlibabaCloud
 
 				int getTopK()const;
 				void setTopK(int topK);
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
 				int getModelId()const;
 				void setModelId(int modelId);
 				std::string getDetailTag()const;
@@ -48,6 +50,7 @@ namespace AlibabaCloud
 
             private:
 				int topK_;
+				std::string product_;
 				int modelId_;
 				std::string detailTag_;
 				std::string content_;

nlp-automl/include/alibabacloud/nlp-automl/model/InvokeActionRequest.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_NLP_AUTOML_MODEL_INVOKEACTIONREQUEST_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_INVOKEACTIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT InvokeActionRequest : public RpcServiceRequest
+			{
+
+			public:
+				InvokeActionRequest();
+				~InvokeActionRequest();
+
+				std::string getInvokeProduct()const;
+				void setInvokeProduct(const std::string& invokeProduct);
+				std::string getInvokeAction()const;
+				void setInvokeAction(const std::string& invokeAction);
+				std::string getInvokeParams()const;
+				void setInvokeParams(const std::string& invokeParams);
+				std::string getInvokeRegion()const;
+				void setInvokeRegion(const std::string& invokeRegion);
+
+            private:
+				std::string invokeProduct_;
+				std::string invokeAction_;
+				std::string invokeParams_;
+				std::string invokeRegion_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_INVOKEACTIONREQUEST_H_

nlp-automl/include/alibabacloud/nlp-automl/model/InvokeActionResult.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_NLP_AUTOML_MODEL_INVOKEACTIONRESULT_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_INVOKEACTIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT InvokeActionResult : public ServiceResult
+			{
+			public:
+
+
+				InvokeActionResult();
+				explicit InvokeActionResult(const std::string &payload);
+				~InvokeActionResult();
+				int getMessage()const;
+				std::string getData()const;
+				int getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int message_;
+				std::string data_;
+				int code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_INVOKEACTIONRESULT_H_

nlp-automl/include/alibabacloud/nlp-automl/model/ListDatasetRequest.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_NLP_AUTOML_MODEL_LISTDATASETREQUEST_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_LISTDATASETREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT ListDatasetRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListDatasetRequest();
+				~ListDatasetRequest();
+
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				long getProjectId()const;
+				void setProjectId(long projectId);
+
+            private:
+				std::string product_;
+				int pageNumber_;
+				int pageSize_;
+				long projectId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_LISTDATASETREQUEST_H_

nlp-automl/include/alibabacloud/nlp-automl/model/ListDatasetResult.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_NLP_AUTOML_MODEL_LISTDATASETRESULT_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_LISTDATASETRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT ListDatasetResult : public ServiceResult
+			{
+			public:
+
+
+				ListDatasetResult();
+				explicit ListDatasetResult(const std::string &payload);
+				~ListDatasetResult();
+				std::string getMessage()const;
+				std::string getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_LISTDATASETRESULT_H_

nlp-automl/include/alibabacloud/nlp-automl/model/ListModelsRequest.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_NLP_AUTOML_MODEL_LISTMODELSREQUEST_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_LISTMODELSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT ListModelsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListModelsRequest();
+				~ListModelsRequest();
+
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				long getProjectId()const;
+				void setProjectId(long projectId);
+
+            private:
+				std::string product_;
+				int pageNumber_;
+				int pageSize_;
+				long projectId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_LISTMODELSREQUEST_H_

nlp-automl/include/alibabacloud/nlp-automl/model/ListModelsResult.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_NLP_AUTOML_MODEL_LISTMODELSRESULT_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_LISTMODELSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT ListModelsResult : public ServiceResult
+			{
+			public:
+
+
+				ListModelsResult();
+				explicit ListModelsResult(const std::string &payload);
+				~ListModelsResult();
+				std::string getMessage()const;
+				std::string getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_LISTMODELSRESULT_H_

nlp-automl/include/alibabacloud/nlp-automl/model/PredictMTModelByDocRequest.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_NLP_AUTOML_MODEL_PREDICTMTMODELBYDOCREQUEST_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_PREDICTMTMODELBYDOCREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT PredictMTModelByDocRequest : public RpcServiceRequest
+			{
+
+			public:
+				PredictMTModelByDocRequest();
+				~PredictMTModelByDocRequest();
+
+				std::string getFileType()const;
+				void setFileType(const std::string& fileType);
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				int getModelId()const;
+				void setModelId(int modelId);
+				std::string getFileContent()const;
+				void setFileContent(const std::string& fileContent);
+				bool getNeedXLIFF()const;
+				void setNeedXLIFF(bool needXLIFF);
+				std::string getModelVersion()const;
+				void setModelVersion(const std::string& modelVersion);
+
+            private:
+				std::string fileType_;
+				std::string product_;
+				int modelId_;
+				std::string fileContent_;
+				bool needXLIFF_;
+				std::string modelVersion_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_PREDICTMTMODELBYDOCREQUEST_H_

nlp-automl/include/alibabacloud/nlp-automl/model/PredictMTModelByDocResult.h

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

nlp-automl/include/alibabacloud/nlp-automl/model/PredictMTModelRequest.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_NLP_AUTOML_MODEL_PREDICTMTMODELREQUEST_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_PREDICTMTMODELREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT PredictMTModelRequest : public RpcServiceRequest
+			{
+
+			public:
+				PredictMTModelRequest();
+				~PredictMTModelRequest();
+
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				std::string getModelId()const;
+				void setModelId(const std::string& modelId);
+				std::string getContent()const;
+				void setContent(const std::string& content);
+				std::string getModelVersion()const;
+				void setModelVersion(const std::string& modelVersion);
+
+            private:
+				std::string product_;
+				std::string modelId_;
+				std::string content_;
+				std::string modelVersion_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_PREDICTMTMODELREQUEST_H_

nlp-automl/include/alibabacloud/nlp-automl/model/PredictMTModelResult.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_NLP_AUTOML_MODEL_PREDICTMTMODELRESULT_H_
+#define ALIBABACLOUD_NLP_AUTOML_MODEL_PREDICTMTMODELRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nlp-automl/Nlp_automlExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nlp_automl
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NLP_AUTOML_EXPORT PredictMTModelResult : public ServiceResult
+			{
+			public:
+
+
+				PredictMTModelResult();
+				explicit PredictMTModelResult(const std::string &payload);
+				~PredictMTModelResult();
+				int getMessage()const;
+				std::string getData()const;
+				int getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int message_;
+				std::string data_;
+				int code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NLP_AUTOML_MODEL_PREDICTMTMODELRESULT_H_

nlp-automl/include/alibabacloud/nlp-automl/model/RunContactReviewRequest.h

@@ -35,12 +35,15 @@ namespace AlibabaCloud
 				RunContactReviewRequest();
 				~RunContactReviewRequest();
 
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
 				std::string getContactScene()const;
 				void setContactScene(const std::string& contactScene);
 				std::string getContactPath()const;
 				void setContactPath(const std::string& contactPath);
 
             private:
+				std::string product_;
 				std::string contactScene_;
 				std::string contactPath_;
 

nlp-automl/include/alibabacloud/nlp-automl/model/RunPreTrainServiceRequest.h

@@ -35,6 +35,8 @@ namespace AlibabaCloud
 				RunPreTrainServiceRequest();
 				~RunPreTrainServiceRequest();
 
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
 				std::string getPredictContent()const;
 				void setPredictContent(const std::string& predictContent);
 				std::string getServiceVersion()const;
@@ -43,6 +45,7 @@ namespace AlibabaCloud
 				void setServiceName(const std::string& serviceName);
 
             private:
+				std::string product_;
 				std::string predictContent_;
 				std::string serviceVersion_;
 				std::string serviceName_;

nlp-automl/include/alibabacloud/nlp-automl/model/RunSmartCallServiceRequest.h

@@ -35,6 +35,8 @@ namespace AlibabaCloud
 				RunSmartCallServiceRequest();
 				~RunSmartCallServiceRequest();
 
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
 				std::string getSessionId()const;
 				void setSessionId(const std::string& sessionId);
 				long getRobotId()const;
@@ -45,6 +47,7 @@ namespace AlibabaCloud
 				void setServiceName(const std::string& serviceName);
 
             private:
+				std::string product_;
 				std::string sessionId_;
 				long robotId_;
 				std::string paramContent_;

nlp-automl/src/Nlp-automlClient.cc

@@ -51,6 +51,114 @@ Nlp_automlClient::Nlp_automlClient(const std::string & accessKeyId, const std::s
 Nlp_automlClient::~Nlp_automlClient()
 {}
 
+Nlp_automlClient::AddMTInterveneWordOutcome Nlp_automlClient::addMTInterveneWord(const AddMTInterveneWordRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddMTInterveneWordOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddMTInterveneWordOutcome(AddMTInterveneWordResult(outcome.result()));
+	else
+		return AddMTInterveneWordOutcome(outcome.error());
+}
+
+void Nlp_automlClient::addMTInterveneWordAsync(const AddMTInterveneWordRequest& request, const AddMTInterveneWordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addMTInterveneWord(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Nlp_automlClient::AddMTInterveneWordOutcomeCallable Nlp_automlClient::addMTInterveneWordCallable(const AddMTInterveneWordRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddMTInterveneWordOutcome()>>(
+			[this, request]()
+			{
+			return this->addMTInterveneWord(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Nlp_automlClient::AddMtIntervenePackageOutcome Nlp_automlClient::addMtIntervenePackage(const AddMtIntervenePackageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddMtIntervenePackageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddMtIntervenePackageOutcome(AddMtIntervenePackageResult(outcome.result()));
+	else
+		return AddMtIntervenePackageOutcome(outcome.error());
+}
+
+void Nlp_automlClient::addMtIntervenePackageAsync(const AddMtIntervenePackageRequest& request, const AddMtIntervenePackageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addMtIntervenePackage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Nlp_automlClient::AddMtIntervenePackageOutcomeCallable Nlp_automlClient::addMtIntervenePackageCallable(const AddMtIntervenePackageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddMtIntervenePackageOutcome()>>(
+			[this, request]()
+			{
+			return this->addMtIntervenePackage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Nlp_automlClient::BindIntervenePackageAndModelOutcome Nlp_automlClient::bindIntervenePackageAndModel(const BindIntervenePackageAndModelRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return BindIntervenePackageAndModelOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return BindIntervenePackageAndModelOutcome(BindIntervenePackageAndModelResult(outcome.result()));
+	else
+		return BindIntervenePackageAndModelOutcome(outcome.error());
+}
+
+void Nlp_automlClient::bindIntervenePackageAndModelAsync(const BindIntervenePackageAndModelRequest& request, const BindIntervenePackageAndModelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, bindIntervenePackageAndModel(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Nlp_automlClient::BindIntervenePackageAndModelOutcomeCallable Nlp_automlClient::bindIntervenePackageAndModelCallable(const BindIntervenePackageAndModelRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<BindIntervenePackageAndModelOutcome()>>(
+			[this, request]()
+			{
+			return this->bindIntervenePackageAndModel(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Nlp_automlClient::CreateAsyncPredictOutcome Nlp_automlClient::createAsyncPredict(const CreateAsyncPredictRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -87,6 +195,222 @@ Nlp_automlClient::CreateAsyncPredictOutcomeCallable Nlp_automlClient::createAsyn
 	return task->get_future();
 }
 
+Nlp_automlClient::CreateDatasetOutcome Nlp_automlClient::createDataset(const CreateDatasetRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateDatasetOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateDatasetOutcome(CreateDatasetResult(outcome.result()));
+	else
+		return CreateDatasetOutcome(outcome.error());
+}
+
+void Nlp_automlClient::createDatasetAsync(const CreateDatasetRequest& request, const CreateDatasetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createDataset(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Nlp_automlClient::CreateDatasetOutcomeCallable Nlp_automlClient::createDatasetCallable(const CreateDatasetRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateDatasetOutcome()>>(
+			[this, request]()
+			{
+			return this->createDataset(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Nlp_automlClient::CreateDatasetRecordOutcome Nlp_automlClient::createDatasetRecord(const CreateDatasetRecordRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateDatasetRecordOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateDatasetRecordOutcome(CreateDatasetRecordResult(outcome.result()));
+	else
+		return CreateDatasetRecordOutcome(outcome.error());
+}
+
+void Nlp_automlClient::createDatasetRecordAsync(const CreateDatasetRecordRequest& request, const CreateDatasetRecordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createDatasetRecord(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Nlp_automlClient::CreateDatasetRecordOutcomeCallable Nlp_automlClient::createDatasetRecordCallable(const CreateDatasetRecordRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateDatasetRecordOutcome()>>(
+			[this, request]()
+			{
+			return this->createDatasetRecord(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Nlp_automlClient::CreateModelOutcome Nlp_automlClient::createModel(const CreateModelRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateModelOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateModelOutcome(CreateModelResult(outcome.result()));
+	else
+		return CreateModelOutcome(outcome.error());
+}
+
+void Nlp_automlClient::createModelAsync(const CreateModelRequest& request, const CreateModelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createModel(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Nlp_automlClient::CreateModelOutcomeCallable Nlp_automlClient::createModelCallable(const CreateModelRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateModelOutcome()>>(
+			[this, request]()
+			{
+			return this->createModel(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Nlp_automlClient::CreateProjectOutcome Nlp_automlClient::createProject(const CreateProjectRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateProjectOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateProjectOutcome(CreateProjectResult(outcome.result()));
+	else
+		return CreateProjectOutcome(outcome.error());
+}
+
+void Nlp_automlClient::createProjectAsync(const CreateProjectRequest& request, const CreateProjectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createProject(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Nlp_automlClient::CreateProjectOutcomeCallable Nlp_automlClient::createProjectCallable(const CreateProjectRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateProjectOutcome()>>(
+			[this, request]()
+			{
+			return this->createProject(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Nlp_automlClient::DeleteModelOutcome Nlp_automlClient::deleteModel(const DeleteModelRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteModelOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteModelOutcome(DeleteModelResult(outcome.result()));
+	else
+		return DeleteModelOutcome(outcome.error());
+}
+
+void Nlp_automlClient::deleteModelAsync(const DeleteModelRequest& request, const DeleteModelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteModel(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Nlp_automlClient::DeleteModelOutcomeCallable Nlp_automlClient::deleteModelCallable(const DeleteModelRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteModelOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteModel(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Nlp_automlClient::DeployModelOutcome Nlp_automlClient::deployModel(const DeployModelRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeployModelOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeployModelOutcome(DeployModelResult(outcome.result()));
+	else
+		return DeployModelOutcome(outcome.error());
+}
+
+void Nlp_automlClient::deployModelAsync(const DeployModelRequest& request, const DeployModelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deployModel(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Nlp_automlClient::DeployModelOutcomeCallable Nlp_automlClient::deployModelCallable(const DeployModelRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeployModelOutcome()>>(
+			[this, request]()
+			{
+			return this->deployModel(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Nlp_automlClient::GetAsyncPredictOutcome Nlp_automlClient::getAsyncPredict(const GetAsyncPredictRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -123,6 +447,78 @@ Nlp_automlClient::GetAsyncPredictOutcomeCallable Nlp_automlClient::getAsyncPredi
 	return task->get_future();
 }
 
+Nlp_automlClient::GetModelOutcome Nlp_automlClient::getModel(const GetModelRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetModelOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetModelOutcome(GetModelResult(outcome.result()));
+	else
+		return GetModelOutcome(outcome.error());
+}
+
+void Nlp_automlClient::getModelAsync(const GetModelRequest& request, const GetModelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getModel(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Nlp_automlClient::GetModelOutcomeCallable Nlp_automlClient::getModelCallable(const GetModelRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetModelOutcome()>>(
+			[this, request]()
+			{
+			return this->getModel(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Nlp_automlClient::GetPredictDocOutcome Nlp_automlClient::getPredictDoc(const GetPredictDocRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetPredictDocOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetPredictDocOutcome(GetPredictDocResult(outcome.result()));
+	else
+		return GetPredictDocOutcome(outcome.error());
+}
+
+void Nlp_automlClient::getPredictDocAsync(const GetPredictDocRequest& request, const GetPredictDocAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getPredictDoc(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Nlp_automlClient::GetPredictDocOutcomeCallable Nlp_automlClient::getPredictDocCallable(const GetPredictDocRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetPredictDocOutcome()>>(
+			[this, request]()
+			{
+			return this->getPredictDoc(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Nlp_automlClient::GetPredictResultOutcome Nlp_automlClient::getPredictResult(const GetPredictResultRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -159,6 +555,186 @@ Nlp_automlClient::GetPredictResultOutcomeCallable Nlp_automlClient::getPredictRe
 	return task->get_future();
 }
 
+Nlp_automlClient::InvokeActionOutcome Nlp_automlClient::invokeAction(const InvokeActionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return InvokeActionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return InvokeActionOutcome(InvokeActionResult(outcome.result()));
+	else
+		return InvokeActionOutcome(outcome.error());
+}
+
+void Nlp_automlClient::invokeActionAsync(const InvokeActionRequest& request, const InvokeActionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, invokeAction(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Nlp_automlClient::InvokeActionOutcomeCallable Nlp_automlClient::invokeActionCallable(const InvokeActionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<InvokeActionOutcome()>>(
+			[this, request]()
+			{
+			return this->invokeAction(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Nlp_automlClient::ListDatasetOutcome Nlp_automlClient::listDataset(const ListDatasetRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListDatasetOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListDatasetOutcome(ListDatasetResult(outcome.result()));
+	else
+		return ListDatasetOutcome(outcome.error());
+}
+
+void Nlp_automlClient::listDatasetAsync(const ListDatasetRequest& request, const ListDatasetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listDataset(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Nlp_automlClient::ListDatasetOutcomeCallable Nlp_automlClient::listDatasetCallable(const ListDatasetRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListDatasetOutcome()>>(
+			[this, request]()
+			{
+			return this->listDataset(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Nlp_automlClient::ListModelsOutcome Nlp_automlClient::listModels(const ListModelsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListModelsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListModelsOutcome(ListModelsResult(outcome.result()));
+	else
+		return ListModelsOutcome(outcome.error());
+}
+
+void Nlp_automlClient::listModelsAsync(const ListModelsRequest& request, const ListModelsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listModels(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Nlp_automlClient::ListModelsOutcomeCallable Nlp_automlClient::listModelsCallable(const ListModelsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListModelsOutcome()>>(
+			[this, request]()
+			{
+			return this->listModels(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Nlp_automlClient::PredictMTModelOutcome Nlp_automlClient::predictMTModel(const PredictMTModelRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PredictMTModelOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PredictMTModelOutcome(PredictMTModelResult(outcome.result()));
+	else
+		return PredictMTModelOutcome(outcome.error());
+}
+
+void Nlp_automlClient::predictMTModelAsync(const PredictMTModelRequest& request, const PredictMTModelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, predictMTModel(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Nlp_automlClient::PredictMTModelOutcomeCallable Nlp_automlClient::predictMTModelCallable(const PredictMTModelRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PredictMTModelOutcome()>>(
+			[this, request]()
+			{
+			return this->predictMTModel(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Nlp_automlClient::PredictMTModelByDocOutcome Nlp_automlClient::predictMTModelByDoc(const PredictMTModelByDocRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PredictMTModelByDocOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PredictMTModelByDocOutcome(PredictMTModelByDocResult(outcome.result()));
+	else
+		return PredictMTModelByDocOutcome(outcome.error());
+}
+
+void Nlp_automlClient::predictMTModelByDocAsync(const PredictMTModelByDocRequest& request, const PredictMTModelByDocAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, predictMTModelByDoc(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Nlp_automlClient::PredictMTModelByDocOutcomeCallable Nlp_automlClient::predictMTModelByDocCallable(const PredictMTModelByDocRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PredictMTModelByDocOutcome()>>(
+			[this, request]()
+			{
+			return this->predictMTModelByDoc(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Nlp_automlClient::RunContactReviewOutcome Nlp_automlClient::runContactReview(const RunContactReviewRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

nlp-automl/src/model/AddMTInterveneWordRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/nlp-automl/model/AddMTInterveneWordRequest.h>
+
+using AlibabaCloud::Nlp_automl::Model::AddMTInterveneWordRequest;
+
+AddMTInterveneWordRequest::AddMTInterveneWordRequest() :
+	RpcServiceRequest("nlp-automl", "2019-07-01", "AddMTInterveneWord")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AddMTInterveneWordRequest::~AddMTInterveneWordRequest()
+{}
+
+std::string AddMTInterveneWordRequest::getProduct()const
+{
+	return product_;
+}
+
+void AddMTInterveneWordRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string AddMTInterveneWordRequest::getSourceText()const
+{
+	return sourceText_;
+}
+
+void AddMTInterveneWordRequest::setSourceText(const std::string& sourceText)
+{
+	sourceText_ = sourceText;
+	setParameter("SourceText", sourceText);
+}
+
+std::string AddMTInterveneWordRequest::getPackageId()const
+{
+	return packageId_;
+}
+
+void AddMTInterveneWordRequest::setPackageId(const std::string& packageId)
+{
+	packageId_ = packageId;
+	setParameter("PackageId", packageId);
+}
+
+std::string AddMTInterveneWordRequest::getTargetText()const
+{
+	return targetText_;
+}
+
+void AddMTInterveneWordRequest::setTargetText(const std::string& targetText)
+{
+	targetText_ = targetText;
+	setParameter("TargetText", targetText);
+}
+
+int AddMTInterveneWordRequest::getTenantId()const
+{
+	return tenantId_;
+}
+
+void AddMTInterveneWordRequest::setTenantId(int tenantId)
+{
+	tenantId_ = tenantId;
+	setParameter("TenantId", std::to_string(tenantId));
+}
+
+std::string AddMTInterveneWordRequest::getProjectId()const
+{
+	return projectId_;
+}
+
+void AddMTInterveneWordRequest::setProjectId(const std::string& projectId)
+{
+	projectId_ = projectId;
+	setParameter("ProjectId", projectId);
+}
+

nlp-automl/src/model/AddMTInterveneWordResult.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/nlp-automl/model/AddMTInterveneWordResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Nlp_automl;
+using namespace AlibabaCloud::Nlp_automl::Model;
+
+AddMTInterveneWordResult::AddMTInterveneWordResult() :
+	ServiceResult()
+{}
+
+AddMTInterveneWordResult::AddMTInterveneWordResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AddMTInterveneWordResult::~AddMTInterveneWordResult()
+{}
+
+void AddMTInterveneWordResult::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["Message"].isNull())
+		message_ = std::stoi(value["Message"].asString());
+	if(!value["WordId"].isNull())
+		wordId_ = value["WordId"].asString();
+
+}
+
+std::string AddMTInterveneWordResult::getWordId()const
+{
+	return wordId_;
+}
+
+int AddMTInterveneWordResult::getMessage()const
+{
+	return message_;
+}
+
+int AddMTInterveneWordResult::getCode()const
+{
+	return code_;
+}
+

nlp-automl/src/model/AddMtIntervenePackageRequest.cc

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/nlp-automl/model/AddMtIntervenePackageRequest.h>
+
+using AlibabaCloud::Nlp_automl::Model::AddMtIntervenePackageRequest;
+
+AddMtIntervenePackageRequest::AddMtIntervenePackageRequest() :
+	RpcServiceRequest("nlp-automl", "2019-07-01", "AddMtIntervenePackage")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AddMtIntervenePackageRequest::~AddMtIntervenePackageRequest()
+{}
+
+std::string AddMtIntervenePackageRequest::getSourceLanguage()const
+{
+	return sourceLanguage_;
+}
+
+void AddMtIntervenePackageRequest::setSourceLanguage(const std::string& sourceLanguage)
+{
+	sourceLanguage_ = sourceLanguage;
+	setParameter("SourceLanguage", sourceLanguage);
+}
+
+std::string AddMtIntervenePackageRequest::getProduct()const
+{
+	return product_;
+}
+
+void AddMtIntervenePackageRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string AddMtIntervenePackageRequest::getPackageName()const
+{
+	return packageName_;
+}
+
+void AddMtIntervenePackageRequest::setPackageName(const std::string& packageName)
+{
+	packageName_ = packageName;
+	setParameter("PackageName", packageName);
+}
+
+int AddMtIntervenePackageRequest::getTenantId()const
+{
+	return tenantId_;
+}
+
+void AddMtIntervenePackageRequest::setTenantId(int tenantId)
+{
+	tenantId_ = tenantId;
+	setParameter("TenantId", std::to_string(tenantId));
+}
+
+std::string AddMtIntervenePackageRequest::getProjectType()const
+{
+	return projectType_;
+}
+
+void AddMtIntervenePackageRequest::setProjectType(const std::string& projectType)
+{
+	projectType_ = projectType;
+	setParameter("ProjectType", projectType);
+}
+
+std::string AddMtIntervenePackageRequest::getSourceType()const
+{
+	return sourceType_;
+}
+
+void AddMtIntervenePackageRequest::setSourceType(const std::string& sourceType)
+{
+	sourceType_ = sourceType;
+	setParameter("SourceType", sourceType);
+}
+
+std::string AddMtIntervenePackageRequest::getTargetLanguage()const
+{
+	return targetLanguage_;
+}
+
+void AddMtIntervenePackageRequest::setTargetLanguage(const std::string& targetLanguage)
+{
+	targetLanguage_ = targetLanguage;
+	setParameter("TargetLanguage", targetLanguage);
+}
+
+std::string AddMtIntervenePackageRequest::getCategory()const
+{
+	return category_;
+}
+
+void AddMtIntervenePackageRequest::setCategory(const std::string& category)
+{
+	category_ = category;
+	setParameter("Category", category);
+}
+
+int AddMtIntervenePackageRequest::getProjectId()const
+{
+	return projectId_;
+}
+
+void AddMtIntervenePackageRequest::setProjectId(int projectId)
+{
+	projectId_ = projectId;
+	setParameter("ProjectId", std::to_string(projectId));
+}
+

nlp-automl/src/model/AddMtIntervenePackageResult.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/nlp-automl/model/AddMtIntervenePackageResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Nlp_automl;
+using namespace AlibabaCloud::Nlp_automl::Model;
+
+AddMtIntervenePackageResult::AddMtIntervenePackageResult() :
+	ServiceResult()
+{}
+
+AddMtIntervenePackageResult::AddMtIntervenePackageResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AddMtIntervenePackageResult::~AddMtIntervenePackageResult()
+{}
+
+void AddMtIntervenePackageResult::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["Message"].isNull())
+		message_ = std::stoi(value["Message"].asString());
+	if(!value["PackageId"].isNull())
+		packageId_ = value["PackageId"].asString();
+
+}
+
+int AddMtIntervenePackageResult::getMessage()const
+{
+	return message_;
+}
+
+std::string AddMtIntervenePackageResult::getPackageId()const
+{
+	return packageId_;
+}
+
+int AddMtIntervenePackageResult::getCode()const
+{
+	return code_;
+}
+

nlp-automl/src/model/BindIntervenePackageAndModelRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/nlp-automl/model/BindIntervenePackageAndModelRequest.h>
+
+using AlibabaCloud::Nlp_automl::Model::BindIntervenePackageAndModelRequest;
+
+BindIntervenePackageAndModelRequest::BindIntervenePackageAndModelRequest() :
+	RpcServiceRequest("nlp-automl", "2019-07-01", "BindIntervenePackageAndModel")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+BindIntervenePackageAndModelRequest::~BindIntervenePackageAndModelRequest()
+{}
+
+std::string BindIntervenePackageAndModelRequest::getProduct()const
+{
+	return product_;
+}
+
+void BindIntervenePackageAndModelRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+long BindIntervenePackageAndModelRequest::getModelId()const
+{
+	return modelId_;
+}
+
+void BindIntervenePackageAndModelRequest::setModelId(long modelId)
+{
+	modelId_ = modelId;
+	setParameter("ModelId", std::to_string(modelId));
+}
+
+long BindIntervenePackageAndModelRequest::getPackageId()const
+{
+	return packageId_;
+}
+
+void BindIntervenePackageAndModelRequest::setPackageId(long packageId)
+{
+	packageId_ = packageId;
+	setParameter("PackageId", std::to_string(packageId));
+}
+
+long BindIntervenePackageAndModelRequest::getTenantId()const
+{
+	return tenantId_;
+}
+
+void BindIntervenePackageAndModelRequest::setTenantId(long tenantId)
+{
+	tenantId_ = tenantId;
+	setParameter("TenantId", std::to_string(tenantId));
+}
+
+long BindIntervenePackageAndModelRequest::getProjectId()const
+{
+	return projectId_;
+}
+
+void BindIntervenePackageAndModelRequest::setProjectId(long projectId)
+{
+	projectId_ = projectId;
+	setParameter("ProjectId", std::to_string(projectId));
+}
+
+std::string BindIntervenePackageAndModelRequest::getModelVersion()const
+{
+	return modelVersion_;
+}
+
+void BindIntervenePackageAndModelRequest::setModelVersion(const std::string& modelVersion)
+{
+	modelVersion_ = modelVersion;
+	setParameter("ModelVersion", modelVersion);
+}
+

nlp-automl/src/model/BindIntervenePackageAndModelResult.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/nlp-automl/model/BindIntervenePackageAndModelResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Nlp_automl;
+using namespace AlibabaCloud::Nlp_automl::Model;
+
+BindIntervenePackageAndModelResult::BindIntervenePackageAndModelResult() :
+	ServiceResult()
+{}
+
+BindIntervenePackageAndModelResult::BindIntervenePackageAndModelResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+BindIntervenePackageAndModelResult::~BindIntervenePackageAndModelResult()
+{}
+
+void BindIntervenePackageAndModelResult::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["Message"].isNull())
+		message_ = std::stoi(value["Message"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString();
+
+}
+
+int BindIntervenePackageAndModelResult::getMessage()const
+{
+	return message_;
+}
+
+int BindIntervenePackageAndModelResult::getCode()const
+{
+	return code_;
+}
+
+std::string BindIntervenePackageAndModelResult::getSuccess()const
+{
+	return success_;
+}
+

nlp-automl/src/model/CreateAsyncPredictRequest.cc

@@ -93,6 +93,17 @@ void CreateAsyncPredictRequest::setFileContent(const std::string& fileContent)
 	setBodyParameter("FileContent", fileContent);
 }
 
+std::string CreateAsyncPredictRequest::getProduct()const
+{
+	return product_;
+}
+
+void CreateAsyncPredictRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setBodyParameter("Product", product);
+}
+
 int CreateAsyncPredictRequest::getModelId()const
 {
 	return modelId_;

nlp-automl/src/model/CreateDatasetRecordRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/nlp-automl/model/CreateDatasetRecordRequest.h>
+
+using AlibabaCloud::Nlp_automl::Model::CreateDatasetRecordRequest;
+
+CreateDatasetRecordRequest::CreateDatasetRecordRequest() :
+	RpcServiceRequest("nlp-automl", "2019-11-11", "CreateDatasetRecord")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateDatasetRecordRequest::~CreateDatasetRecordRequest()
+{}
+
+std::string CreateDatasetRecordRequest::getDatasetRecord()const
+{
+	return datasetRecord_;
+}
+
+void CreateDatasetRecordRequest::setDatasetRecord(const std::string& datasetRecord)
+{
+	datasetRecord_ = datasetRecord;
+	setBodyParameter("DatasetRecord", datasetRecord);
+}
+
+long CreateDatasetRecordRequest::getDatasetId()const
+{
+	return datasetId_;
+}
+
+void CreateDatasetRecordRequest::setDatasetId(long datasetId)
+{
+	datasetId_ = datasetId;
+	setBodyParameter("DatasetId", std::to_string(datasetId));
+}
+
+long CreateDatasetRecordRequest::getProjectId()const
+{
+	return projectId_;
+}
+
+void CreateDatasetRecordRequest::setProjectId(long projectId)
+{
+	projectId_ = projectId;
+	setBodyParameter("ProjectId", std::to_string(projectId));
+}
+

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

nlp-automl/src/model/CreateDatasetRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/nlp-automl/model/CreateDatasetRequest.h>
+
+using AlibabaCloud::Nlp_automl::Model::CreateDatasetRequest;
+
+CreateDatasetRequest::CreateDatasetRequest() :
+	RpcServiceRequest("nlp-automl", "2019-11-11", "CreateDataset")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateDatasetRequest::~CreateDatasetRequest()
+{}
+
+std::string CreateDatasetRequest::getProduct()const
+{
+	return product_;
+}
+
+void CreateDatasetRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setBodyParameter("Product", product);
+}
+
+std::string CreateDatasetRequest::getDatasetName()const
+{
+	return datasetName_;
+}
+
+void CreateDatasetRequest::setDatasetName(const std::string& datasetName)
+{
+	datasetName_ = datasetName;
+	setBodyParameter("DatasetName", datasetName);
+}
+
+long CreateDatasetRequest::getProjectId()const
+{
+	return projectId_;
+}
+
+void CreateDatasetRequest::setProjectId(long projectId)
+{
+	projectId_ = projectId;
+	setBodyParameter("ProjectId", std::to_string(projectId));
+}
+

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

nlp-automl/src/model/CreateModelRequest.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/nlp-automl/model/CreateModelRequest.h>
+
+using AlibabaCloud::Nlp_automl::Model::CreateModelRequest;
+
+CreateModelRequest::CreateModelRequest() :
+	RpcServiceRequest("nlp-automl", "2019-11-11", "CreateModel")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateModelRequest::~CreateModelRequest()
+{}
+
+std::string CreateModelRequest::getIsIncrementalTrain()const
+{
+	return isIncrementalTrain_;
+}
+
+void CreateModelRequest::setIsIncrementalTrain(const std::string& isIncrementalTrain)
+{
+	isIncrementalTrain_ = isIncrementalTrain;
+	setBodyParameter("IsIncrementalTrain", isIncrementalTrain);
+}
+
+std::string CreateModelRequest::getModelName()const
+{
+	return modelName_;
+}
+
+void CreateModelRequest::setModelName(const std::string& modelName)
+{
+	modelName_ = modelName;
+	setBodyParameter("ModelName", modelName);
+}
+
+std::map<std::string, std::string> CreateModelRequest::getDatasetIdList()const
+{
+	return datasetIdList_;
+}
+
+void CreateModelRequest::setDatasetIdList(const std::map<std::string, std::string>& datasetIdList)
+{
+	datasetIdList_ = datasetIdList;
+	setJsonParameters("DatasetIdList", datasetIdList);
+}
+
+std::map<std::string, std::string> CreateModelRequest::getTestDatasetIdList()const
+{
+	return testDatasetIdList_;
+}
+
+void CreateModelRequest::setTestDatasetIdList(const std::map<std::string, std::string>& testDatasetIdList)
+{
+	testDatasetIdList_ = testDatasetIdList;
+	setJsonParameters("TestDatasetIdList", testDatasetIdList);
+}
+
+std::string CreateModelRequest::getModelType()const
+{
+	return modelType_;
+}
+
+void CreateModelRequest::setModelType(const std::string& modelType)
+{
+	modelType_ = modelType;
+	setBodyParameter("ModelType", modelType);
+}
+
+long CreateModelRequest::getProjectId()const
+{
+	return projectId_;
+}
+
+void CreateModelRequest::setProjectId(long projectId)
+{
+	projectId_ = projectId;
+	setBodyParameter("ProjectId", std::to_string(projectId));
+}
+
+std::string CreateModelRequest::getProduct()const
+{
+	return product_;
+}
+
+void CreateModelRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setBodyParameter("Product", product);
+}
+
+long CreateModelRequest::getModelId()const
+{
+	return modelId_;
+}
+
+void CreateModelRequest::setModelId(long modelId)
+{
+	modelId_ = modelId;
+	setBodyParameter("ModelId", std::to_string(modelId));
+}
+

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

nlp-automl/src/model/CreateProjectRequest.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/nlp-automl/model/CreateProjectRequest.h>
+
+using AlibabaCloud::Nlp_automl::Model::CreateProjectRequest;
+
+CreateProjectRequest::CreateProjectRequest() :
+	RpcServiceRequest("nlp-automl", "2019-11-11", "CreateProject")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateProjectRequest::~CreateProjectRequest()
+{}
+
+std::string CreateProjectRequest::getProjectName()const
+{
+	return projectName_;
+}
+
+void CreateProjectRequest::setProjectName(const std::string& projectName)
+{
+	projectName_ = projectName;
+	setBodyParameter("ProjectName", projectName);
+}
+
+std::string CreateProjectRequest::getProduct()const
+{
+	return product_;
+}
+
+void CreateProjectRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setBodyParameter("Product", product);
+}
+
+std::string CreateProjectRequest::getProjectDescription()const
+{
+	return projectDescription_;
+}
+
+void CreateProjectRequest::setProjectDescription(const std::string& projectDescription)
+{
+	projectDescription_ = projectDescription;
+	setBodyParameter("ProjectDescription", projectDescription);
+}
+
+std::string CreateProjectRequest::getProjectType()const
+{
+	return projectType_;
+}
+
+void CreateProjectRequest::setProjectType(const std::string& projectType)
+{
+	projectType_ = projectType;
+	setBodyParameter("ProjectType", projectType);
+}
+

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

nlp-automl/src/model/DeleteModelRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/nlp-automl/model/DeleteModelRequest.h>
+
+using AlibabaCloud::Nlp_automl::Model::DeleteModelRequest;
+
+DeleteModelRequest::DeleteModelRequest() :
+	RpcServiceRequest("nlp-automl", "2019-11-11", "DeleteModel")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteModelRequest::~DeleteModelRequest()
+{}
+
+std::string DeleteModelRequest::getProduct()const
+{
+	return product_;
+}
+
+void DeleteModelRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setBodyParameter("Product", product);
+}
+
+long DeleteModelRequest::getModelId()const
+{
+	return modelId_;
+}
+
+void DeleteModelRequest::setModelId(long modelId)
+{
+	modelId_ = modelId;
+	setBodyParameter("ModelId", std::to_string(modelId));
+}
+
+long DeleteModelRequest::getProjectId()const
+{
+	return projectId_;
+}
+
+void DeleteModelRequest::setProjectId(long projectId)
+{
+	projectId_ = projectId;
+	setBodyParameter("ProjectId", std::to_string(projectId));
+}
+

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

nlp-automl/src/model/DeployModelRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/nlp-automl/model/DeployModelRequest.h>
+
+using AlibabaCloud::Nlp_automl::Model::DeployModelRequest;
+
+DeployModelRequest::DeployModelRequest() :
+	RpcServiceRequest("nlp-automl", "2019-11-11", "DeployModel")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeployModelRequest::~DeployModelRequest()
+{}
+
+std::string DeployModelRequest::getProduct()const
+{
+	return product_;
+}
+
+void DeployModelRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setBodyParameter("Product", product);
+}
+
+long DeployModelRequest::getModelId()const
+{
+	return modelId_;
+}
+
+void DeployModelRequest::setModelId(long modelId)
+{
+	modelId_ = modelId;
+	setBodyParameter("ModelId", std::to_string(modelId));
+}
+
+std::string DeployModelRequest::getOptType()const
+{
+	return optType_;
+}
+
+void DeployModelRequest::setOptType(const std::string& optType)
+{
+	optType_ = optType;
+	setBodyParameter("OptType", optType);
+}
+
+long DeployModelRequest::getProjectId()const
+{
+	return projectId_;
+}
+
+void DeployModelRequest::setProjectId(long projectId)
+{
+	projectId_ = projectId;
+	setBodyParameter("ProjectId", std::to_string(projectId));
+}
+
+std::string DeployModelRequest::getModelVersion()const
+{
+	return modelVersion_;
+}
+
+void DeployModelRequest::setModelVersion(const std::string& modelVersion)
+{
+	modelVersion_ = modelVersion;
+	setBodyParameter("ModelVersion", modelVersion);
+}
+

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

nlp-automl/src/model/GetAsyncPredictRequest.cc

@@ -27,6 +27,17 @@ GetAsyncPredictRequest::GetAsyncPredictRequest() :
 GetAsyncPredictRequest::~GetAsyncPredictRequest()
 {}
 
+std::string GetAsyncPredictRequest::getProduct()const
+{
+	return product_;
+}
+
+void GetAsyncPredictRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
 int GetAsyncPredictRequest::getAsyncPredictId()const
 {
 	return asyncPredictId_;

nlp-automl/src/model/GetModelRequest.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/nlp-automl/model/GetModelRequest.h>
+
+using AlibabaCloud::Nlp_automl::Model::GetModelRequest;
+
+GetModelRequest::GetModelRequest() :
+	RpcServiceRequest("nlp-automl", "2019-11-11", "GetModel")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetModelRequest::~GetModelRequest()
+{}
+
+std::string GetModelRequest::getProduct()const
+{
+	return product_;
+}
+
+void GetModelRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setBodyParameter("Product", product);
+}
+
+long GetModelRequest::getModelId()const
+{
+	return modelId_;
+}
+
+void GetModelRequest::setModelId(long modelId)
+{
+	modelId_ = modelId;
+	setBodyParameter("ModelId", std::to_string(modelId));
+}
+
+long GetModelRequest::getProjectId()const
+{
+	return projectId_;
+}
+
+void GetModelRequest::setProjectId(long projectId)
+{
+	projectId_ = projectId;
+	setBodyParameter("ProjectId", std::to_string(projectId));
+}
+
+std::string GetModelRequest::getModelVersion()const
+{
+	return modelVersion_;
+}
+
+void GetModelRequest::setModelVersion(const std::string& modelVersion)
+{
+	modelVersion_ = modelVersion;
+	setBodyParameter("ModelVersion", modelVersion);
+}
+

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

nlp-automl/src/model/GetPredictDocRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/nlp-automl/model/GetPredictDocRequest.h>
+
+using AlibabaCloud::Nlp_automl::Model::GetPredictDocRequest;
+
+GetPredictDocRequest::GetPredictDocRequest() :
+	RpcServiceRequest("nlp-automl", "2019-07-01", "GetPredictDoc")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetPredictDocRequest::~GetPredictDocRequest()
+{}
+
+std::string GetPredictDocRequest::getProduct()const
+{
+	return product_;
+}
+
+void GetPredictDocRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+long GetPredictDocRequest::getDocId()const
+{
+	return docId_;
+}
+
+void GetPredictDocRequest::setDocId(long docId)
+{
+	docId_ = docId;
+	setParameter("DocId", std::to_string(docId));
+}
+

nlp-automl/src/model/GetPredictDocResult.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/nlp-automl/model/GetPredictDocResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Nlp_automl;
+using namespace AlibabaCloud::Nlp_automl::Model;
+
+GetPredictDocResult::GetPredictDocResult() :
+	ServiceResult()
+{}
+
+GetPredictDocResult::GetPredictDocResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetPredictDocResult::~GetPredictDocResult()
+{}
+
+void GetPredictDocResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ResultContent"].isNull())
+		resultContent_ = value["ResultContent"].asString();
+	if(!value["Status"].isNull())
+		status_ = std::stoi(value["Status"].asString());
+	if(!value["XLIFFInfo"].isNull())
+		xLIFFInfo_ = value["XLIFFInfo"].asString();
+
+}
+
+int GetPredictDocResult::getStatus()const
+{
+	return status_;
+}
+
+std::string GetPredictDocResult::getXLIFFInfo()const
+{
+	return xLIFFInfo_;
+}
+
+std::string GetPredictDocResult::getResultContent()const
+{
+	return resultContent_;
+}
+

nlp-automl/src/model/GetPredictResultRequest.cc

@@ -38,6 +38,17 @@ void GetPredictResultRequest::setTopK(int topK)
 	setBodyParameter("TopK", std::to_string(topK));
 }
 
+std::string GetPredictResultRequest::getProduct()const
+{
+	return product_;
+}
+
+void GetPredictResultRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setBodyParameter("Product", product);
+}
+
 int GetPredictResultRequest::getModelId()const
 {
 	return modelId_;

nlp-automl/src/model/InvokeActionRequest.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/nlp-automl/model/InvokeActionRequest.h>
+
+using AlibabaCloud::Nlp_automl::Model::InvokeActionRequest;
+
+InvokeActionRequest::InvokeActionRequest() :
+	RpcServiceRequest("nlp-automl", "2019-07-01", "InvokeAction")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+InvokeActionRequest::~InvokeActionRequest()
+{}
+
+std::string InvokeActionRequest::getInvokeProduct()const
+{
+	return invokeProduct_;
+}
+
+void InvokeActionRequest::setInvokeProduct(const std::string& invokeProduct)
+{
+	invokeProduct_ = invokeProduct;
+	setParameter("InvokeProduct", invokeProduct);
+}
+
+std::string InvokeActionRequest::getInvokeAction()const
+{
+	return invokeAction_;
+}
+
+void InvokeActionRequest::setInvokeAction(const std::string& invokeAction)
+{
+	invokeAction_ = invokeAction;
+	setBodyParameter("InvokeAction", invokeAction);
+}
+
+std::string InvokeActionRequest::getInvokeParams()const
+{
+	return invokeParams_;
+}
+
+void InvokeActionRequest::setInvokeParams(const std::string& invokeParams)
+{
+	invokeParams_ = invokeParams;
+	setBodyParameter("InvokeParams", invokeParams);
+}
+
+std::string InvokeActionRequest::getInvokeRegion()const
+{
+	return invokeRegion_;
+}
+
+void InvokeActionRequest::setInvokeRegion(const std::string& invokeRegion)
+{
+	invokeRegion_ = invokeRegion;
+	setParameter("InvokeRegion", invokeRegion);
+}
+

nlp-automl/src/model/InvokeActionResult.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/nlp-automl/model/InvokeActionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Nlp_automl;
+using namespace AlibabaCloud::Nlp_automl::Model;
+
+InvokeActionResult::InvokeActionResult() :
+	ServiceResult()
+{}
+
+InvokeActionResult::InvokeActionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+InvokeActionResult::~InvokeActionResult()
+{}
+
+void InvokeActionResult::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["Message"].isNull())
+		message_ = std::stoi(value["Message"].asString());
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString();
+
+}
+
+int InvokeActionResult::getMessage()const
+{
+	return message_;
+}
+
+std::string InvokeActionResult::getData()const
+{
+	return data_;
+}
+
+int InvokeActionResult::getCode()const
+{
+	return code_;
+}
+

nlp-automl/src/model/ListDatasetRequest.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/nlp-automl/model/ListDatasetRequest.h>
+
+using AlibabaCloud::Nlp_automl::Model::ListDatasetRequest;
+
+ListDatasetRequest::ListDatasetRequest() :
+	RpcServiceRequest("nlp-automl", "2019-11-11", "ListDataset")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListDatasetRequest::~ListDatasetRequest()
+{}
+
+std::string ListDatasetRequest::getProduct()const
+{
+	return product_;
+}
+
+void ListDatasetRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setBodyParameter("Product", product);
+}
+
+int ListDatasetRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListDatasetRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setBodyParameter("PageNumber", std::to_string(pageNumber));
+}
+
+int ListDatasetRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListDatasetRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setBodyParameter("PageSize", std::to_string(pageSize));
+}
+
+long ListDatasetRequest::getProjectId()const
+{
+	return projectId_;
+}
+
+void ListDatasetRequest::setProjectId(long projectId)
+{
+	projectId_ = projectId;
+	setBodyParameter("ProjectId", std::to_string(projectId));
+}
+

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

nlp-automl/src/model/ListModelsRequest.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/nlp-automl/model/ListModelsRequest.h>
+
+using AlibabaCloud::Nlp_automl::Model::ListModelsRequest;
+
+ListModelsRequest::ListModelsRequest() :
+	RpcServiceRequest("nlp-automl", "2019-11-11", "ListModels")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListModelsRequest::~ListModelsRequest()
+{}
+
+std::string ListModelsRequest::getProduct()const
+{
+	return product_;
+}
+
+void ListModelsRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setBodyParameter("Product", product);
+}
+
+int ListModelsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListModelsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setBodyParameter("PageNumber", std::to_string(pageNumber));
+}
+
+int ListModelsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListModelsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setBodyParameter("PageSize", std::to_string(pageSize));
+}
+
+long ListModelsRequest::getProjectId()const
+{
+	return projectId_;
+}
+
+void ListModelsRequest::setProjectId(long projectId)
+{
+	projectId_ = projectId;
+	setBodyParameter("ProjectId", std::to_string(projectId));
+}
+

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

nlp-automl/src/model/PredictMTModelByDocRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/nlp-automl/model/PredictMTModelByDocRequest.h>
+
+using AlibabaCloud::Nlp_automl::Model::PredictMTModelByDocRequest;
+
+PredictMTModelByDocRequest::PredictMTModelByDocRequest() :
+	RpcServiceRequest("nlp-automl", "2019-07-01", "PredictMTModelByDoc")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+PredictMTModelByDocRequest::~PredictMTModelByDocRequest()
+{}
+
+std::string PredictMTModelByDocRequest::getFileType()const
+{
+	return fileType_;
+}
+
+void PredictMTModelByDocRequest::setFileType(const std::string& fileType)
+{
+	fileType_ = fileType;
+	setParameter("FileType", fileType);
+}
+
+std::string PredictMTModelByDocRequest::getProduct()const
+{
+	return product_;
+}
+
+void PredictMTModelByDocRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+int PredictMTModelByDocRequest::getModelId()const
+{
+	return modelId_;
+}
+
+void PredictMTModelByDocRequest::setModelId(int modelId)
+{
+	modelId_ = modelId;
+	setParameter("ModelId", std::to_string(modelId));
+}
+
+std::string PredictMTModelByDocRequest::getFileContent()const
+{
+	return fileContent_;
+}
+
+void PredictMTModelByDocRequest::setFileContent(const std::string& fileContent)
+{
+	fileContent_ = fileContent;
+	setBodyParameter("FileContent", fileContent);
+}
+
+bool PredictMTModelByDocRequest::getNeedXLIFF()const
+{
+	return needXLIFF_;
+}
+
+void PredictMTModelByDocRequest::setNeedXLIFF(bool needXLIFF)
+{
+	needXLIFF_ = needXLIFF;
+	setParameter("NeedXLIFF", needXLIFF ? "true" : "false");
+}
+
+std::string PredictMTModelByDocRequest::getModelVersion()const
+{
+	return modelVersion_;
+}
+
+void PredictMTModelByDocRequest::setModelVersion(const std::string& modelVersion)
+{
+	modelVersion_ = modelVersion;
+	setParameter("ModelVersion", modelVersion);
+}
+

nlp-automl/src/model/PredictMTModelByDocResult.cc

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

nlp-automl/src/model/PredictMTModelRequest.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/nlp-automl/model/PredictMTModelRequest.h>
+
+using AlibabaCloud::Nlp_automl::Model::PredictMTModelRequest;
+
+PredictMTModelRequest::PredictMTModelRequest() :
+	RpcServiceRequest("nlp-automl", "2019-07-01", "PredictMTModel")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+PredictMTModelRequest::~PredictMTModelRequest()
+{}
+
+std::string PredictMTModelRequest::getProduct()const
+{
+	return product_;
+}
+
+void PredictMTModelRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string PredictMTModelRequest::getModelId()const
+{
+	return modelId_;
+}
+
+void PredictMTModelRequest::setModelId(const std::string& modelId)
+{
+	modelId_ = modelId;
+	setParameter("ModelId", modelId);
+}
+
+std::string PredictMTModelRequest::getContent()const
+{
+	return content_;
+}
+
+void PredictMTModelRequest::setContent(const std::string& content)
+{
+	content_ = content;
+	setBodyParameter("Content", content);
+}
+
+std::string PredictMTModelRequest::getModelVersion()const
+{
+	return modelVersion_;
+}
+
+void PredictMTModelRequest::setModelVersion(const std::string& modelVersion)
+{
+	modelVersion_ = modelVersion;
+	setParameter("ModelVersion", modelVersion);
+}
+

nlp-automl/src/model/PredictMTModelResult.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/nlp-automl/model/PredictMTModelResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Nlp_automl;
+using namespace AlibabaCloud::Nlp_automl::Model;
+
+PredictMTModelResult::PredictMTModelResult() :
+	ServiceResult()
+{}
+
+PredictMTModelResult::PredictMTModelResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+PredictMTModelResult::~PredictMTModelResult()
+{}
+
+void PredictMTModelResult::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["Message"].isNull())
+		message_ = std::stoi(value["Message"].asString());
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString();
+
+}
+
+int PredictMTModelResult::getMessage()const
+{
+	return message_;
+}
+
+std::string PredictMTModelResult::getData()const
+{
+	return data_;
+}
+
+int PredictMTModelResult::getCode()const
+{
+	return code_;
+}
+

nlp-automl/src/model/RunContactReviewRequest.cc

@@ -27,6 +27,17 @@ RunContactReviewRequest::RunContactReviewRequest() :
 RunContactReviewRequest::~RunContactReviewRequest()
 {}
 
+std::string RunContactReviewRequest::getProduct()const
+{
+	return product_;
+}
+
+void RunContactReviewRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setBodyParameter("Product", product);
+}
+
 std::string RunContactReviewRequest::getContactScene()const
 {
 	return contactScene_;

nlp-automl/src/model/RunPreTrainServiceRequest.cc

@@ -27,6 +27,17 @@ RunPreTrainServiceRequest::RunPreTrainServiceRequest() :
 RunPreTrainServiceRequest::~RunPreTrainServiceRequest()
 {}
 
+std::string RunPreTrainServiceRequest::getProduct()const
+{
+	return product_;
+}
+
+void RunPreTrainServiceRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setBodyParameter("Product", product);
+}
+
 std::string RunPreTrainServiceRequest::getPredictContent()const
 {
 	return predictContent_;

nlp-automl/src/model/RunSmartCallServiceRequest.cc

@@ -27,6 +27,17 @@ RunSmartCallServiceRequest::RunSmartCallServiceRequest() :
 RunSmartCallServiceRequest::~RunSmartCallServiceRequest()
 {}
 
+std::string RunSmartCallServiceRequest::getProduct()const
+{
+	return product_;
+}
+
+void RunSmartCallServiceRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setBodyParameter("Product", product);
+}
+
 std::string RunSmartCallServiceRequest::getSessionId()const
 {
 	return sessionId_;