Lindorm open api.

VERSION

@@ -1 +1 @@
-1.36.1808
+1.36.1809

hitsdb/CMakeLists.txt

@@ -21,12 +21,18 @@ set(hitsdb_public_header
 	include/alibabacloud/hitsdb/HitsdbExport.h )
 
 set(hitsdb_public_header_model 
+	include/alibabacloud/hitsdb/model/CreateLdpsNamespaceRequest.h
+	include/alibabacloud/hitsdb/model/CreateLdpsNamespaceResult.h
 	include/alibabacloud/hitsdb/model/CreateLindormInstanceRequest.h
 	include/alibabacloud/hitsdb/model/CreateLindormInstanceResult.h
 	include/alibabacloud/hitsdb/model/DescribeRegionsRequest.h
 	include/alibabacloud/hitsdb/model/DescribeRegionsResult.h
 	include/alibabacloud/hitsdb/model/GetInstanceIpWhiteListRequest.h
 	include/alibabacloud/hitsdb/model/GetInstanceIpWhiteListResult.h
+	include/alibabacloud/hitsdb/model/GetLdpsNamespacedQuotaRequest.h
+	include/alibabacloud/hitsdb/model/GetLdpsNamespacedQuotaResult.h
+	include/alibabacloud/hitsdb/model/GetLdpsResourceCostRequest.h
+	include/alibabacloud/hitsdb/model/GetLdpsResourceCostResult.h
 	include/alibabacloud/hitsdb/model/GetLindormInstanceRequest.h
 	include/alibabacloud/hitsdb/model/GetLindormInstanceResult.h
 	include/alibabacloud/hitsdb/model/GetLindormInstanceEngineListRequest.h
@@ -52,12 +58,18 @@ set(hitsdb_public_header_model
 
 set(hitsdb_src 
 	src/HitsdbClient.cc
+	src/model/CreateLdpsNamespaceRequest.cc
+	src/model/CreateLdpsNamespaceResult.cc
 	src/model/CreateLindormInstanceRequest.cc
 	src/model/CreateLindormInstanceResult.cc
 	src/model/DescribeRegionsRequest.cc
 	src/model/DescribeRegionsResult.cc
 	src/model/GetInstanceIpWhiteListRequest.cc
 	src/model/GetInstanceIpWhiteListResult.cc
+	src/model/GetLdpsNamespacedQuotaRequest.cc
+	src/model/GetLdpsNamespacedQuotaResult.cc
+	src/model/GetLdpsResourceCostRequest.cc
+	src/model/GetLdpsResourceCostResult.cc
 	src/model/GetLindormInstanceRequest.cc
 	src/model/GetLindormInstanceResult.cc
 	src/model/GetLindormInstanceEngineListRequest.cc

hitsdb/include/alibabacloud/hitsdb/HitsdbClient.h

@@ -22,12 +22,18 @@
 #include <alibabacloud/core/EndpointProvider.h>
 #include <alibabacloud/core/RpcServiceClient.h>
 #include "HitsdbExport.h"
+#include "model/CreateLdpsNamespaceRequest.h"
+#include "model/CreateLdpsNamespaceResult.h"
 #include "model/CreateLindormInstanceRequest.h"
 #include "model/CreateLindormInstanceResult.h"
 #include "model/DescribeRegionsRequest.h"
 #include "model/DescribeRegionsResult.h"
 #include "model/GetInstanceIpWhiteListRequest.h"
 #include "model/GetInstanceIpWhiteListResult.h"
+#include "model/GetLdpsNamespacedQuotaRequest.h"
+#include "model/GetLdpsNamespacedQuotaResult.h"
+#include "model/GetLdpsResourceCostRequest.h"
+#include "model/GetLdpsResourceCostResult.h"
 #include "model/GetLindormInstanceRequest.h"
 #include "model/GetLindormInstanceResult.h"
 #include "model/GetLindormInstanceEngineListRequest.h"
@@ -59,6 +65,9 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_HITSDB_EXPORT HitsdbClient : public RpcServiceClient
 		{
 		public:
+			typedef Outcome<Error, Model::CreateLdpsNamespaceResult> CreateLdpsNamespaceOutcome;
+			typedef std::future<CreateLdpsNamespaceOutcome> CreateLdpsNamespaceOutcomeCallable;
+			typedef std::function<void(const HitsdbClient*, const Model::CreateLdpsNamespaceRequest&, const CreateLdpsNamespaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLdpsNamespaceAsyncHandler;
 			typedef Outcome<Error, Model::CreateLindormInstanceResult> CreateLindormInstanceOutcome;
 			typedef std::future<CreateLindormInstanceOutcome> CreateLindormInstanceOutcomeCallable;
 			typedef std::function<void(const HitsdbClient*, const Model::CreateLindormInstanceRequest&, const CreateLindormInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLindormInstanceAsyncHandler;
@@ -68,6 +77,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetInstanceIpWhiteListResult> GetInstanceIpWhiteListOutcome;
 			typedef std::future<GetInstanceIpWhiteListOutcome> GetInstanceIpWhiteListOutcomeCallable;
 			typedef std::function<void(const HitsdbClient*, const Model::GetInstanceIpWhiteListRequest&, const GetInstanceIpWhiteListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetInstanceIpWhiteListAsyncHandler;
+			typedef Outcome<Error, Model::GetLdpsNamespacedQuotaResult> GetLdpsNamespacedQuotaOutcome;
+			typedef std::future<GetLdpsNamespacedQuotaOutcome> GetLdpsNamespacedQuotaOutcomeCallable;
+			typedef std::function<void(const HitsdbClient*, const Model::GetLdpsNamespacedQuotaRequest&, const GetLdpsNamespacedQuotaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetLdpsNamespacedQuotaAsyncHandler;
+			typedef Outcome<Error, Model::GetLdpsResourceCostResult> GetLdpsResourceCostOutcome;
+			typedef std::future<GetLdpsResourceCostOutcome> GetLdpsResourceCostOutcomeCallable;
+			typedef std::function<void(const HitsdbClient*, const Model::GetLdpsResourceCostRequest&, const GetLdpsResourceCostOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetLdpsResourceCostAsyncHandler;
 			typedef Outcome<Error, Model::GetLindormInstanceResult> GetLindormInstanceOutcome;
 			typedef std::future<GetLindormInstanceOutcome> GetLindormInstanceOutcomeCallable;
 			typedef std::function<void(const HitsdbClient*, const Model::GetLindormInstanceRequest&, const GetLindormInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetLindormInstanceAsyncHandler;
@@ -106,6 +121,9 @@ namespace AlibabaCloud
 			HitsdbClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
 			HitsdbClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
 			~HitsdbClient();
+			CreateLdpsNamespaceOutcome createLdpsNamespace(const Model::CreateLdpsNamespaceRequest &request)const;
+			void createLdpsNamespaceAsync(const Model::CreateLdpsNamespaceRequest& request, const CreateLdpsNamespaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateLdpsNamespaceOutcomeCallable createLdpsNamespaceCallable(const Model::CreateLdpsNamespaceRequest& request) const;
 			CreateLindormInstanceOutcome createLindormInstance(const Model::CreateLindormInstanceRequest &request)const;
 			void createLindormInstanceAsync(const Model::CreateLindormInstanceRequest& request, const CreateLindormInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateLindormInstanceOutcomeCallable createLindormInstanceCallable(const Model::CreateLindormInstanceRequest& request) const;
@@ -115,6 +133,12 @@ namespace AlibabaCloud
 			GetInstanceIpWhiteListOutcome getInstanceIpWhiteList(const Model::GetInstanceIpWhiteListRequest &request)const;
 			void getInstanceIpWhiteListAsync(const Model::GetInstanceIpWhiteListRequest& request, const GetInstanceIpWhiteListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetInstanceIpWhiteListOutcomeCallable getInstanceIpWhiteListCallable(const Model::GetInstanceIpWhiteListRequest& request) const;
+			GetLdpsNamespacedQuotaOutcome getLdpsNamespacedQuota(const Model::GetLdpsNamespacedQuotaRequest &request)const;
+			void getLdpsNamespacedQuotaAsync(const Model::GetLdpsNamespacedQuotaRequest& request, const GetLdpsNamespacedQuotaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetLdpsNamespacedQuotaOutcomeCallable getLdpsNamespacedQuotaCallable(const Model::GetLdpsNamespacedQuotaRequest& request) const;
+			GetLdpsResourceCostOutcome getLdpsResourceCost(const Model::GetLdpsResourceCostRequest &request)const;
+			void getLdpsResourceCostAsync(const Model::GetLdpsResourceCostRequest& request, const GetLdpsResourceCostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetLdpsResourceCostOutcomeCallable getLdpsResourceCostCallable(const Model::GetLdpsResourceCostRequest& request) const;
 			GetLindormInstanceOutcome getLindormInstance(const Model::GetLindormInstanceRequest &request)const;
 			void getLindormInstanceAsync(const Model::GetLindormInstanceRequest& request, const GetLindormInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetLindormInstanceOutcomeCallable getLindormInstanceCallable(const Model::GetLindormInstanceRequest& request) const;

hitsdb/include/alibabacloud/hitsdb/model/CreateLdpsNamespaceRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_HITSDB_MODEL_CREATELDPSNAMESPACEREQUEST_H_
+#define ALIBABACLOUD_HITSDB_MODEL_CREATELDPSNAMESPACEREQUEST_H_
+
+#include <alibabacloud/hitsdb/HitsdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Hitsdb {
+namespace Model {
+class ALIBABACLOUD_HITSDB_EXPORT CreateLdpsNamespaceRequest : public RpcServiceRequest {
+public:
+	CreateLdpsNamespaceRequest();
+	~CreateLdpsNamespaceRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getSecurityToken() const;
+	void setSecurityToken(const std::string &securityToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
+
+private:
+	long resourceOwnerId_;
+	std::string accessKeyId_;
+	std::string securityToken_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	long ownerId_;
+	std::string instanceId_;
+	std::string _namespace_;
+};
+} // namespace Model
+} // namespace Hitsdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_HITSDB_MODEL_CREATELDPSNAMESPACEREQUEST_H_

hitsdb/include/alibabacloud/hitsdb/model/CreateLdpsNamespaceResult.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_HITSDB_MODEL_CREATELDPSNAMESPACERESULT_H_
+#define ALIBABACLOUD_HITSDB_MODEL_CREATELDPSNAMESPACERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hitsdb/HitsdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Hitsdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HITSDB_EXPORT CreateLdpsNamespaceResult : public ServiceResult
+			{
+			public:
+
+
+				CreateLdpsNamespaceResult();
+				explicit CreateLdpsNamespaceResult(const std::string &payload);
+				~CreateLdpsNamespaceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HITSDB_MODEL_CREATELDPSNAMESPACERESULT_H_

hitsdb/include/alibabacloud/hitsdb/model/CreateLindormInstanceRequest.h

@@ -54,6 +54,8 @@ public:
 	void setLindormNum(int lindormNum);
 	std::string getVSwitchId() const;
 	void setVSwitchId(const std::string &vSwitchId);
+	int getStreamNum() const;
+	void setStreamNum(int streamNum);
 	int getLogSingleStorage() const;
 	void setLogSingleStorage(int logSingleStorage);
 	std::string getZoneId() const;
@@ -104,6 +106,8 @@ public:
 	void setInstanceAlias(const std::string &instanceAlias);
 	int getFilestoreNum() const;
 	void setFilestoreNum(int filestoreNum);
+	std::string getStreamSpec() const;
+	void setStreamSpec(const std::string &streamSpec);
 	std::string getCoreSpec() const;
 	void setCoreSpec(const std::string &coreSpec);
 	std::string getVPCId() const;
@@ -126,6 +130,7 @@ private:
 	long ownerId_;
 	int lindormNum_;
 	std::string vSwitchId_;
+	int streamNum_;
 	int logSingleStorage_;
 	std::string zoneId_;
 	std::string arbiterZoneId_;
@@ -151,6 +156,7 @@ private:
 	std::string ownerAccount_;
 	std::string instanceAlias_;
 	int filestoreNum_;
+	std::string streamSpec_;
 	std::string coreSpec_;
 	std::string vPCId_;
 	std::string payType_;

hitsdb/include/alibabacloud/hitsdb/model/GetInstanceIpWhiteListResult.h

@@ -32,17 +32,24 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_HITSDB_EXPORT GetInstanceIpWhiteListResult : public ServiceResult
 			{
 			public:
+				struct GroupListItem
+				{
+					std::string groupName;
+					std::string securityIpList;
+				};
 
 
 				GetInstanceIpWhiteListResult();
 				explicit GetInstanceIpWhiteListResult(const std::string &payload);
 				~GetInstanceIpWhiteListResult();
+				std::vector<GroupListItem> getGroupList()const;
 				std::vector<std::string> getIpList()const;
 				std::string getInstanceId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::vector<GroupListItem> groupList_;
 				std::vector<std::string> ipList_;
 				std::string instanceId_;
 

hitsdb/include/alibabacloud/hitsdb/model/GetLdpsNamespacedQuotaRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_HITSDB_MODEL_GETLDPSNAMESPACEDQUOTAREQUEST_H_
+#define ALIBABACLOUD_HITSDB_MODEL_GETLDPSNAMESPACEDQUOTAREQUEST_H_
+
+#include <alibabacloud/hitsdb/HitsdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Hitsdb {
+namespace Model {
+class ALIBABACLOUD_HITSDB_EXPORT GetLdpsNamespacedQuotaRequest : public RpcServiceRequest {
+public:
+	GetLdpsNamespacedQuotaRequest();
+	~GetLdpsNamespacedQuotaRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getSecurityToken() const;
+	void setSecurityToken(const std::string &securityToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string get_Namespace() const;
+	void set_Namespace(const std::string &_namespace);
+
+private:
+	long resourceOwnerId_;
+	std::string accessKeyId_;
+	std::string securityToken_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	long ownerId_;
+	std::string instanceId_;
+	std::string _namespace_;
+};
+} // namespace Model
+} // namespace Hitsdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_HITSDB_MODEL_GETLDPSNAMESPACEDQUOTAREQUEST_H_

hitsdb/include/alibabacloud/hitsdb/model/GetLdpsNamespacedQuotaResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_HITSDB_MODEL_GETLDPSNAMESPACEDQUOTARESULT_H_
+#define ALIBABACLOUD_HITSDB_MODEL_GETLDPSNAMESPACEDQUOTARESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hitsdb/HitsdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Hitsdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HITSDB_EXPORT GetLdpsNamespacedQuotaResult : public ServiceResult
+			{
+			public:
+				struct NamespacedQuota
+				{
+					std::string usedMemory;
+					std::string cpuAmount;
+					std::string usedCpu;
+					std::string memoryAmount;
+					std::string name;
+				};
+
+
+				GetLdpsNamespacedQuotaResult();
+				explicit GetLdpsNamespacedQuotaResult(const std::string &payload);
+				~GetLdpsNamespacedQuotaResult();
+				std::vector<NamespacedQuota> getNamespacedQuotas()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<NamespacedQuota> namespacedQuotas_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HITSDB_MODEL_GETLDPSNAMESPACEDQUOTARESULT_H_

hitsdb/include/alibabacloud/hitsdb/model/GetLdpsResourceCostRequest.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_HITSDB_MODEL_GETLDPSRESOURCECOSTREQUEST_H_
+#define ALIBABACLOUD_HITSDB_MODEL_GETLDPSRESOURCECOSTREQUEST_H_
+
+#include <alibabacloud/hitsdb/HitsdbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Hitsdb {
+namespace Model {
+class ALIBABACLOUD_HITSDB_EXPORT GetLdpsResourceCostRequest : public RpcServiceRequest {
+public:
+	GetLdpsResourceCostRequest();
+	~GetLdpsResourceCostRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	long getStartTime() const;
+	void setStartTime(long startTime);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getJobId() const;
+	void setJobId(const std::string &jobId);
+	std::string getSecurityToken() const;
+	void setSecurityToken(const std::string &securityToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getEndTime() const;
+	void setEndTime(long endTime);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+
+private:
+	long resourceOwnerId_;
+	long startTime_;
+	std::string accessKeyId_;
+	std::string jobId_;
+	std::string securityToken_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	long endTime_;
+	long ownerId_;
+	std::string instanceId_;
+};
+} // namespace Model
+} // namespace Hitsdb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_HITSDB_MODEL_GETLDPSRESOURCECOSTREQUEST_H_

hitsdb/include/alibabacloud/hitsdb/model/GetLdpsResourceCostResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_HITSDB_MODEL_GETLDPSRESOURCECOSTRESULT_H_
+#define ALIBABACLOUD_HITSDB_MODEL_GETLDPSRESOURCECOSTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hitsdb/HitsdbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Hitsdb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HITSDB_EXPORT GetLdpsResourceCostResult : public ServiceResult
+			{
+			public:
+
+
+				GetLdpsResourceCostResult();
+				explicit GetLdpsResourceCostResult(const std::string &payload);
+				~GetLdpsResourceCostResult();
+				long getEndTime()const;
+				std::string getInstanceId()const;
+				long getStartTime()const;
+				long getTotalResource()const;
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long endTime_;
+				std::string instanceId_;
+				long startTime_;
+				long totalResource_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HITSDB_MODEL_GETLDPSRESOURCECOSTRESULT_H_

hitsdb/include/alibabacloud/hitsdb/model/GetLindormInstanceResult.h

@@ -50,6 +50,7 @@ namespace AlibabaCloud
 				long getExpiredMilliseconds()const;
 				std::string getStandbyZoneId()const;
 				std::vector<Engine> getEngineList()const;
+				bool getEnableLTS()const;
 				std::string getResourceGroupId()const;
 				bool getEnableBDS()const;
 				std::string getLogDiskCategory()const;
@@ -74,13 +75,17 @@ namespace AlibabaCloud
 				std::string getArbiterVSwitchId()const;
 				std::string getVpcId()const;
 				bool getEnableCdc()const;
+				bool getEnableMLCtrl()const;
 				bool getEnableStream()const;
 				bool getEnablePhoenix()const;
 				int getLogSingleStorage()const;
 				std::string getExpireTime()const;
+				bool getEnableML()const;
 				int getLogNum()const;
 				int getLocalCloudStorage()const;
+				bool getEnableBlob()const;
 				std::string getDiskThreshold()const;
+				bool getEnableLsqlVersionV3()const;
 				bool getAutoRenew()const;
 				bool getEnableShs()const;
 				std::string getMaintainEndTime()const;
@@ -94,6 +99,7 @@ namespace AlibabaCloud
 				std::string getMultiZoneCombination()const;
 				bool getEnableKms()const;
 				int getCoreNum()const;
+				std::string getArchVersion()const;
 				std::string getCreateTime()const;
 				std::string getLogSpec()const;
 				std::string getLocalCloudCategory()const;
@@ -107,6 +113,7 @@ namespace AlibabaCloud
 				long expiredMilliseconds_;
 				std::string standbyZoneId_;
 				std::vector<Engine> engineList_;
+				bool enableLTS_;
 				std::string resourceGroupId_;
 				bool enableBDS_;
 				std::string logDiskCategory_;
@@ -131,13 +138,17 @@ namespace AlibabaCloud
 				std::string arbiterVSwitchId_;
 				std::string vpcId_;
 				bool enableCdc_;
+				bool enableMLCtrl_;
 				bool enableStream_;
 				bool enablePhoenix_;
 				int logSingleStorage_;
 				std::string expireTime_;
+				bool enableML_;
 				int logNum_;
 				int localCloudStorage_;
+				bool enableBlob_;
 				std::string diskThreshold_;
+				bool enableLsqlVersionV3_;
 				bool autoRenew_;
 				bool enableShs_;
 				std::string maintainEndTime_;
@@ -151,6 +162,7 @@ namespace AlibabaCloud
 				std::string multiZoneCombination_;
 				bool enableKms_;
 				int coreNum_;
+				std::string archVersion_;
 				std::string createTime_;
 				std::string logSpec_;
 				std::string localCloudCategory_;

hitsdb/include/alibabacloud/hitsdb/model/ReleaseLindormInstanceRequest.h

@@ -32,6 +32,8 @@ public:
 	~ReleaseLindormInstanceRequest();
 	long getResourceOwnerId() const;
 	void setResourceOwnerId(long resourceOwnerId);
+	bool getImmediately() const;
+	void setImmediately(bool immediately);
 	std::string getAccessKeyId() const;
 	void setAccessKeyId(const std::string &accessKeyId);
 	std::string getSecurityToken() const;
@@ -47,6 +49,7 @@ public:
 
 private:
 	long resourceOwnerId_;
+	bool immediately_;
 	std::string accessKeyId_;
 	std::string securityToken_;
 	std::string resourceOwnerAccount_;

hitsdb/include/alibabacloud/hitsdb/model/UpdateInstanceIpWhiteListRequest.h

@@ -32,6 +32,8 @@ public:
 	~UpdateInstanceIpWhiteListRequest();
 	long getResourceOwnerId() const;
 	void setResourceOwnerId(long resourceOwnerId);
+	bool get_Delete() const;
+	void set_Delete(bool _delete);
 	std::string getAccessKeyId() const;
 	void setAccessKeyId(const std::string &accessKeyId);
 	std::string getSecurityToken() const;
@@ -51,6 +53,7 @@ public:
 
 private:
 	long resourceOwnerId_;
+	bool _delete_;
 	std::string accessKeyId_;
 	std::string securityToken_;
 	std::string resourceOwnerAccount_;

hitsdb/include/alibabacloud/hitsdb/model/UpgradeLindormInstanceRequest.h

@@ -32,10 +32,30 @@ public:
 	~UpgradeLindormInstanceRequest();
 	long getResourceOwnerId() const;
 	void setResourceOwnerId(long resourceOwnerId);
-	int getPhoenixCoreNum() const;
-	void setPhoenixCoreNum(int phoenixCoreNum);
-	std::string getPhoenixCoreSpec() const;
-	void setPhoenixCoreSpec(const std::string &phoenixCoreSpec);
+	std::string getLogSpec() const;
+	void setLogSpec(const std::string &logSpec);
+	std::string getSecurityToken() const;
+	void setSecurityToken(const std::string &securityToken);
+	int getTsdbNum() const;
+	void setTsdbNum(int tsdbNum);
+	int getSolrNum() const;
+	void setSolrNum(int solrNum);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	int getLindormNum() const;
+	void setLindormNum(int lindormNum);
+	int getLtsCoreNum() const;
+	void setLtsCoreNum(int ltsCoreNum);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	int getMlNum() const;
+	void setMlNum(int mlNum);
+	int getStreamNum() const;
+	void setStreamNum(int streamNum);
+	int getLogSingleStorage() const;
+	void setLogSingleStorage(int logSingleStorage);
+	std::string getZoneId() const;
+	void setZoneId(const std::string &zoneId);
 	std::string getClientToken() const;
 	void setClientToken(const std::string &clientToken);
 	std::string getUpgradeType() const;
@@ -46,18 +66,10 @@ public:
 	void setFilestoreSpec(const std::string &filestoreSpec);
 	std::string getAccessKeyId() const;
 	void setAccessKeyId(const std::string &accessKeyId);
-	std::string getLogSpec() const;
-	void setLogSpec(const std::string &logSpec);
-	std::string getSecurityToken() const;
-	void setSecurityToken(const std::string &securityToken);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
-	int getTsdbNum() const;
-	void setTsdbNum(int tsdbNum);
 	std::string getLindormSpec() const;
 	void setLindormSpec(const std::string &lindormSpec);
-	int getSolrNum() const;
-	void setSolrNum(int solrNum);
 	int getColdStorage() const;
 	void setColdStorage(int coldStorage);
 	int getLogNum() const;
@@ -72,38 +84,36 @@ public:
 	void setOwnerAccount(const std::string &ownerAccount);
 	int getFilestoreNum() const;
 	void setFilestoreNum(int filestoreNum);
-	long getOwnerId() const;
-	void setOwnerId(long ownerId);
-	int getLindormNum() const;
-	void setLindormNum(int lindormNum);
-	int getLtsCoreNum() const;
-	void setLtsCoreNum(int ltsCoreNum);
-	std::string getInstanceId() const;
-	void setInstanceId(const std::string &instanceId);
+	std::string getStreamSpec() const;
+	void setStreamSpec(const std::string &streamSpec);
+	std::string getMlSpec() const;
+	void setMlSpec(const std::string &mlSpec);
 	std::string getLtsCoreSpec() const;
 	void setLtsCoreSpec(const std::string &ltsCoreSpec);
 	int getClusterStorage() const;
 	void setClusterStorage(int clusterStorage);
-	int getLogSingleStorage() const;
-	void setLogSingleStorage(int logSingleStorage);
-	std::string getZoneId() const;
-	void setZoneId(const std::string &zoneId);
 
 private:
 	long resourceOwnerId_;
-	int phoenixCoreNum_;
-	std::string phoenixCoreSpec_;
+	std::string logSpec_;
+	std::string securityToken_;
+	int tsdbNum_;
+	int solrNum_;
+	long ownerId_;
+	int lindormNum_;
+	int ltsCoreNum_;
+	std::string instanceId_;
+	int mlNum_;
+	int streamNum_;
+	int logSingleStorage_;
+	std::string zoneId_;
 	std::string clientToken_;
 	std::string upgradeType_;
 	std::string tsdbSpec_;
 	std::string filestoreSpec_;
 	std::string accessKeyId_;
-	std::string logSpec_;
-	std::string securityToken_;
 	std::string regionId_;
-	int tsdbNum_;
 	std::string lindormSpec_;
-	int solrNum_;
 	int coldStorage_;
 	int logNum_;
 	std::string solrSpec_;
@@ -111,14 +121,10 @@ private:
 	std::string resourceOwnerAccount_;
 	std::string ownerAccount_;
 	int filestoreNum_;
-	long ownerId_;
-	int lindormNum_;
-	int ltsCoreNum_;
-	std::string instanceId_;
+	std::string streamSpec_;
+	std::string mlSpec_;
 	std::string ltsCoreSpec_;
 	int clusterStorage_;
-	int logSingleStorage_;
-	std::string zoneId_;
 };
 } // namespace Model
 } // namespace Hitsdb

hitsdb/src/HitsdbClient.cc

@@ -51,6 +51,42 @@ HitsdbClient::HitsdbClient(const std::string & accessKeyId, const std::string &
 HitsdbClient::~HitsdbClient()
 {}
 
+HitsdbClient::CreateLdpsNamespaceOutcome HitsdbClient::createLdpsNamespace(const CreateLdpsNamespaceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateLdpsNamespaceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateLdpsNamespaceOutcome(CreateLdpsNamespaceResult(outcome.result()));
+	else
+		return CreateLdpsNamespaceOutcome(outcome.error());
+}
+
+void HitsdbClient::createLdpsNamespaceAsync(const CreateLdpsNamespaceRequest& request, const CreateLdpsNamespaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createLdpsNamespace(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HitsdbClient::CreateLdpsNamespaceOutcomeCallable HitsdbClient::createLdpsNamespaceCallable(const CreateLdpsNamespaceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateLdpsNamespaceOutcome()>>(
+			[this, request]()
+			{
+			return this->createLdpsNamespace(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HitsdbClient::CreateLindormInstanceOutcome HitsdbClient::createLindormInstance(const CreateLindormInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -159,6 +195,78 @@ HitsdbClient::GetInstanceIpWhiteListOutcomeCallable HitsdbClient::getInstanceIpW
 	return task->get_future();
 }
 
+HitsdbClient::GetLdpsNamespacedQuotaOutcome HitsdbClient::getLdpsNamespacedQuota(const GetLdpsNamespacedQuotaRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetLdpsNamespacedQuotaOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetLdpsNamespacedQuotaOutcome(GetLdpsNamespacedQuotaResult(outcome.result()));
+	else
+		return GetLdpsNamespacedQuotaOutcome(outcome.error());
+}
+
+void HitsdbClient::getLdpsNamespacedQuotaAsync(const GetLdpsNamespacedQuotaRequest& request, const GetLdpsNamespacedQuotaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getLdpsNamespacedQuota(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HitsdbClient::GetLdpsNamespacedQuotaOutcomeCallable HitsdbClient::getLdpsNamespacedQuotaCallable(const GetLdpsNamespacedQuotaRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetLdpsNamespacedQuotaOutcome()>>(
+			[this, request]()
+			{
+			return this->getLdpsNamespacedQuota(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+HitsdbClient::GetLdpsResourceCostOutcome HitsdbClient::getLdpsResourceCost(const GetLdpsResourceCostRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetLdpsResourceCostOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetLdpsResourceCostOutcome(GetLdpsResourceCostResult(outcome.result()));
+	else
+		return GetLdpsResourceCostOutcome(outcome.error());
+}
+
+void HitsdbClient::getLdpsResourceCostAsync(const GetLdpsResourceCostRequest& request, const GetLdpsResourceCostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getLdpsResourceCost(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+HitsdbClient::GetLdpsResourceCostOutcomeCallable HitsdbClient::getLdpsResourceCostCallable(const GetLdpsResourceCostRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetLdpsResourceCostOutcome()>>(
+			[this, request]()
+			{
+			return this->getLdpsResourceCost(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 HitsdbClient::GetLindormInstanceOutcome HitsdbClient::getLindormInstance(const GetLindormInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

hitsdb/src/model/CreateLdpsNamespaceRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hitsdb/model/CreateLdpsNamespaceRequest.h>
+
+using AlibabaCloud::Hitsdb::Model::CreateLdpsNamespaceRequest;
+
+CreateLdpsNamespaceRequest::CreateLdpsNamespaceRequest()
+    : RpcServiceRequest("hitsdb", "2020-06-15", "CreateLdpsNamespace") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateLdpsNamespaceRequest::~CreateLdpsNamespaceRequest() {}
+
+long CreateLdpsNamespaceRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateLdpsNamespaceRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CreateLdpsNamespaceRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void CreateLdpsNamespaceRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string CreateLdpsNamespaceRequest::getSecurityToken() const {
+  return securityToken_;
+}
+
+void CreateLdpsNamespaceRequest::setSecurityToken(const std::string &securityToken) {
+  securityToken_ = securityToken;
+  setParameter(std::string("SecurityToken"), securityToken);
+}
+
+std::string CreateLdpsNamespaceRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateLdpsNamespaceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateLdpsNamespaceRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CreateLdpsNamespaceRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CreateLdpsNamespaceRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreateLdpsNamespaceRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long CreateLdpsNamespaceRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateLdpsNamespaceRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateLdpsNamespaceRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void CreateLdpsNamespaceRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+
+std::string CreateLdpsNamespaceRequest::get_Namespace() const {
+  return _namespace_;
+}
+
+void CreateLdpsNamespaceRequest::set_Namespace(const std::string &_namespace) {
+  _namespace_ = _namespace;
+  setParameter(std::string("Namespace"), _namespace);
+}
+

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

hitsdb/src/model/CreateLindormInstanceRequest.cc

@@ -133,6 +133,15 @@ void CreateLindormInstanceRequest::setVSwitchId(const std::string &vSwitchId) {
   setParameter(std::string("VSwitchId"), vSwitchId);
 }
 
+int CreateLindormInstanceRequest::getStreamNum() const {
+  return streamNum_;
+}
+
+void CreateLindormInstanceRequest::setStreamNum(int streamNum) {
+  streamNum_ = streamNum;
+  setParameter(std::string("StreamNum"), std::to_string(streamNum));
+}
+
 int CreateLindormInstanceRequest::getLogSingleStorage() const {
   return logSingleStorage_;
 }
@@ -358,6 +367,15 @@ void CreateLindormInstanceRequest::setFilestoreNum(int filestoreNum) {
   setParameter(std::string("FilestoreNum"), std::to_string(filestoreNum));
 }
 
+std::string CreateLindormInstanceRequest::getStreamSpec() const {
+  return streamSpec_;
+}
+
+void CreateLindormInstanceRequest::setStreamSpec(const std::string &streamSpec) {
+  streamSpec_ = streamSpec;
+  setParameter(std::string("StreamSpec"), streamSpec);
+}
+
 std::string CreateLindormInstanceRequest::getCoreSpec() const {
   return coreSpec_;
 }

hitsdb/src/model/GetInstanceIpWhiteListResult.cc

@@ -39,6 +39,16 @@ void GetInstanceIpWhiteListResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	auto allGroupListNode = value["GroupList"]["GroupListItem"];
+	for (auto valueGroupListGroupListItem : allGroupListNode)
+	{
+		GroupListItem groupListObject;
+		if(!valueGroupListGroupListItem["GroupName"].isNull())
+			groupListObject.groupName = valueGroupListGroupListItem["GroupName"].asString();
+		if(!valueGroupListGroupListItem["SecurityIpList"].isNull())
+			groupListObject.securityIpList = valueGroupListGroupListItem["SecurityIpList"].asString();
+		groupList_.push_back(groupListObject);
+	}
 	auto allIpList = value["IpList"]["IpList"];
 	for (const auto &item : allIpList)
 		ipList_.push_back(item.asString());
@@ -47,6 +57,11 @@ void GetInstanceIpWhiteListResult::parse(const std::string &payload)
 
 }
 
+std::vector<GetInstanceIpWhiteListResult::GroupListItem> GetInstanceIpWhiteListResult::getGroupList()const
+{
+	return groupList_;
+}
+
 std::vector<std::string> GetInstanceIpWhiteListResult::getIpList()const
 {
 	return ipList_;

hitsdb/src/model/GetLdpsNamespacedQuotaRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hitsdb/model/GetLdpsNamespacedQuotaRequest.h>
+
+using AlibabaCloud::Hitsdb::Model::GetLdpsNamespacedQuotaRequest;
+
+GetLdpsNamespacedQuotaRequest::GetLdpsNamespacedQuotaRequest()
+    : RpcServiceRequest("hitsdb", "2020-06-15", "GetLdpsNamespacedQuota") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetLdpsNamespacedQuotaRequest::~GetLdpsNamespacedQuotaRequest() {}
+
+long GetLdpsNamespacedQuotaRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void GetLdpsNamespacedQuotaRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string GetLdpsNamespacedQuotaRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void GetLdpsNamespacedQuotaRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string GetLdpsNamespacedQuotaRequest::getSecurityToken() const {
+  return securityToken_;
+}
+
+void GetLdpsNamespacedQuotaRequest::setSecurityToken(const std::string &securityToken) {
+  securityToken_ = securityToken;
+  setParameter(std::string("SecurityToken"), securityToken);
+}
+
+std::string GetLdpsNamespacedQuotaRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetLdpsNamespacedQuotaRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string GetLdpsNamespacedQuotaRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void GetLdpsNamespacedQuotaRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string GetLdpsNamespacedQuotaRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void GetLdpsNamespacedQuotaRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long GetLdpsNamespacedQuotaRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void GetLdpsNamespacedQuotaRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string GetLdpsNamespacedQuotaRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void GetLdpsNamespacedQuotaRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+
+std::string GetLdpsNamespacedQuotaRequest::get_Namespace() const {
+  return _namespace_;
+}
+
+void GetLdpsNamespacedQuotaRequest::set_Namespace(const std::string &_namespace) {
+  _namespace_ = _namespace;
+  setParameter(std::string("Namespace"), _namespace);
+}
+

hitsdb/src/model/GetLdpsNamespacedQuotaResult.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/hitsdb/model/GetLdpsNamespacedQuotaResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Hitsdb;
+using namespace AlibabaCloud::Hitsdb::Model;
+
+GetLdpsNamespacedQuotaResult::GetLdpsNamespacedQuotaResult() :
+	ServiceResult()
+{}
+
+GetLdpsNamespacedQuotaResult::GetLdpsNamespacedQuotaResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetLdpsNamespacedQuotaResult::~GetLdpsNamespacedQuotaResult()
+{}
+
+void GetLdpsNamespacedQuotaResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allNamespacedQuotasNode = value["NamespacedQuotas"]["NamespacedQuota"];
+	for (auto valueNamespacedQuotasNamespacedQuota : allNamespacedQuotasNode)
+	{
+		NamespacedQuota namespacedQuotasObject;
+		if(!valueNamespacedQuotasNamespacedQuota["Name"].isNull())
+			namespacedQuotasObject.name = valueNamespacedQuotasNamespacedQuota["Name"].asString();
+		if(!valueNamespacedQuotasNamespacedQuota["CpuAmount"].isNull())
+			namespacedQuotasObject.cpuAmount = valueNamespacedQuotasNamespacedQuota["CpuAmount"].asString();
+		if(!valueNamespacedQuotasNamespacedQuota["MemoryAmount"].isNull())
+			namespacedQuotasObject.memoryAmount = valueNamespacedQuotasNamespacedQuota["MemoryAmount"].asString();
+		if(!valueNamespacedQuotasNamespacedQuota["UsedCpu"].isNull())
+			namespacedQuotasObject.usedCpu = valueNamespacedQuotasNamespacedQuota["UsedCpu"].asString();
+		if(!valueNamespacedQuotasNamespacedQuota["UsedMemory"].isNull())
+			namespacedQuotasObject.usedMemory = valueNamespacedQuotasNamespacedQuota["UsedMemory"].asString();
+		namespacedQuotas_.push_back(namespacedQuotasObject);
+	}
+
+}
+
+std::vector<GetLdpsNamespacedQuotaResult::NamespacedQuota> GetLdpsNamespacedQuotaResult::getNamespacedQuotas()const
+{
+	return namespacedQuotas_;
+}
+

hitsdb/src/model/GetLdpsResourceCostRequest.cc

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hitsdb/model/GetLdpsResourceCostRequest.h>
+
+using AlibabaCloud::Hitsdb::Model::GetLdpsResourceCostRequest;
+
+GetLdpsResourceCostRequest::GetLdpsResourceCostRequest()
+    : RpcServiceRequest("hitsdb", "2020-06-15", "GetLdpsResourceCost") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetLdpsResourceCostRequest::~GetLdpsResourceCostRequest() {}
+
+long GetLdpsResourceCostRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void GetLdpsResourceCostRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+long GetLdpsResourceCostRequest::getStartTime() const {
+  return startTime_;
+}
+
+void GetLdpsResourceCostRequest::setStartTime(long startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), std::to_string(startTime));
+}
+
+std::string GetLdpsResourceCostRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void GetLdpsResourceCostRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string GetLdpsResourceCostRequest::getJobId() const {
+  return jobId_;
+}
+
+void GetLdpsResourceCostRequest::setJobId(const std::string &jobId) {
+  jobId_ = jobId;
+  setParameter(std::string("JobId"), jobId);
+}
+
+std::string GetLdpsResourceCostRequest::getSecurityToken() const {
+  return securityToken_;
+}
+
+void GetLdpsResourceCostRequest::setSecurityToken(const std::string &securityToken) {
+  securityToken_ = securityToken;
+  setParameter(std::string("SecurityToken"), securityToken);
+}
+
+std::string GetLdpsResourceCostRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetLdpsResourceCostRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string GetLdpsResourceCostRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void GetLdpsResourceCostRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string GetLdpsResourceCostRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void GetLdpsResourceCostRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long GetLdpsResourceCostRequest::getEndTime() const {
+  return endTime_;
+}
+
+void GetLdpsResourceCostRequest::setEndTime(long endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), std::to_string(endTime));
+}
+
+long GetLdpsResourceCostRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void GetLdpsResourceCostRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string GetLdpsResourceCostRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void GetLdpsResourceCostRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+

hitsdb/src/model/GetLdpsResourceCostResult.cc

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/hitsdb/model/GetLdpsResourceCostResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Hitsdb;
+using namespace AlibabaCloud::Hitsdb::Model;
+
+GetLdpsResourceCostResult::GetLdpsResourceCostResult() :
+	ServiceResult()
+{}
+
+GetLdpsResourceCostResult::GetLdpsResourceCostResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetLdpsResourceCostResult::~GetLdpsResourceCostResult()
+{}
+
+void GetLdpsResourceCostResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["InstanceId"].isNull())
+		instanceId_ = value["InstanceId"].asString();
+	if(!value["JobId"].isNull())
+		jobId_ = value["JobId"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = std::stol(value["StartTime"].asString());
+	if(!value["EndTime"].isNull())
+		endTime_ = std::stol(value["EndTime"].asString());
+	if(!value["TotalResource"].isNull())
+		totalResource_ = std::stol(value["TotalResource"].asString());
+
+}
+
+long GetLdpsResourceCostResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string GetLdpsResourceCostResult::getInstanceId()const
+{
+	return instanceId_;
+}
+
+long GetLdpsResourceCostResult::getStartTime()const
+{
+	return startTime_;
+}
+
+long GetLdpsResourceCostResult::getTotalResource()const
+{
+	return totalResource_;
+}
+
+std::string GetLdpsResourceCostResult::getJobId()const
+{
+	return jobId_;
+}
+

hitsdb/src/model/GetLindormInstanceResult.cc

@@ -73,6 +73,8 @@ void GetLindormInstanceResult::parse(const std::string &payload)
 		serviceType_ = value["ServiceType"].asString();
 	if(!value["EnableKms"].isNull())
 		enableKms_ = value["EnableKms"].asString() == "true";
+	if(!value["EnableML"].isNull())
+		enableML_ = value["EnableML"].asString() == "true";
 	if(!value["DiskUsage"].isNull())
 		diskUsage_ = value["DiskUsage"].asString();
 	if(!value["DiskCategory"].isNull())
@@ -117,12 +119,18 @@ void GetLindormInstanceResult::parse(const std::string &payload)
 		enableCompute_ = value["EnableCompute"].asString() == "true";
 	if(!value["EnableSSL"].isNull())
 		enableSSL_ = value["EnableSSL"].asString() == "true";
+	if(!value["EnableMLCtrl"].isNull())
+		enableMLCtrl_ = value["EnableMLCtrl"].asString() == "true";
 	if(!value["EnableCdc"].isNull())
 		enableCdc_ = value["EnableCdc"].asString() == "true";
 	if(!value["EnableStream"].isNull())
 		enableStream_ = value["EnableStream"].asString() == "true";
+	if(!value["EnableLTS"].isNull())
+		enableLTS_ = value["EnableLTS"].asString() == "true";
 	if(!value["EnableShs"].isNull())
 		enableShs_ = value["EnableShs"].asString() == "true";
+	if(!value["EnableBlob"].isNull())
+		enableBlob_ = value["EnableBlob"].asString() == "true";
 	if(!value["MaintainStartTime"].isNull())
 		maintainStartTime_ = value["MaintainStartTime"].asString();
 	if(!value["MaintainEndTime"].isNull())
@@ -163,6 +171,10 @@ void GetLindormInstanceResult::parse(const std::string &payload)
 		logNum_ = std::stoi(value["LogNum"].asString());
 	if(!value["LogSingleStorage"].isNull())
 		logSingleStorage_ = std::stoi(value["LogSingleStorage"].asString());
+	if(!value["ArchVersion"].isNull())
+		archVersion_ = value["ArchVersion"].asString();
+	if(!value["EnableLsqlVersionV3"].isNull())
+		enableLsqlVersionV3_ = value["EnableLsqlVersionV3"].asString() == "true";
 
 }
 
@@ -181,6 +193,11 @@ std::vector<GetLindormInstanceResult::Engine> GetLindormInstanceResult::getEngin
 	return engineList_;
 }
 
+bool GetLindormInstanceResult::getEnableLTS()const
+{
+	return enableLTS_;
+}
+
 std::string GetLindormInstanceResult::getResourceGroupId()const
 {
 	return resourceGroupId_;
@@ -301,6 +318,11 @@ bool GetLindormInstanceResult::getEnableCdc()const
 	return enableCdc_;
 }
 
+bool GetLindormInstanceResult::getEnableMLCtrl()const
+{
+	return enableMLCtrl_;
+}
+
 bool GetLindormInstanceResult::getEnableStream()const
 {
 	return enableStream_;
@@ -321,6 +343,11 @@ std::string GetLindormInstanceResult::getExpireTime()const
 	return expireTime_;
 }
 
+bool GetLindormInstanceResult::getEnableML()const
+{
+	return enableML_;
+}
+
 int GetLindormInstanceResult::getLogNum()const
 {
 	return logNum_;
@@ -331,11 +358,21 @@ int GetLindormInstanceResult::getLocalCloudStorage()const
 	return localCloudStorage_;
 }
 
+bool GetLindormInstanceResult::getEnableBlob()const
+{
+	return enableBlob_;
+}
+
 std::string GetLindormInstanceResult::getDiskThreshold()const
 {
 	return diskThreshold_;
 }
 
+bool GetLindormInstanceResult::getEnableLsqlVersionV3()const
+{
+	return enableLsqlVersionV3_;
+}
+
 bool GetLindormInstanceResult::getAutoRenew()const
 {
 	return autoRenew_;
@@ -401,6 +438,11 @@ int GetLindormInstanceResult::getCoreNum()const
 	return coreNum_;
 }
 
+std::string GetLindormInstanceResult::getArchVersion()const
+{
+	return archVersion_;
+}
+
 std::string GetLindormInstanceResult::getCreateTime()const
 {
 	return createTime_;

hitsdb/src/model/ReleaseLindormInstanceRequest.cc

@@ -34,6 +34,15 @@ void ReleaseLindormInstanceRequest::setResourceOwnerId(long resourceOwnerId) {
   setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
+bool ReleaseLindormInstanceRequest::getImmediately() const {
+  return immediately_;
+}
+
+void ReleaseLindormInstanceRequest::setImmediately(bool immediately) {
+  immediately_ = immediately;
+  setParameter(std::string("Immediately"), immediately ? "true" : "false");
+}
+
 std::string ReleaseLindormInstanceRequest::getAccessKeyId() const {
   return accessKeyId_;
 }

hitsdb/src/model/UpdateInstanceIpWhiteListRequest.cc

@@ -34,6 +34,15 @@ void UpdateInstanceIpWhiteListRequest::setResourceOwnerId(long resourceOwnerId)
   setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
+bool UpdateInstanceIpWhiteListRequest::get_Delete() const {
+  return _delete_;
+}
+
+void UpdateInstanceIpWhiteListRequest::set_Delete(bool _delete) {
+  _delete_ = _delete;
+  setParameter(std::string("Delete"), _delete ? "true" : "false");
+}
+
 std::string UpdateInstanceIpWhiteListRequest::getAccessKeyId() const {
   return accessKeyId_;
 }

hitsdb/src/model/UpgradeLindormInstanceRequest.cc

@@ -34,22 +34,112 @@ void UpgradeLindormInstanceRequest::setResourceOwnerId(long resourceOwnerId) {
   setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-int UpgradeLindormInstanceRequest::getPhoenixCoreNum() const {
-  return phoenixCoreNum_;
+std::string UpgradeLindormInstanceRequest::getLogSpec() const {
+  return logSpec_;
+}
+
+void UpgradeLindormInstanceRequest::setLogSpec(const std::string &logSpec) {
+  logSpec_ = logSpec;
+  setParameter(std::string("LogSpec"), logSpec);
+}
+
+std::string UpgradeLindormInstanceRequest::getSecurityToken() const {
+  return securityToken_;
+}
+
+void UpgradeLindormInstanceRequest::setSecurityToken(const std::string &securityToken) {
+  securityToken_ = securityToken;
+  setParameter(std::string("SecurityToken"), securityToken);
+}
+
+int UpgradeLindormInstanceRequest::getTsdbNum() const {
+  return tsdbNum_;
+}
+
+void UpgradeLindormInstanceRequest::setTsdbNum(int tsdbNum) {
+  tsdbNum_ = tsdbNum;
+  setParameter(std::string("TsdbNum"), std::to_string(tsdbNum));
+}
+
+int UpgradeLindormInstanceRequest::getSolrNum() const {
+  return solrNum_;
+}
+
+void UpgradeLindormInstanceRequest::setSolrNum(int solrNum) {
+  solrNum_ = solrNum;
+  setParameter(std::string("SolrNum"), std::to_string(solrNum));
+}
+
+long UpgradeLindormInstanceRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void UpgradeLindormInstanceRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void UpgradeLindormInstanceRequest::setPhoenixCoreNum(int phoenixCoreNum) {
-  phoenixCoreNum_ = phoenixCoreNum;
-  setParameter(std::string("PhoenixCoreNum"), std::to_string(phoenixCoreNum));
+int UpgradeLindormInstanceRequest::getLindormNum() const {
+  return lindormNum_;
+}
+
+void UpgradeLindormInstanceRequest::setLindormNum(int lindormNum) {
+  lindormNum_ = lindormNum;
+  setParameter(std::string("LindormNum"), std::to_string(lindormNum));
+}
+
+int UpgradeLindormInstanceRequest::getLtsCoreNum() const {
+  return ltsCoreNum_;
 }
 
-std::string UpgradeLindormInstanceRequest::getPhoenixCoreSpec() const {
-  return phoenixCoreSpec_;
+void UpgradeLindormInstanceRequest::setLtsCoreNum(int ltsCoreNum) {
+  ltsCoreNum_ = ltsCoreNum;
+  setParameter(std::string("LtsCoreNum"), std::to_string(ltsCoreNum));
+}
+
+std::string UpgradeLindormInstanceRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void UpgradeLindormInstanceRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+
+int UpgradeLindormInstanceRequest::getMlNum() const {
+  return mlNum_;
+}
+
+void UpgradeLindormInstanceRequest::setMlNum(int mlNum) {
+  mlNum_ = mlNum;
+  setParameter(std::string("MlNum"), std::to_string(mlNum));
+}
+
+int UpgradeLindormInstanceRequest::getStreamNum() const {
+  return streamNum_;
+}
+
+void UpgradeLindormInstanceRequest::setStreamNum(int streamNum) {
+  streamNum_ = streamNum;
+  setParameter(std::string("StreamNum"), std::to_string(streamNum));
+}
+
+int UpgradeLindormInstanceRequest::getLogSingleStorage() const {
+  return logSingleStorage_;
+}
+
+void UpgradeLindormInstanceRequest::setLogSingleStorage(int logSingleStorage) {
+  logSingleStorage_ = logSingleStorage;
+  setParameter(std::string("LogSingleStorage"), std::to_string(logSingleStorage));
+}
+
+std::string UpgradeLindormInstanceRequest::getZoneId() const {
+  return zoneId_;
 }
 
-void UpgradeLindormInstanceRequest::setPhoenixCoreSpec(const std::string &phoenixCoreSpec) {
-  phoenixCoreSpec_ = phoenixCoreSpec;
-  setParameter(std::string("PhoenixCoreSpec"), phoenixCoreSpec);
+void UpgradeLindormInstanceRequest::setZoneId(const std::string &zoneId) {
+  zoneId_ = zoneId;
+  setParameter(std::string("ZoneId"), zoneId);
 }
 
 std::string UpgradeLindormInstanceRequest::getClientToken() const {
@@ -97,24 +187,6 @@ void UpgradeLindormInstanceRequest::setAccessKeyId(const std::string &accessKeyI
   setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-std::string UpgradeLindormInstanceRequest::getLogSpec() const {
-  return logSpec_;
-}
-
-void UpgradeLindormInstanceRequest::setLogSpec(const std::string &logSpec) {
-  logSpec_ = logSpec;
-  setParameter(std::string("LogSpec"), logSpec);
-}
-
-std::string UpgradeLindormInstanceRequest::getSecurityToken() const {
-  return securityToken_;
-}
-
-void UpgradeLindormInstanceRequest::setSecurityToken(const std::string &securityToken) {
-  securityToken_ = securityToken;
-  setParameter(std::string("SecurityToken"), securityToken);
-}
-
 std::string UpgradeLindormInstanceRequest::getRegionId() const {
   return regionId_;
 }
@@ -124,15 +196,6 @@ void UpgradeLindormInstanceRequest::setRegionId(const std::string &regionId) {
   setParameter(std::string("RegionId"), regionId);
 }
 
-int UpgradeLindormInstanceRequest::getTsdbNum() const {
-  return tsdbNum_;
-}
-
-void UpgradeLindormInstanceRequest::setTsdbNum(int tsdbNum) {
-  tsdbNum_ = tsdbNum;
-  setParameter(std::string("TsdbNum"), std::to_string(tsdbNum));
-}
-
 std::string UpgradeLindormInstanceRequest::getLindormSpec() const {
   return lindormSpec_;
 }
@@ -142,15 +205,6 @@ void UpgradeLindormInstanceRequest::setLindormSpec(const std::string &lindormSpe
   setParameter(std::string("LindormSpec"), lindormSpec);
 }
 
-int UpgradeLindormInstanceRequest::getSolrNum() const {
-  return solrNum_;
-}
-
-void UpgradeLindormInstanceRequest::setSolrNum(int solrNum) {
-  solrNum_ = solrNum;
-  setParameter(std::string("SolrNum"), std::to_string(solrNum));
-}
-
 int UpgradeLindormInstanceRequest::getColdStorage() const {
   return coldStorage_;
 }
@@ -214,40 +268,22 @@ void UpgradeLindormInstanceRequest::setFilestoreNum(int filestoreNum) {
   setParameter(std::string("FilestoreNum"), std::to_string(filestoreNum));
 }
 
-long UpgradeLindormInstanceRequest::getOwnerId() const {
-  return ownerId_;
-}
-
-void UpgradeLindormInstanceRequest::setOwnerId(long ownerId) {
-  ownerId_ = ownerId;
-  setParameter(std::string("OwnerId"), std::to_string(ownerId));
-}
-
-int UpgradeLindormInstanceRequest::getLindormNum() const {
-  return lindormNum_;
-}
-
-void UpgradeLindormInstanceRequest::setLindormNum(int lindormNum) {
-  lindormNum_ = lindormNum;
-  setParameter(std::string("LindormNum"), std::to_string(lindormNum));
+std::string UpgradeLindormInstanceRequest::getStreamSpec() const {
+  return streamSpec_;
 }
 
-int UpgradeLindormInstanceRequest::getLtsCoreNum() const {
-  return ltsCoreNum_;
+void UpgradeLindormInstanceRequest::setStreamSpec(const std::string &streamSpec) {
+  streamSpec_ = streamSpec;
+  setParameter(std::string("StreamSpec"), streamSpec);
 }
 
-void UpgradeLindormInstanceRequest::setLtsCoreNum(int ltsCoreNum) {
-  ltsCoreNum_ = ltsCoreNum;
-  setParameter(std::string("LtsCoreNum"), std::to_string(ltsCoreNum));
+std::string UpgradeLindormInstanceRequest::getMlSpec() const {
+  return mlSpec_;
 }
 
-std::string UpgradeLindormInstanceRequest::getInstanceId() const {
-  return instanceId_;
-}
-
-void UpgradeLindormInstanceRequest::setInstanceId(const std::string &instanceId) {
-  instanceId_ = instanceId;
-  setParameter(std::string("InstanceId"), instanceId);
+void UpgradeLindormInstanceRequest::setMlSpec(const std::string &mlSpec) {
+  mlSpec_ = mlSpec;
+  setParameter(std::string("MlSpec"), mlSpec);
 }
 
 std::string UpgradeLindormInstanceRequest::getLtsCoreSpec() const {
@@ -268,21 +304,3 @@ void UpgradeLindormInstanceRequest::setClusterStorage(int clusterStorage) {
   setParameter(std::string("ClusterStorage"), std::to_string(clusterStorage));
 }
 
-int UpgradeLindormInstanceRequest::getLogSingleStorage() const {
-  return logSingleStorage_;
-}
-
-void UpgradeLindormInstanceRequest::setLogSingleStorage(int logSingleStorage) {
-  logSingleStorage_ = logSingleStorage;
-  setParameter(std::string("LogSingleStorage"), std::to_string(logSingleStorage));
-}
-
-std::string UpgradeLindormInstanceRequest::getZoneId() const {
-  return zoneId_;
-}
-
-void UpgradeLindormInstanceRequest::setZoneId(const std::string &zoneId) {
-  zoneId_ = zoneId;
-  setParameter(std::string("ZoneId"), zoneId);
-}
-