Generated 2021-01-01 for Ft.

VERSION

@@ -1 +1 @@
-1.36.1735
+1.36.1736

ft/CMakeLists.txt

@@ -21,21 +21,33 @@ set(ft_public_header
 	include/alibabacloud/ft/FtExport.h )
 
 set(ft_public_header_model 
-	include/alibabacloud/ft/model/CreateInsRequest.h
+	include/alibabacloud/ft/model/DataRateLimitTestRequest.h
-	include/alibabacloud/ft/model/CreateInsResult.h
+	include/alibabacloud/ft/model/DataRateLimitTestResult.h
-	include/alibabacloud/ft/model/RpcNoDefaultErrorCodeApiRequest.h
+	include/alibabacloud/ft/model/NormalRpcHsfApiRequest.h
-	include/alibabacloud/ft/model/RpcNoDefaultErrorCodeApiResult.h
+	include/alibabacloud/ft/model/NormalRpcHsfApiResult.h
-	include/alibabacloud/ft/model/UpdateInsRequest.h
+	include/alibabacloud/ft/model/NormalRpcHttpApiRequest.h
-	include/alibabacloud/ft/model/UpdateInsResult.h )
+	include/alibabacloud/ft/model/NormalRpcHttpApiResult.h
+	include/alibabacloud/ft/model/RpcDataUploadRequest.h
+	include/alibabacloud/ft/model/RpcDataUploadResult.h
+	include/alibabacloud/ft/model/RpcDataUploadAndDownloadRequest.h
+	include/alibabacloud/ft/model/RpcDataUploadAndDownloadResult.h
+	include/alibabacloud/ft/model/RpcDataUploadTestRequest.h
+	include/alibabacloud/ft/model/RpcDataUploadTestResult.h )
 
 set(ft_src 
 	src/FtClient.cc
-	src/model/CreateInsRequest.cc
+	src/model/DataRateLimitTestRequest.cc
-	src/model/CreateInsResult.cc
+	src/model/DataRateLimitTestResult.cc
-	src/model/RpcNoDefaultErrorCodeApiRequest.cc
+	src/model/NormalRpcHsfApiRequest.cc
-	src/model/RpcNoDefaultErrorCodeApiResult.cc
+	src/model/NormalRpcHsfApiResult.cc
-	src/model/UpdateInsRequest.cc
+	src/model/NormalRpcHttpApiRequest.cc
-	src/model/UpdateInsResult.cc )
+	src/model/NormalRpcHttpApiResult.cc
+	src/model/RpcDataUploadRequest.cc
+	src/model/RpcDataUploadResult.cc
+	src/model/RpcDataUploadAndDownloadRequest.cc
+	src/model/RpcDataUploadAndDownloadResult.cc
+	src/model/RpcDataUploadTestRequest.cc
+	src/model/RpcDataUploadTestResult.cc )
 
 add_library(ft ${LIB_TYPE}
 	${ft_public_header}

ft/include/alibabacloud/ft/FtClient.h

@@ -22,12 +22,18 @@
 #include <alibabacloud/core/EndpointProvider.h>
 #include <alibabacloud/core/RpcServiceClient.h>
 #include "FtExport.h"
-#include "model/CreateInsRequest.h"
+#include "model/DataRateLimitTestRequest.h"
-#include "model/CreateInsResult.h"
+#include "model/DataRateLimitTestResult.h"
-#include "model/RpcNoDefaultErrorCodeApiRequest.h"
+#include "model/NormalRpcHsfApiRequest.h"
-#include "model/RpcNoDefaultErrorCodeApiResult.h"
+#include "model/NormalRpcHsfApiResult.h"
-#include "model/UpdateInsRequest.h"
+#include "model/NormalRpcHttpApiRequest.h"
-#include "model/UpdateInsResult.h"
+#include "model/NormalRpcHttpApiResult.h"
+#include "model/RpcDataUploadRequest.h"
+#include "model/RpcDataUploadResult.h"
+#include "model/RpcDataUploadAndDownloadRequest.h"
+#include "model/RpcDataUploadAndDownloadResult.h"
+#include "model/RpcDataUploadTestRequest.h"
+#include "model/RpcDataUploadTestResult.h"
 
 
 namespace AlibabaCloud
@@ -37,29 +43,47 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_FT_EXPORT FtClient : public RpcServiceClient
 		{
 		public:
-			typedef Outcome<Error, Model::CreateInsResult> CreateInsOutcome;
+			typedef Outcome<Error, Model::DataRateLimitTestResult> DataRateLimitTestOutcome;
-			typedef std::future<CreateInsOutcome> CreateInsOutcomeCallable;
+			typedef std::future<DataRateLimitTestOutcome> DataRateLimitTestOutcomeCallable;
-			typedef std::function<void(const FtClient*, const Model::CreateInsRequest&, const CreateInsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateInsAsyncHandler;
+			typedef std::function<void(const FtClient*, const Model::DataRateLimitTestRequest&, const DataRateLimitTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DataRateLimitTestAsyncHandler;
-			typedef Outcome<Error, Model::RpcNoDefaultErrorCodeApiResult> RpcNoDefaultErrorCodeApiOutcome;
+			typedef Outcome<Error, Model::NormalRpcHsfApiResult> NormalRpcHsfApiOutcome;
-			typedef std::future<RpcNoDefaultErrorCodeApiOutcome> RpcNoDefaultErrorCodeApiOutcomeCallable;
+			typedef std::future<NormalRpcHsfApiOutcome> NormalRpcHsfApiOutcomeCallable;
-			typedef std::function<void(const FtClient*, const Model::RpcNoDefaultErrorCodeApiRequest&, const RpcNoDefaultErrorCodeApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RpcNoDefaultErrorCodeApiAsyncHandler;
+			typedef std::function<void(const FtClient*, const Model::NormalRpcHsfApiRequest&, const NormalRpcHsfApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> NormalRpcHsfApiAsyncHandler;
-			typedef Outcome<Error, Model::UpdateInsResult> UpdateInsOutcome;
+			typedef Outcome<Error, Model::NormalRpcHttpApiResult> NormalRpcHttpApiOutcome;
-			typedef std::future<UpdateInsOutcome> UpdateInsOutcomeCallable;
+			typedef std::future<NormalRpcHttpApiOutcome> NormalRpcHttpApiOutcomeCallable;
-			typedef std::function<void(const FtClient*, const Model::UpdateInsRequest&, const UpdateInsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateInsAsyncHandler;
+			typedef std::function<void(const FtClient*, const Model::NormalRpcHttpApiRequest&, const NormalRpcHttpApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> NormalRpcHttpApiAsyncHandler;
+			typedef Outcome<Error, Model::RpcDataUploadResult> RpcDataUploadOutcome;
+			typedef std::future<RpcDataUploadOutcome> RpcDataUploadOutcomeCallable;
+			typedef std::function<void(const FtClient*, const Model::RpcDataUploadRequest&, const RpcDataUploadOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RpcDataUploadAsyncHandler;
+			typedef Outcome<Error, Model::RpcDataUploadAndDownloadResult> RpcDataUploadAndDownloadOutcome;
+			typedef std::future<RpcDataUploadAndDownloadOutcome> RpcDataUploadAndDownloadOutcomeCallable;
+			typedef std::function<void(const FtClient*, const Model::RpcDataUploadAndDownloadRequest&, const RpcDataUploadAndDownloadOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RpcDataUploadAndDownloadAsyncHandler;
+			typedef Outcome<Error, Model::RpcDataUploadTestResult> RpcDataUploadTestOutcome;
+			typedef std::future<RpcDataUploadTestOutcome> RpcDataUploadTestOutcomeCallable;
+			typedef std::function<void(const FtClient*, const Model::RpcDataUploadTestRequest&, const RpcDataUploadTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RpcDataUploadTestAsyncHandler;
 
 			FtClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			FtClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
 			FtClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
 			~FtClient();
-			CreateInsOutcome createIns(const Model::CreateInsRequest &request)const;
+			DataRateLimitTestOutcome dataRateLimitTest(const Model::DataRateLimitTestRequest &request)const;
-			void createInsAsync(const Model::CreateInsRequest& request, const CreateInsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			void dataRateLimitTestAsync(const Model::DataRateLimitTestRequest& request, const DataRateLimitTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateInsOutcomeCallable createInsCallable(const Model::CreateInsRequest& request) const;
+			DataRateLimitTestOutcomeCallable dataRateLimitTestCallable(const Model::DataRateLimitTestRequest& request) const;
-			RpcNoDefaultErrorCodeApiOutcome rpcNoDefaultErrorCodeApi(const Model::RpcNoDefaultErrorCodeApiRequest &request)const;
+			NormalRpcHsfApiOutcome normalRpcHsfApi(const Model::NormalRpcHsfApiRequest &request)const;
-			void rpcNoDefaultErrorCodeApiAsync(const Model::RpcNoDefaultErrorCodeApiRequest& request, const RpcNoDefaultErrorCodeApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			void normalRpcHsfApiAsync(const Model::NormalRpcHsfApiRequest& request, const NormalRpcHsfApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			RpcNoDefaultErrorCodeApiOutcomeCallable rpcNoDefaultErrorCodeApiCallable(const Model::RpcNoDefaultErrorCodeApiRequest& request) const;
+			NormalRpcHsfApiOutcomeCallable normalRpcHsfApiCallable(const Model::NormalRpcHsfApiRequest& request) const;
-			UpdateInsOutcome updateIns(const Model::UpdateInsRequest &request)const;
+			NormalRpcHttpApiOutcome normalRpcHttpApi(const Model::NormalRpcHttpApiRequest &request)const;
-			void updateInsAsync(const Model::UpdateInsRequest& request, const UpdateInsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			void normalRpcHttpApiAsync(const Model::NormalRpcHttpApiRequest& request, const NormalRpcHttpApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			UpdateInsOutcomeCallable updateInsCallable(const Model::UpdateInsRequest& request) const;
+			NormalRpcHttpApiOutcomeCallable normalRpcHttpApiCallable(const Model::NormalRpcHttpApiRequest& request) const;
+			RpcDataUploadOutcome rpcDataUpload(const Model::RpcDataUploadRequest &request)const;
+			void rpcDataUploadAsync(const Model::RpcDataUploadRequest& request, const RpcDataUploadAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RpcDataUploadOutcomeCallable rpcDataUploadCallable(const Model::RpcDataUploadRequest& request) const;
+			RpcDataUploadAndDownloadOutcome rpcDataUploadAndDownload(const Model::RpcDataUploadAndDownloadRequest &request)const;
+			void rpcDataUploadAndDownloadAsync(const Model::RpcDataUploadAndDownloadRequest& request, const RpcDataUploadAndDownloadAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RpcDataUploadAndDownloadOutcomeCallable rpcDataUploadAndDownloadCallable(const Model::RpcDataUploadAndDownloadRequest& request) const;
+			RpcDataUploadTestOutcome rpcDataUploadTest(const Model::RpcDataUploadTestRequest &request)const;
+			void rpcDataUploadTestAsync(const Model::RpcDataUploadTestRequest& request, const RpcDataUploadTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RpcDataUploadTestOutcomeCallable rpcDataUploadTestCallable(const Model::RpcDataUploadTestRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

ft/include/alibabacloud/ft/model/DataRateLimitTestRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_FT_MODEL_CREATEINSREQUEST_H_
+#ifndef ALIBABACLOUD_FT_MODEL_DATARATELIMITTESTREQUEST_H_
-#define ALIBABACLOUD_FT_MODEL_CREATEINSREQUEST_H_
+#define ALIBABACLOUD_FT_MODEL_DATARATELIMITTESTREQUEST_H_
 
 #include <alibabacloud/ft/FtExport.h>
 #include <alibabacloud/core/RpcServiceRequest.h>
@@ -26,32 +26,26 @@
 namespace AlibabaCloud {
 namespace Ft {
 namespace Model {
-class ALIBABACLOUD_FT_EXPORT CreateInsRequest : public RpcServiceRequest {
+class ALIBABACLOUD_FT_EXPORT DataRateLimitTestRequest : public RpcServiceRequest {
 public:
-	CreateInsRequest();
+	DataRateLimitTestRequest();
-	~CreateInsRequest();
+	~DataRateLimitTestRequest();
+	std::string getNewparam2() const;
+	void setNewparam2(const std::string &newparam2);
 	std::string getNewparam1() const;
 	void setNewparam1(const std::string &newparam1);
-	std::string getBind() const;
+	std::string getData() const;
-	void setBind(const std::string &bind);
+	void setData(const std::string &data);
-	std::string getTest() const;
+	std::string getMap() const;
-	void setTest(const std::string &test);
+	void setMap(const std::string &map);
-	std::string getSuccess() const;
-	void setSuccess(const std::string &success);
-	std::string getTime() const;
-	void setTime(const std::string &time);
-	std::string getNewPala() const;
-	void setNewPala(const std::string &newPala);
 
 private:
+	std::string newparam2_;
 	std::string newparam1_;
-	std::string bind_;
+	std::string data_;
-	std::string test_;
+	std::string map_;
-	std::string success_;
-	std::string time_;
-	std::string newPala_;
 };
 } // namespace Model
 } // namespace Ft
 } // namespace AlibabaCloud
-#endif // !ALIBABACLOUD_FT_MODEL_CREATEINSREQUEST_H_
+#endif // !ALIBABACLOUD_FT_MODEL_DATARATELIMITTESTREQUEST_H_

ft/include/alibabacloud/ft/model/DataRateLimitTestResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_FT_MODEL_UPDATEINSRESULT_H_
+#ifndef ALIBABACLOUD_FT_MODEL_DATARATELIMITTESTRESULT_H_
-#define ALIBABACLOUD_FT_MODEL_UPDATEINSRESULT_H_
+#define ALIBABACLOUD_FT_MODEL_DATARATELIMITTESTRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,25 +29,21 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_FT_EXPORT UpdateInsResult : public ServiceResult
+			class ALIBABACLOUD_FT_EXPORT DataRateLimitTestResult : public ServiceResult
 			{
 			public:
 
 
-				UpdateInsResult();
+				DataRateLimitTestResult();
-				explicit UpdateInsResult(const std::string &payload);
+				explicit DataRateLimitTestResult(const std::string &payload);
-				~UpdateInsResult();
+				~DataRateLimitTestResult();
-				std::string getCode()const;
-				std::string getSuccess()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string code_;
-				std::string success_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_FT_MODEL_UPDATEINSRESULT_H_
+#endif // !ALIBABACLOUD_FT_MODEL_DATARATELIMITTESTRESULT_H_

ft/include/alibabacloud/ft/model/NormalRpcHsfApiRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_FT_MODEL_UPDATEINSREQUEST_H_
+#ifndef ALIBABACLOUD_FT_MODEL_NORMALRPCHSFAPIREQUEST_H_
-#define ALIBABACLOUD_FT_MODEL_UPDATEINSREQUEST_H_
+#define ALIBABACLOUD_FT_MODEL_NORMALRPCHSFAPIREQUEST_H_
 
 #include <alibabacloud/ft/FtExport.h>
 #include <alibabacloud/core/RpcServiceRequest.h>
@@ -26,20 +26,14 @@
 namespace AlibabaCloud {
 namespace Ft {
 namespace Model {
-class ALIBABACLOUD_FT_EXPORT UpdateInsRequest : public RpcServiceRequest {
+class ALIBABACLOUD_FT_EXPORT NormalRpcHsfApiRequest : public RpcServiceRequest {
 public:
-	UpdateInsRequest();
+	NormalRpcHsfApiRequest();
-	~UpdateInsRequest();
+	~NormalRpcHsfApiRequest();
-	std::string getSucceed() const;
-	void setSucceed(const std::string &succeed);
-	std::string getHttpStatusCode1() const;
-	void setHttpStatusCode1(const std::string &httpStatusCode1);
 
 private:
-	std::string succeed_;
-	std::string httpStatusCode1_;
 };
 } // namespace Model
 } // namespace Ft
 } // namespace AlibabaCloud
-#endif // !ALIBABACLOUD_FT_MODEL_UPDATEINSREQUEST_H_
+#endif // !ALIBABACLOUD_FT_MODEL_NORMALRPCHSFAPIREQUEST_H_

ft/include/alibabacloud/ft/model/NormalRpcHsfApiResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_FT_MODEL_CREATEINSRESULT_H_
+#ifndef ALIBABACLOUD_FT_MODEL_NORMALRPCHSFAPIRESULT_H_
-#define ALIBABACLOUD_FT_MODEL_CREATEINSRESULT_H_
+#define ALIBABACLOUD_FT_MODEL_NORMALRPCHSFAPIRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,25 +29,21 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_FT_EXPORT CreateInsResult : public ServiceResult
+			class ALIBABACLOUD_FT_EXPORT NormalRpcHsfApiResult : public ServiceResult
 			{
 			public:
 
 
-				CreateInsResult();
+				NormalRpcHsfApiResult();
-				explicit CreateInsResult(const std::string &payload);
+				explicit NormalRpcHsfApiResult(const std::string &payload);
-				~CreateInsResult();
+				~NormalRpcHsfApiResult();
-				std::string getCode()const;
-				std::string getSuccess()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string code_;
-				std::string success_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_FT_MODEL_CREATEINSRESULT_H_
+#endif // !ALIBABACLOUD_FT_MODEL_NORMALRPCHSFAPIRESULT_H_

ft/include/alibabacloud/ft/model/NormalRpcHttpApiRequest.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_FT_MODEL_NORMALRPCHTTPAPIREQUEST_H_
+#define ALIBABACLOUD_FT_MODEL_NORMALRPCHTTPAPIREQUEST_H_
+
+#include <alibabacloud/ft/FtExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ft {
+namespace Model {
+class ALIBABACLOUD_FT_EXPORT NormalRpcHttpApiRequest : public RpcServiceRequest {
+public:
+	NormalRpcHttpApiRequest();
+	~NormalRpcHttpApiRequest();
+
+private:
+};
+} // namespace Model
+} // namespace Ft
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_FT_MODEL_NORMALRPCHTTPAPIREQUEST_H_

ft/include/alibabacloud/ft/model/NormalRpcHttpApiResult.h

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

ft/include/alibabacloud/ft/model/RpcDataUploadAndDownloadRequest.h

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

ft/include/alibabacloud/ft/model/RpcDataUploadAndDownloadResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_FT_MODEL_RPCNODEFAULTERRORCODEAPIRESULT_H_
+#ifndef ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADANDDOWNLOADRESULT_H_
-#define ALIBABACLOUD_FT_MODEL_RPCNODEFAULTERRORCODEAPIRESULT_H_
+#define ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADANDDOWNLOADRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,25 +29,21 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_FT_EXPORT RpcNoDefaultErrorCodeApiResult : public ServiceResult
+			class ALIBABACLOUD_FT_EXPORT RpcDataUploadAndDownloadResult : public ServiceResult
 			{
 			public:
 
 
-				RpcNoDefaultErrorCodeApiResult();
+				RpcDataUploadAndDownloadResult();
-				explicit RpcNoDefaultErrorCodeApiResult(const std::string &payload);
+				explicit RpcDataUploadAndDownloadResult(const std::string &payload);
-				~RpcNoDefaultErrorCodeApiResult();
+				~RpcDataUploadAndDownloadResult();
-				std::string getCode()const;
-				std::string getSuccess()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string code_;
-				std::string success_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_FT_MODEL_RPCNODEFAULTERRORCODEAPIRESULT_H_
+#endif // !ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADANDDOWNLOADRESULT_H_

ft/include/alibabacloud/ft/model/RpcDataUploadRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADREQUEST_H_
+#define ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADREQUEST_H_
+
+#include <alibabacloud/ft/FtExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ft {
+namespace Model {
+class ALIBABACLOUD_FT_EXPORT RpcDataUploadRequest : public RpcServiceRequest {
+public:
+	RpcDataUploadRequest();
+	~RpcDataUploadRequest();
+	std::string getQuery1() const;
+	void setQuery1(const std::string &query1);
+	long getQuery2() const;
+	void setQuery2(long query2);
+	std::string getLargeParam() const;
+	void setLargeParam(const std::string &largeParam);
+
+private:
+	std::string query1_;
+	long query2_;
+	std::string largeParam_;
+};
+} // namespace Model
+} // namespace Ft
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADREQUEST_H_

ft/include/alibabacloud/ft/model/RpcDataUploadResult.h

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

ft/include/alibabacloud/ft/model/RpcDataUploadTestRequest.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_FT_MODEL_RPCDATAUPLOADTESTREQUEST_H_
+#define ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADTESTREQUEST_H_
+
+#include <alibabacloud/ft/FtExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ft {
+namespace Model {
+class ALIBABACLOUD_FT_EXPORT RpcDataUploadTestRequest : public RpcServiceRequest {
+public:
+	RpcDataUploadTestRequest();
+	~RpcDataUploadTestRequest();
+
+private:
+};
+} // namespace Model
+} // namespace Ft
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_FT_MODEL_RPCDATAUPLOADTESTREQUEST_H_

ft/include/alibabacloud/ft/model/RpcDataUploadTestResult.h

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

ft/include/alibabacloud/ft/model/RpcNoDefaultErrorCodeApiRequest.h

@@ -1,57 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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_FT_MODEL_RPCNODEFAULTERRORCODEAPIREQUEST_H_
-#define ALIBABACLOUD_FT_MODEL_RPCNODEFAULTERRORCODEAPIREQUEST_H_
-
-#include <alibabacloud/ft/FtExport.h>
-#include <alibabacloud/core/RpcServiceRequest.h>
-#include <string>
-#include <vector>
-#include <map>
-
-namespace AlibabaCloud {
-namespace Ft {
-namespace Model {
-class ALIBABACLOUD_FT_EXPORT RpcNoDefaultErrorCodeApiRequest : public RpcServiceRequest {
-public:
-	RpcNoDefaultErrorCodeApiRequest();
-	~RpcNoDefaultErrorCodeApiRequest();
-	std::string getHttpMe() const;
-	void setHttpMe(const std::string &httpMe);
-	std::string getHttpStatusCode() const;
-	void setHttpStatusCode(const std::string &httpStatusCode);
-	std::string getSetUser() const;
-	void setSetUser(const std::string &setUser);
-	std::string getCode() const;
-	void setCode(const std::string &code);
-	std::string getSuccess() const;
-	void setSuccess(const std::string &success);
-	std::string getMessage() const;
-	void setMessage(const std::string &message);
-
-private:
-	std::string httpMe_;
-	std::string httpStatusCode_;
-	std::string setUser_;
-	std::string code_;
-	std::string success_;
-	std::string message_;
-};
-} // namespace Model
-} // namespace Ft
-} // namespace AlibabaCloud
-#endif // !ALIBABACLOUD_FT_MODEL_RPCNODEFAULTERRORCODEAPIREQUEST_H_

ft/src/FtClient.cc

@@ -51,108 +51,216 @@ FtClient::FtClient(const std::string & accessKeyId, const std::string & accessKe
 FtClient::~FtClient()
 {}
 
-FtClient::CreateInsOutcome FtClient::createIns(const CreateInsRequest &request) const
+FtClient::DataRateLimitTestOutcome FtClient::dataRateLimitTest(const DataRateLimitTestRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return CreateInsOutcome(endpointOutcome.error());
+		return DataRateLimitTestOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return CreateInsOutcome(CreateInsResult(outcome.result()));
+		return DataRateLimitTestOutcome(DataRateLimitTestResult(outcome.result()));
 	else
-		return CreateInsOutcome(outcome.error());
+		return DataRateLimitTestOutcome(outcome.error());
 }
 
-void FtClient::createInsAsync(const CreateInsRequest& request, const CreateInsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void FtClient::dataRateLimitTestAsync(const DataRateLimitTestRequest& request, const DataRateLimitTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, createIns(request), context);
+		handler(this, request, dataRateLimitTest(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-FtClient::CreateInsOutcomeCallable FtClient::createInsCallable(const CreateInsRequest &request) const
+FtClient::DataRateLimitTestOutcomeCallable FtClient::dataRateLimitTestCallable(const DataRateLimitTestRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<CreateInsOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<DataRateLimitTestOutcome()>>(
 			[this, request]()
 			{
-			return this->createIns(request);
+			return this->dataRateLimitTest(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-FtClient::RpcNoDefaultErrorCodeApiOutcome FtClient::rpcNoDefaultErrorCodeApi(const RpcNoDefaultErrorCodeApiRequest &request) const
+FtClient::NormalRpcHsfApiOutcome FtClient::normalRpcHsfApi(const NormalRpcHsfApiRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return RpcNoDefaultErrorCodeApiOutcome(endpointOutcome.error());
+		return NormalRpcHsfApiOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return RpcNoDefaultErrorCodeApiOutcome(RpcNoDefaultErrorCodeApiResult(outcome.result()));
+		return NormalRpcHsfApiOutcome(NormalRpcHsfApiResult(outcome.result()));
 	else
-		return RpcNoDefaultErrorCodeApiOutcome(outcome.error());
+		return NormalRpcHsfApiOutcome(outcome.error());
 }
 
-void FtClient::rpcNoDefaultErrorCodeApiAsync(const RpcNoDefaultErrorCodeApiRequest& request, const RpcNoDefaultErrorCodeApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void FtClient::normalRpcHsfApiAsync(const NormalRpcHsfApiRequest& request, const NormalRpcHsfApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, rpcNoDefaultErrorCodeApi(request), context);
+		handler(this, request, normalRpcHsfApi(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-FtClient::RpcNoDefaultErrorCodeApiOutcomeCallable FtClient::rpcNoDefaultErrorCodeApiCallable(const RpcNoDefaultErrorCodeApiRequest &request) const
+FtClient::NormalRpcHsfApiOutcomeCallable FtClient::normalRpcHsfApiCallable(const NormalRpcHsfApiRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<RpcNoDefaultErrorCodeApiOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<NormalRpcHsfApiOutcome()>>(
 			[this, request]()
 			{
-			return this->rpcNoDefaultErrorCodeApi(request);
+			return this->normalRpcHsfApi(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-FtClient::UpdateInsOutcome FtClient::updateIns(const UpdateInsRequest &request) const
+FtClient::NormalRpcHttpApiOutcome FtClient::normalRpcHttpApi(const NormalRpcHttpApiRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return UpdateInsOutcome(endpointOutcome.error());
+		return NormalRpcHttpApiOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return UpdateInsOutcome(UpdateInsResult(outcome.result()));
+		return NormalRpcHttpApiOutcome(NormalRpcHttpApiResult(outcome.result()));
 	else
-		return UpdateInsOutcome(outcome.error());
+		return NormalRpcHttpApiOutcome(outcome.error());
 }
 
-void FtClient::updateInsAsync(const UpdateInsRequest& request, const UpdateInsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void FtClient::normalRpcHttpApiAsync(const NormalRpcHttpApiRequest& request, const NormalRpcHttpApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, updateIns(request), context);
+		handler(this, request, normalRpcHttpApi(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-FtClient::UpdateInsOutcomeCallable FtClient::updateInsCallable(const UpdateInsRequest &request) const
+FtClient::NormalRpcHttpApiOutcomeCallable FtClient::normalRpcHttpApiCallable(const NormalRpcHttpApiRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<UpdateInsOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<NormalRpcHttpApiOutcome()>>(
 			[this, request]()
 			{
-			return this->updateIns(request);
+			return this->normalRpcHttpApi(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FtClient::RpcDataUploadOutcome FtClient::rpcDataUpload(const RpcDataUploadRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RpcDataUploadOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RpcDataUploadOutcome(RpcDataUploadResult(outcome.result()));
+	else
+		return RpcDataUploadOutcome(outcome.error());
+}
+
+void FtClient::rpcDataUploadAsync(const RpcDataUploadRequest& request, const RpcDataUploadAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, rpcDataUpload(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FtClient::RpcDataUploadOutcomeCallable FtClient::rpcDataUploadCallable(const RpcDataUploadRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RpcDataUploadOutcome()>>(
+			[this, request]()
+			{
+			return this->rpcDataUpload(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FtClient::RpcDataUploadAndDownloadOutcome FtClient::rpcDataUploadAndDownload(const RpcDataUploadAndDownloadRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RpcDataUploadAndDownloadOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RpcDataUploadAndDownloadOutcome(RpcDataUploadAndDownloadResult(outcome.result()));
+	else
+		return RpcDataUploadAndDownloadOutcome(outcome.error());
+}
+
+void FtClient::rpcDataUploadAndDownloadAsync(const RpcDataUploadAndDownloadRequest& request, const RpcDataUploadAndDownloadAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, rpcDataUploadAndDownload(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FtClient::RpcDataUploadAndDownloadOutcomeCallable FtClient::rpcDataUploadAndDownloadCallable(const RpcDataUploadAndDownloadRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RpcDataUploadAndDownloadOutcome()>>(
+			[this, request]()
+			{
+			return this->rpcDataUploadAndDownload(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FtClient::RpcDataUploadTestOutcome FtClient::rpcDataUploadTest(const RpcDataUploadTestRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RpcDataUploadTestOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RpcDataUploadTestOutcome(RpcDataUploadTestResult(outcome.result()));
+	else
+		return RpcDataUploadTestOutcome(outcome.error());
+}
+
+void FtClient::rpcDataUploadTestAsync(const RpcDataUploadTestRequest& request, const RpcDataUploadTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, rpcDataUploadTest(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FtClient::RpcDataUploadTestOutcomeCallable FtClient::rpcDataUploadTestCallable(const RpcDataUploadTestRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RpcDataUploadTestOutcome()>>(
+			[this, request]()
+			{
+			return this->rpcDataUploadTest(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));

ft/src/model/CreateInsRequest.cc

@@ -1,81 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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/ft/model/CreateInsRequest.h>
-
-using AlibabaCloud::Ft::Model::CreateInsRequest;
-
-CreateInsRequest::CreateInsRequest()
-    : RpcServiceRequest("ft", "2015-03-03", "CreateIns") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-CreateInsRequest::~CreateInsRequest() {}
-
-std::string CreateInsRequest::getNewparam1() const {
-  return newparam1_;
-}
-
-void CreateInsRequest::setNewparam1(const std::string &newparam1) {
-  newparam1_ = newparam1;
-  setParameter(std::string("new-param-1"), newparam1);
-}
-
-std::string CreateInsRequest::getBind() const {
-  return bind_;
-}
-
-void CreateInsRequest::setBind(const std::string &bind) {
-  bind_ = bind;
-  setParameter(std::string("Bind"), bind);
-}
-
-std::string CreateInsRequest::getTest() const {
-  return test_;
-}
-
-void CreateInsRequest::setTest(const std::string &test) {
-  test_ = test;
-  setParameter(std::string("Test"), test);
-}
-
-std::string CreateInsRequest::getSuccess() const {
-  return success_;
-}
-
-void CreateInsRequest::setSuccess(const std::string &success) {
-  success_ = success;
-  setParameter(std::string("Success"), success);
-}
-
-std::string CreateInsRequest::getTime() const {
-  return time_;
-}
-
-void CreateInsRequest::setTime(const std::string &time) {
-  time_ = time;
-  setParameter(std::string("Time"), time);
-}
-
-std::string CreateInsRequest::getNewPala() const {
-  return newPala_;
-}
-
-void CreateInsRequest::setNewPala(const std::string &newPala) {
-  newPala_ = newPala;
-  setParameter(std::string("NewPala"), newPala);
-}
-

ft/src/model/DataRateLimitTestRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ft/model/DataRateLimitTestRequest.h>
+
+using AlibabaCloud::Ft::Model::DataRateLimitTestRequest;
+
+DataRateLimitTestRequest::DataRateLimitTestRequest()
+    : RpcServiceRequest("ft", "2021-01-01", "DataRateLimitTest") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DataRateLimitTestRequest::~DataRateLimitTestRequest() {}
+
+std::string DataRateLimitTestRequest::getNewparam2() const {
+  return newparam2_;
+}
+
+void DataRateLimitTestRequest::setNewparam2(const std::string &newparam2) {
+  newparam2_ = newparam2;
+  setParameter(std::string("new-param-2"), newparam2);
+}
+
+std::string DataRateLimitTestRequest::getNewparam1() const {
+  return newparam1_;
+}
+
+void DataRateLimitTestRequest::setNewparam1(const std::string &newparam1) {
+  newparam1_ = newparam1;
+  setParameter(std::string("new-param-1"), newparam1);
+}
+
+std::string DataRateLimitTestRequest::getData() const {
+  return data_;
+}
+
+void DataRateLimitTestRequest::setData(const std::string &data) {
+  data_ = data;
+  setParameter(std::string("Data"), data);
+}
+
+std::string DataRateLimitTestRequest::getMap() const {
+  return map_;
+}
+
+void DataRateLimitTestRequest::setMap(const std::string &map) {
+  map_ = map;
+  setParameter(std::string("Map"), map);
+}
+

ft/src/model/DataRateLimitTestResult.cc

@@ -14,45 +14,31 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/ft/model/UpdateInsResult.h>
+#include <alibabacloud/ft/model/DataRateLimitTestResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Ft;
 using namespace AlibabaCloud::Ft::Model;
 
-UpdateInsResult::UpdateInsResult() :
+DataRateLimitTestResult::DataRateLimitTestResult() :
 	ServiceResult()
 {}
 
-UpdateInsResult::UpdateInsResult(const std::string &payload) :
+DataRateLimitTestResult::DataRateLimitTestResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-UpdateInsResult::~UpdateInsResult()
+DataRateLimitTestResult::~DataRateLimitTestResult()
 {}
 
-void UpdateInsResult::parse(const std::string &payload)
+void DataRateLimitTestResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["Code"].isNull())
-		code_ = value["Code"].asString();
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString();
 
 }
 
-std::string UpdateInsResult::getCode()const
-{
-	return code_;
-}
-
-std::string UpdateInsResult::getSuccess()const
-{
-	return success_;
-}
-

ft/src/model/NormalRpcHsfApiRequest.cc

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

ft/src/model/NormalRpcHsfApiResult.cc

@@ -14,45 +14,31 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/ft/model/CreateInsResult.h>
+#include <alibabacloud/ft/model/NormalRpcHsfApiResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Ft;
 using namespace AlibabaCloud::Ft::Model;
 
-CreateInsResult::CreateInsResult() :
+NormalRpcHsfApiResult::NormalRpcHsfApiResult() :
 	ServiceResult()
 {}
 
-CreateInsResult::CreateInsResult(const std::string &payload) :
+NormalRpcHsfApiResult::NormalRpcHsfApiResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-CreateInsResult::~CreateInsResult()
+NormalRpcHsfApiResult::~NormalRpcHsfApiResult()
 {}
 
-void CreateInsResult::parse(const std::string &payload)
+void NormalRpcHsfApiResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["Code"].isNull())
-		code_ = value["Code"].asString();
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString();
 
 }
 
-std::string CreateInsResult::getCode()const
-{
-	return code_;
-}
-
-std::string CreateInsResult::getSuccess()const
-{
-	return success_;
-}
-

ft/src/model/NormalRpcHttpApiRequest.cc

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

ft/src/model/NormalRpcHttpApiResult.cc

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

ft/src/model/RpcDataUploadAndDownloadRequest.cc

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

ft/src/model/RpcDataUploadAndDownloadResult.cc

@@ -14,45 +14,31 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/ft/model/RpcNoDefaultErrorCodeApiResult.h>
+#include <alibabacloud/ft/model/RpcDataUploadAndDownloadResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Ft;
 using namespace AlibabaCloud::Ft::Model;
 
-RpcNoDefaultErrorCodeApiResult::RpcNoDefaultErrorCodeApiResult() :
+RpcDataUploadAndDownloadResult::RpcDataUploadAndDownloadResult() :
 	ServiceResult()
 {}
 
-RpcNoDefaultErrorCodeApiResult::RpcNoDefaultErrorCodeApiResult(const std::string &payload) :
+RpcDataUploadAndDownloadResult::RpcDataUploadAndDownloadResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-RpcNoDefaultErrorCodeApiResult::~RpcNoDefaultErrorCodeApiResult()
+RpcDataUploadAndDownloadResult::~RpcDataUploadAndDownloadResult()
 {}
 
-void RpcNoDefaultErrorCodeApiResult::parse(const std::string &payload)
+void RpcDataUploadAndDownloadResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["Code"].isNull())
-		code_ = value["Code"].asString();
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString();
 
 }
 
-std::string RpcNoDefaultErrorCodeApiResult::getCode()const
-{
-	return code_;
-}
-
-std::string RpcNoDefaultErrorCodeApiResult::getSuccess()const
-{
-	return success_;
-}
-

ft/src/model/RpcDataUploadRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ft/model/RpcDataUploadRequest.h>
+
+using AlibabaCloud::Ft::Model::RpcDataUploadRequest;
+
+RpcDataUploadRequest::RpcDataUploadRequest()
+    : RpcServiceRequest("ft", "2021-01-01", "RpcDataUpload") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+RpcDataUploadRequest::~RpcDataUploadRequest() {}
+
+std::string RpcDataUploadRequest::getQuery1() const {
+  return query1_;
+}
+
+void RpcDataUploadRequest::setQuery1(const std::string &query1) {
+  query1_ = query1;
+  setParameter(std::string("query1"), query1);
+}
+
+long RpcDataUploadRequest::getQuery2() const {
+  return query2_;
+}
+
+void RpcDataUploadRequest::setQuery2(long query2) {
+  query2_ = query2;
+  setParameter(std::string("query2"), std::to_string(query2));
+}
+
+std::string RpcDataUploadRequest::getLargeParam() const {
+  return largeParam_;
+}
+
+void RpcDataUploadRequest::setLargeParam(const std::string &largeParam) {
+  largeParam_ = largeParam;
+  setBodyParameter(std::string("largeParam"), largeParam);
+}
+

ft/src/model/RpcDataUploadResult.cc

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ft/model/RpcDataUploadResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ft;
+using namespace AlibabaCloud::Ft::Model;
+
+RpcDataUploadResult::RpcDataUploadResult() :
+	ServiceResult()
+{}
+
+RpcDataUploadResult::RpcDataUploadResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+RpcDataUploadResult::~RpcDataUploadResult()
+{}
+
+void RpcDataUploadResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["url"].isNull())
+		url_ = value["url"].asString();
+	if(!value["totalBytes"].isNull())
+		totalBytes_ = std::stol(value["totalBytes"].asString());
+	if(!value["totalTime"].isNull())
+		totalTime_ = std::stol(value["totalTime"].asString());
+	if(!value["speed"].isNull())
+		speed_ = value["speed"].asString();
+	if(!value["params"].isNull())
+		params_ = value["params"].asString();
+	if(!value["headers"].isNull())
+		headers_ = value["headers"].asString();
+
+}
+
+std::string RpcDataUploadResult::getSpeed()const
+{
+	return speed_;
+}
+
+std::string RpcDataUploadResult::getHeaders()const
+{
+	return headers_;
+}
+
+long RpcDataUploadResult::getTotalBytes()const
+{
+	return totalBytes_;
+}
+
+long RpcDataUploadResult::getTotalTime()const
+{
+	return totalTime_;
+}
+
+std::string RpcDataUploadResult::getParams()const
+{
+	return params_;
+}
+
+std::string RpcDataUploadResult::getUrl()const
+{
+	return url_;
+}
+

ft/src/model/RpcDataUploadTestRequest.cc

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

ft/src/model/RpcDataUploadTestResult.cc

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

ft/src/model/RpcNoDefaultErrorCodeApiRequest.cc

@@ -1,81 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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/ft/model/RpcNoDefaultErrorCodeApiRequest.h>
-
-using AlibabaCloud::Ft::Model::RpcNoDefaultErrorCodeApiRequest;
-
-RpcNoDefaultErrorCodeApiRequest::RpcNoDefaultErrorCodeApiRequest()
-    : RpcServiceRequest("ft", "2015-03-03", "RpcNoDefaultErrorCodeApi") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-RpcNoDefaultErrorCodeApiRequest::~RpcNoDefaultErrorCodeApiRequest() {}
-
-std::string RpcNoDefaultErrorCodeApiRequest::getHttpMe() const {
-  return httpMe_;
-}
-
-void RpcNoDefaultErrorCodeApiRequest::setHttpMe(const std::string &httpMe) {
-  httpMe_ = httpMe;
-  setParameter(std::string("HttpMe"), httpMe);
-}
-
-std::string RpcNoDefaultErrorCodeApiRequest::getHttpStatusCode() const {
-  return httpStatusCode_;
-}
-
-void RpcNoDefaultErrorCodeApiRequest::setHttpStatusCode(const std::string &httpStatusCode) {
-  httpStatusCode_ = httpStatusCode;
-  setParameter(std::string("HttpStatusCode"), httpStatusCode);
-}
-
-std::string RpcNoDefaultErrorCodeApiRequest::getSetUser() const {
-  return setUser_;
-}
-
-void RpcNoDefaultErrorCodeApiRequest::setSetUser(const std::string &setUser) {
-  setUser_ = setUser;
-  setParameter(std::string("SetUser"), setUser);
-}
-
-std::string RpcNoDefaultErrorCodeApiRequest::getCode() const {
-  return code_;
-}
-
-void RpcNoDefaultErrorCodeApiRequest::setCode(const std::string &code) {
-  code_ = code;
-  setParameter(std::string("Code"), code);
-}
-
-std::string RpcNoDefaultErrorCodeApiRequest::getSuccess() const {
-  return success_;
-}
-
-void RpcNoDefaultErrorCodeApiRequest::setSuccess(const std::string &success) {
-  success_ = success;
-  setParameter(std::string("Success"), success);
-}
-
-std::string RpcNoDefaultErrorCodeApiRequest::getMessage() const {
-  return message_;
-}
-
-void RpcNoDefaultErrorCodeApiRequest::setMessage(const std::string &message) {
-  message_ = message;
-  setParameter(std::string("Message"), message);
-}
-

ft/src/model/UpdateInsRequest.cc

@@ -1,45 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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/ft/model/UpdateInsRequest.h>
-
-using AlibabaCloud::Ft::Model::UpdateInsRequest;
-
-UpdateInsRequest::UpdateInsRequest()
-    : RpcServiceRequest("ft", "2015-03-03", "UpdateIns") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-UpdateInsRequest::~UpdateInsRequest() {}
-
-std::string UpdateInsRequest::getSucceed() const {
-  return succeed_;
-}
-
-void UpdateInsRequest::setSucceed(const std::string &succeed) {
-  succeed_ = succeed;
-  setParameter(std::string("Succeed"), succeed);
-}
-
-std::string UpdateInsRequest::getHttpStatusCode1() const {
-  return httpStatusCode1_;
-}
-
-void UpdateInsRequest::setHttpStatusCode1(const std::string &httpStatusCode1) {
-  httpStatusCode1_ = httpStatusCode1;
-  setParameter(std::string("HttpStatusCode1"), httpStatusCode1);
-}
-