Add ImageFamily paramters and apis, in Instance creation apis and Image query apis, and add DescribeImageFromFamily.

CHANGELOG

@@ -1,3 +1,23 @@
+2020-03-16 Version: 1.36.319
+- Add ImageFamily paramters and apis, in Instance creation apis and Image query apis, and add DescribeImageFromFamily.
+- Add Instance batch operation apis RebootInstances StartInstances and StopInstances.
+- Add EncryptAlgorithm paramter in instance creati
+
+2020-03-13 Version: 1.36.318
+- ACM POP SDK.
+
+2020-03-12 Version: 1.36.317
+- Add new Api SegmentBody.
+
+2020-03-11 Version: 1.36.316
+- Update structure for DescribeAvailableResource without compatible.
+
+2020-03-11 Version: 1.36.315
+- Add new Api SegmentBody.
+
+2020-03-11 Version: 1.36.314
+- Support certificate translate.
+
 2020-03-10 Version: 1.36.313
 - Add ExportTas apis.
 

VERSION

@@ -1 +1 @@
-1.36.313
+1.36.319

acms-open/CMakeLists.txt

@@ -0,0 +1,114 @@
+#
+# 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.
+#
+
+set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
+
+set(acms-open_public_header 
+	include/alibabacloud/acms-open/Acms_openClient.h
+	include/alibabacloud/acms-open/Acms_openExport.h )
+
+set(acms-open_public_header_model 
+	include/alibabacloud/acms-open/model/CreateConfigurationRequest.h
+	include/alibabacloud/acms-open/model/CreateConfigurationResult.h
+	include/alibabacloud/acms-open/model/CreateNamespaceRequest.h
+	include/alibabacloud/acms-open/model/CreateNamespaceResult.h
+	include/alibabacloud/acms-open/model/DeleteConfigurationRequest.h
+	include/alibabacloud/acms-open/model/DeleteConfigurationResult.h
+	include/alibabacloud/acms-open/model/DeleteNamespaceRequest.h
+	include/alibabacloud/acms-open/model/DeleteNamespaceResult.h
+	include/alibabacloud/acms-open/model/DeployConfigurationRequest.h
+	include/alibabacloud/acms-open/model/DeployConfigurationResult.h
+	include/alibabacloud/acms-open/model/DescribeConfigurationRequest.h
+	include/alibabacloud/acms-open/model/DescribeConfigurationResult.h
+	include/alibabacloud/acms-open/model/DescribeNamespaceRequest.h
+	include/alibabacloud/acms-open/model/DescribeNamespaceResult.h
+	include/alibabacloud/acms-open/model/UpdateNamespaceRequest.h
+	include/alibabacloud/acms-open/model/UpdateNamespaceResult.h )
+
+set(acms-open_src 
+	src/Acms-openClient.cc
+	src/model/CreateConfigurationRequest.cc
+	src/model/CreateConfigurationResult.cc
+	src/model/CreateNamespaceRequest.cc
+	src/model/CreateNamespaceResult.cc
+	src/model/DeleteConfigurationRequest.cc
+	src/model/DeleteConfigurationResult.cc
+	src/model/DeleteNamespaceRequest.cc
+	src/model/DeleteNamespaceResult.cc
+	src/model/DeployConfigurationRequest.cc
+	src/model/DeployConfigurationResult.cc
+	src/model/DescribeConfigurationRequest.cc
+	src/model/DescribeConfigurationResult.cc
+	src/model/DescribeNamespaceRequest.cc
+	src/model/DescribeNamespaceResult.cc
+	src/model/UpdateNamespaceRequest.cc
+	src/model/UpdateNamespaceResult.cc )
+
+add_library(acms-open ${LIB_TYPE}
+	${acms-open_public_header}
+	${acms-open_public_header_model}
+	${acms-open_src})
+
+set_target_properties(acms-open
+	PROPERTIES
+	LINKER_LANGUAGE CXX
+	ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+	OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}acms-open
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(acms-open
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_ACMS_OPEN_LIBRARY)
+endif()
+
+target_include_directories(acms-open
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(acms-open
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(acms-open
+		jsoncpp)
+	target_include_directories(acms-open
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(acms-open
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(acms-open
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(acms-open
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(acms-open
+		jsoncpp)
+endif()
+
+install(FILES ${acms-open_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/acms-open)
+install(FILES ${acms-open_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/acms-open/model)
+install(TARGETS acms-open
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

acms-open/include/alibabacloud/acms-open/Acms_openClient.h

@@ -0,0 +1,110 @@
+/*
+ * 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_ACMS_OPEN_ACMS_OPENCLIENT_H_
+#define ALIBABACLOUD_ACMS_OPEN_ACMS_OPENCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RoaServiceClient.h>
+#include "Acms_openExport.h"
+#include "model/CreateConfigurationRequest.h"
+#include "model/CreateConfigurationResult.h"
+#include "model/CreateNamespaceRequest.h"
+#include "model/CreateNamespaceResult.h"
+#include "model/DeleteConfigurationRequest.h"
+#include "model/DeleteConfigurationResult.h"
+#include "model/DeleteNamespaceRequest.h"
+#include "model/DeleteNamespaceResult.h"
+#include "model/DeployConfigurationRequest.h"
+#include "model/DeployConfigurationResult.h"
+#include "model/DescribeConfigurationRequest.h"
+#include "model/DescribeConfigurationResult.h"
+#include "model/DescribeNamespaceRequest.h"
+#include "model/DescribeNamespaceResult.h"
+#include "model/UpdateNamespaceRequest.h"
+#include "model/UpdateNamespaceResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Acms_open
+	{
+		class ALIBABACLOUD_ACMS_OPEN_EXPORT Acms_openClient : public RoaServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::CreateConfigurationResult> CreateConfigurationOutcome;
+			typedef std::future<CreateConfigurationOutcome> CreateConfigurationOutcomeCallable;
+			typedef std::function<void(const Acms_openClient*, const Model::CreateConfigurationRequest&, const CreateConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateConfigurationAsyncHandler;
+			typedef Outcome<Error, Model::CreateNamespaceResult> CreateNamespaceOutcome;
+			typedef std::future<CreateNamespaceOutcome> CreateNamespaceOutcomeCallable;
+			typedef std::function<void(const Acms_openClient*, const Model::CreateNamespaceRequest&, const CreateNamespaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateNamespaceAsyncHandler;
+			typedef Outcome<Error, Model::DeleteConfigurationResult> DeleteConfigurationOutcome;
+			typedef std::future<DeleteConfigurationOutcome> DeleteConfigurationOutcomeCallable;
+			typedef std::function<void(const Acms_openClient*, const Model::DeleteConfigurationRequest&, const DeleteConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteConfigurationAsyncHandler;
+			typedef Outcome<Error, Model::DeleteNamespaceResult> DeleteNamespaceOutcome;
+			typedef std::future<DeleteNamespaceOutcome> DeleteNamespaceOutcomeCallable;
+			typedef std::function<void(const Acms_openClient*, const Model::DeleteNamespaceRequest&, const DeleteNamespaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteNamespaceAsyncHandler;
+			typedef Outcome<Error, Model::DeployConfigurationResult> DeployConfigurationOutcome;
+			typedef std::future<DeployConfigurationOutcome> DeployConfigurationOutcomeCallable;
+			typedef std::function<void(const Acms_openClient*, const Model::DeployConfigurationRequest&, const DeployConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeployConfigurationAsyncHandler;
+			typedef Outcome<Error, Model::DescribeConfigurationResult> DescribeConfigurationOutcome;
+			typedef std::future<DescribeConfigurationOutcome> DescribeConfigurationOutcomeCallable;
+			typedef std::function<void(const Acms_openClient*, const Model::DescribeConfigurationRequest&, const DescribeConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeConfigurationAsyncHandler;
+			typedef Outcome<Error, Model::DescribeNamespaceResult> DescribeNamespaceOutcome;
+			typedef std::future<DescribeNamespaceOutcome> DescribeNamespaceOutcomeCallable;
+			typedef std::function<void(const Acms_openClient*, const Model::DescribeNamespaceRequest&, const DescribeNamespaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeNamespaceAsyncHandler;
+			typedef Outcome<Error, Model::UpdateNamespaceResult> UpdateNamespaceOutcome;
+			typedef std::future<UpdateNamespaceOutcome> UpdateNamespaceOutcomeCallable;
+			typedef std::function<void(const Acms_openClient*, const Model::UpdateNamespaceRequest&, const UpdateNamespaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateNamespaceAsyncHandler;
+
+			Acms_openClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			Acms_openClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			Acms_openClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~Acms_openClient();
+			CreateConfigurationOutcome createConfiguration(const Model::CreateConfigurationRequest &request)const;
+			void createConfigurationAsync(const Model::CreateConfigurationRequest& request, const CreateConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateConfigurationOutcomeCallable createConfigurationCallable(const Model::CreateConfigurationRequest& request) const;
+			CreateNamespaceOutcome createNamespace(const Model::CreateNamespaceRequest &request)const;
+			void createNamespaceAsync(const Model::CreateNamespaceRequest& request, const CreateNamespaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateNamespaceOutcomeCallable createNamespaceCallable(const Model::CreateNamespaceRequest& request) const;
+			DeleteConfigurationOutcome deleteConfiguration(const Model::DeleteConfigurationRequest &request)const;
+			void deleteConfigurationAsync(const Model::DeleteConfigurationRequest& request, const DeleteConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteConfigurationOutcomeCallable deleteConfigurationCallable(const Model::DeleteConfigurationRequest& request) const;
+			DeleteNamespaceOutcome deleteNamespace(const Model::DeleteNamespaceRequest &request)const;
+			void deleteNamespaceAsync(const Model::DeleteNamespaceRequest& request, const DeleteNamespaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteNamespaceOutcomeCallable deleteNamespaceCallable(const Model::DeleteNamespaceRequest& request) const;
+			DeployConfigurationOutcome deployConfiguration(const Model::DeployConfigurationRequest &request)const;
+			void deployConfigurationAsync(const Model::DeployConfigurationRequest& request, const DeployConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeployConfigurationOutcomeCallable deployConfigurationCallable(const Model::DeployConfigurationRequest& request) const;
+			DescribeConfigurationOutcome describeConfiguration(const Model::DescribeConfigurationRequest &request)const;
+			void describeConfigurationAsync(const Model::DescribeConfigurationRequest& request, const DescribeConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeConfigurationOutcomeCallable describeConfigurationCallable(const Model::DescribeConfigurationRequest& request) const;
+			DescribeNamespaceOutcome describeNamespace(const Model::DescribeNamespaceRequest &request)const;
+			void describeNamespaceAsync(const Model::DescribeNamespaceRequest& request, const DescribeNamespaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeNamespaceOutcomeCallable describeNamespaceCallable(const Model::DescribeNamespaceRequest& request) const;
+			UpdateNamespaceOutcome updateNamespace(const Model::UpdateNamespaceRequest &request)const;
+			void updateNamespaceAsync(const Model::UpdateNamespaceRequest& request, const UpdateNamespaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateNamespaceOutcomeCallable updateNamespaceCallable(const Model::UpdateNamespaceRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_ACMS_OPEN_ACMS_OPENCLIENT_H_

acms-open/include/alibabacloud/acms-open/Acms_openExport.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ACMS_OPEN_ACMS_OPENEXPORT_H_
+#define ALIBABACLOUD_ACMS_OPEN_ACMS_OPENEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_ACMS_OPEN_LIBRARY)
+#		define ALIBABACLOUD_ACMS_OPEN_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_ACMS_OPEN_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_ACMS_OPEN_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_ACMS_OPEN_ACMS_OPENEXPORT_H_

acms-open/include/alibabacloud/acms-open/model/CreateConfigurationRequest.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ACMS_OPEN_MODEL_CREATECONFIGURATIONREQUEST_H_
+#define ALIBABACLOUD_ACMS_OPEN_MODEL_CREATECONFIGURATIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/acms-open/Acms_openExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Acms_open
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACMS_OPEN_EXPORT CreateConfigurationRequest : public RoaServiceRequest
+			{
+
+			public:
+				CreateConfigurationRequest();
+				~CreateConfigurationRequest();
+
+				std::string getDataId()const;
+				void setDataId(const std::string& dataId);
+				std::string getAppName()const;
+				void setAppName(const std::string& appName);
+				std::string getNamespaceId()const;
+				void setNamespaceId(const std::string& namespaceId);
+				std::string getType()const;
+				void setType(const std::string& type);
+				std::string getContent()const;
+				void setContent(const std::string& content);
+				std::string getGroup()const;
+				void setGroup(const std::string& group);
+				std::string getDesc()const;
+				void setDesc(const std::string& desc);
+				std::string getTags()const;
+				void setTags(const std::string& tags);
+
+            private:
+				std::string dataId_;
+				std::string appName_;
+				std::string namespaceId_;
+				std::string type_;
+				std::string content_;
+				std::string group_;
+				std::string desc_;
+				std::string tags_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACMS_OPEN_MODEL_CREATECONFIGURATIONREQUEST_H_

acms-open/include/alibabacloud/acms-open/model/CreateConfigurationResult.h

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

acms-open/include/alibabacloud/acms-open/model/CreateNamespaceRequest.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_ACMS_OPEN_MODEL_CREATENAMESPACEREQUEST_H_
+#define ALIBABACLOUD_ACMS_OPEN_MODEL_CREATENAMESPACEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/acms-open/Acms_openExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Acms_open
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACMS_OPEN_EXPORT CreateNamespaceRequest : public RoaServiceRequest
+			{
+
+			public:
+				CreateNamespaceRequest();
+				~CreateNamespaceRequest();
+
+				std::string getName()const;
+				void setName(const std::string& name);
+
+            private:
+				std::string name_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACMS_OPEN_MODEL_CREATENAMESPACEREQUEST_H_

acms-open/include/alibabacloud/acms-open/model/CreateNamespaceResult.h

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

acms-open/include/alibabacloud/acms-open/model/DeleteConfigurationRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ACMS_OPEN_MODEL_DELETECONFIGURATIONREQUEST_H_
+#define ALIBABACLOUD_ACMS_OPEN_MODEL_DELETECONFIGURATIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/acms-open/Acms_openExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Acms_open
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACMS_OPEN_EXPORT DeleteConfigurationRequest : public RoaServiceRequest
+			{
+
+			public:
+				DeleteConfigurationRequest();
+				~DeleteConfigurationRequest();
+
+				std::string getDataId()const;
+				void setDataId(const std::string& dataId);
+				std::string getNamespaceId()const;
+				void setNamespaceId(const std::string& namespaceId);
+				std::string getGroup()const;
+				void setGroup(const std::string& group);
+
+            private:
+				std::string dataId_;
+				std::string namespaceId_;
+				std::string group_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACMS_OPEN_MODEL_DELETECONFIGURATIONREQUEST_H_

acms-open/include/alibabacloud/acms-open/model/DeleteConfigurationResult.h

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

acms-open/include/alibabacloud/acms-open/model/DeleteNamespaceRequest.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_ACMS_OPEN_MODEL_DELETENAMESPACEREQUEST_H_
+#define ALIBABACLOUD_ACMS_OPEN_MODEL_DELETENAMESPACEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/acms-open/Acms_openExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Acms_open
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACMS_OPEN_EXPORT DeleteNamespaceRequest : public RoaServiceRequest
+			{
+
+			public:
+				DeleteNamespaceRequest();
+				~DeleteNamespaceRequest();
+
+				std::string getNamespaceId()const;
+				void setNamespaceId(const std::string& namespaceId);
+
+            private:
+				std::string namespaceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACMS_OPEN_MODEL_DELETENAMESPACEREQUEST_H_

acms-open/include/alibabacloud/acms-open/model/DeleteNamespaceResult.h

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

acms-open/include/alibabacloud/acms-open/model/DeployConfigurationRequest.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ACMS_OPEN_MODEL_DEPLOYCONFIGURATIONREQUEST_H_
+#define ALIBABACLOUD_ACMS_OPEN_MODEL_DEPLOYCONFIGURATIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/acms-open/Acms_openExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Acms_open
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACMS_OPEN_EXPORT DeployConfigurationRequest : public RoaServiceRequest
+			{
+
+			public:
+				DeployConfigurationRequest();
+				~DeployConfigurationRequest();
+
+				std::string getDataId()const;
+				void setDataId(const std::string& dataId);
+				std::string getAppName()const;
+				void setAppName(const std::string& appName);
+				std::string getNamespaceId()const;
+				void setNamespaceId(const std::string& namespaceId);
+				std::string getType()const;
+				void setType(const std::string& type);
+				std::string getContent()const;
+				void setContent(const std::string& content);
+				std::string getGroup()const;
+				void setGroup(const std::string& group);
+				std::string getDesc()const;
+				void setDesc(const std::string& desc);
+				std::string getTags()const;
+				void setTags(const std::string& tags);
+
+            private:
+				std::string dataId_;
+				std::string appName_;
+				std::string namespaceId_;
+				std::string type_;
+				std::string content_;
+				std::string group_;
+				std::string desc_;
+				std::string tags_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACMS_OPEN_MODEL_DEPLOYCONFIGURATIONREQUEST_H_

acms-open/include/alibabacloud/acms-open/model/DeployConfigurationResult.h

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

acms-open/include/alibabacloud/acms-open/model/DescribeConfigurationRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ACMS_OPEN_MODEL_DESCRIBECONFIGURATIONREQUEST_H_
+#define ALIBABACLOUD_ACMS_OPEN_MODEL_DESCRIBECONFIGURATIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/acms-open/Acms_openExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Acms_open
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACMS_OPEN_EXPORT DescribeConfigurationRequest : public RoaServiceRequest
+			{
+
+			public:
+				DescribeConfigurationRequest();
+				~DescribeConfigurationRequest();
+
+				std::string getDataId()const;
+				void setDataId(const std::string& dataId);
+				std::string getNamespaceId()const;
+				void setNamespaceId(const std::string& namespaceId);
+				std::string getGroup()const;
+				void setGroup(const std::string& group);
+
+            private:
+				std::string dataId_;
+				std::string namespaceId_;
+				std::string group_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACMS_OPEN_MODEL_DESCRIBECONFIGURATIONREQUEST_H_

acms-open/include/alibabacloud/acms-open/model/DescribeConfigurationResult.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ACMS_OPEN_MODEL_DESCRIBECONFIGURATIONRESULT_H_
+#define ALIBABACLOUD_ACMS_OPEN_MODEL_DESCRIBECONFIGURATIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/acms-open/Acms_openExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Acms_open
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACMS_OPEN_EXPORT DescribeConfigurationResult : public ServiceResult
+			{
+			public:
+				struct Configuration
+				{
+					std::string group;
+					std::string desc;
+					std::string dataId;
+					std::string content;
+					std::string tags;
+					std::string md5;
+					std::string appName;
+				};
+
+
+				DescribeConfigurationResult();
+				explicit DescribeConfigurationResult(const std::string &payload);
+				~DescribeConfigurationResult();
+				Configuration getConfiguration()const;
+				std::string getMessage()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Configuration configuration_;
+				std::string message_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACMS_OPEN_MODEL_DESCRIBECONFIGURATIONRESULT_H_

acms-open/include/alibabacloud/acms-open/model/DescribeNamespaceRequest.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_ACMS_OPEN_MODEL_DESCRIBENAMESPACEREQUEST_H_
+#define ALIBABACLOUD_ACMS_OPEN_MODEL_DESCRIBENAMESPACEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/acms-open/Acms_openExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Acms_open
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACMS_OPEN_EXPORT DescribeNamespaceRequest : public RoaServiceRequest
+			{
+
+			public:
+				DescribeNamespaceRequest();
+				~DescribeNamespaceRequest();
+
+				std::string getNamespaceId()const;
+				void setNamespaceId(const std::string& namespaceId);
+
+            private:
+				std::string namespaceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACMS_OPEN_MODEL_DESCRIBENAMESPACEREQUEST_H_

acms-open/include/alibabacloud/acms-open/model/DescribeNamespaceResult.h

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

acms-open/include/alibabacloud/acms-open/model/UpdateNamespaceRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ACMS_OPEN_MODEL_UPDATENAMESPACEREQUEST_H_
+#define ALIBABACLOUD_ACMS_OPEN_MODEL_UPDATENAMESPACEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/acms-open/Acms_openExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Acms_open
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACMS_OPEN_EXPORT UpdateNamespaceRequest : public RoaServiceRequest
+			{
+
+			public:
+				UpdateNamespaceRequest();
+				~UpdateNamespaceRequest();
+
+				std::string getNamespaceName()const;
+				void setNamespaceName(const std::string& namespaceName);
+				std::string getNamespaceId()const;
+				void setNamespaceId(const std::string& namespaceId);
+
+            private:
+				std::string namespaceName_;
+				std::string namespaceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACMS_OPEN_MODEL_UPDATENAMESPACEREQUEST_H_

acms-open/include/alibabacloud/acms-open/model/UpdateNamespaceResult.h

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

acms-open/src/Acms-openClient.cc

@@ -0,0 +1,341 @@
+/*
+ * 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/acms-open/Acms_openClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::Acms_open;
+using namespace AlibabaCloud::Acms_open::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "acms-open";
+}
+
+Acms_openClient::Acms_openClient(const Credentials &credentials, const ClientConfiguration &configuration) :
+	RoaServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "acms");
+}
+
+Acms_openClient::Acms_openClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
+	RoaServiceClient(SERVICE_NAME, credentialsProvider, configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "acms");
+}
+
+Acms_openClient::Acms_openClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
+	RoaServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "acms");
+}
+
+Acms_openClient::~Acms_openClient()
+{}
+
+Acms_openClient::CreateConfigurationOutcome Acms_openClient::createConfiguration(const CreateConfigurationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateConfigurationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateConfigurationOutcome(CreateConfigurationResult(outcome.result()));
+	else
+		return CreateConfigurationOutcome(outcome.error());
+}
+
+void Acms_openClient::createConfigurationAsync(const CreateConfigurationRequest& request, const CreateConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createConfiguration(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Acms_openClient::CreateConfigurationOutcomeCallable Acms_openClient::createConfigurationCallable(const CreateConfigurationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateConfigurationOutcome()>>(
+			[this, request]()
+			{
+			return this->createConfiguration(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Acms_openClient::CreateNamespaceOutcome Acms_openClient::createNamespace(const CreateNamespaceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateNamespaceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateNamespaceOutcome(CreateNamespaceResult(outcome.result()));
+	else
+		return CreateNamespaceOutcome(outcome.error());
+}
+
+void Acms_openClient::createNamespaceAsync(const CreateNamespaceRequest& request, const CreateNamespaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createNamespace(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Acms_openClient::CreateNamespaceOutcomeCallable Acms_openClient::createNamespaceCallable(const CreateNamespaceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateNamespaceOutcome()>>(
+			[this, request]()
+			{
+			return this->createNamespace(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Acms_openClient::DeleteConfigurationOutcome Acms_openClient::deleteConfiguration(const DeleteConfigurationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteConfigurationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteConfigurationOutcome(DeleteConfigurationResult(outcome.result()));
+	else
+		return DeleteConfigurationOutcome(outcome.error());
+}
+
+void Acms_openClient::deleteConfigurationAsync(const DeleteConfigurationRequest& request, const DeleteConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteConfiguration(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Acms_openClient::DeleteConfigurationOutcomeCallable Acms_openClient::deleteConfigurationCallable(const DeleteConfigurationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteConfigurationOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteConfiguration(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Acms_openClient::DeleteNamespaceOutcome Acms_openClient::deleteNamespace(const DeleteNamespaceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteNamespaceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteNamespaceOutcome(DeleteNamespaceResult(outcome.result()));
+	else
+		return DeleteNamespaceOutcome(outcome.error());
+}
+
+void Acms_openClient::deleteNamespaceAsync(const DeleteNamespaceRequest& request, const DeleteNamespaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteNamespace(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Acms_openClient::DeleteNamespaceOutcomeCallable Acms_openClient::deleteNamespaceCallable(const DeleteNamespaceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteNamespaceOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteNamespace(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Acms_openClient::DeployConfigurationOutcome Acms_openClient::deployConfiguration(const DeployConfigurationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeployConfigurationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeployConfigurationOutcome(DeployConfigurationResult(outcome.result()));
+	else
+		return DeployConfigurationOutcome(outcome.error());
+}
+
+void Acms_openClient::deployConfigurationAsync(const DeployConfigurationRequest& request, const DeployConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deployConfiguration(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Acms_openClient::DeployConfigurationOutcomeCallable Acms_openClient::deployConfigurationCallable(const DeployConfigurationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeployConfigurationOutcome()>>(
+			[this, request]()
+			{
+			return this->deployConfiguration(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Acms_openClient::DescribeConfigurationOutcome Acms_openClient::describeConfiguration(const DescribeConfigurationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeConfigurationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeConfigurationOutcome(DescribeConfigurationResult(outcome.result()));
+	else
+		return DescribeConfigurationOutcome(outcome.error());
+}
+
+void Acms_openClient::describeConfigurationAsync(const DescribeConfigurationRequest& request, const DescribeConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeConfiguration(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Acms_openClient::DescribeConfigurationOutcomeCallable Acms_openClient::describeConfigurationCallable(const DescribeConfigurationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeConfigurationOutcome()>>(
+			[this, request]()
+			{
+			return this->describeConfiguration(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Acms_openClient::DescribeNamespaceOutcome Acms_openClient::describeNamespace(const DescribeNamespaceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeNamespaceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeNamespaceOutcome(DescribeNamespaceResult(outcome.result()));
+	else
+		return DescribeNamespaceOutcome(outcome.error());
+}
+
+void Acms_openClient::describeNamespaceAsync(const DescribeNamespaceRequest& request, const DescribeNamespaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeNamespace(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Acms_openClient::DescribeNamespaceOutcomeCallable Acms_openClient::describeNamespaceCallable(const DescribeNamespaceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeNamespaceOutcome()>>(
+			[this, request]()
+			{
+			return this->describeNamespace(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Acms_openClient::UpdateNamespaceOutcome Acms_openClient::updateNamespace(const UpdateNamespaceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateNamespaceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateNamespaceOutcome(UpdateNamespaceResult(outcome.result()));
+	else
+		return UpdateNamespaceOutcome(outcome.error());
+}
+
+void Acms_openClient::updateNamespaceAsync(const UpdateNamespaceRequest& request, const UpdateNamespaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateNamespace(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Acms_openClient::UpdateNamespaceOutcomeCallable Acms_openClient::updateNamespaceCallable(const UpdateNamespaceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateNamespaceOutcome()>>(
+			[this, request]()
+			{
+			return this->updateNamespace(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

acms-open/src/model/CreateConfigurationRequest.cc

@@ -0,0 +1,118 @@
+/*
+ * 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/acms-open/model/CreateConfigurationRequest.h>
+
+using AlibabaCloud::Acms_open::Model::CreateConfigurationRequest;
+
+CreateConfigurationRequest::CreateConfigurationRequest() :
+	RoaServiceRequest("acms-open", "2020-02-06")
+{
+	setResourcePath("/diamond-ops/pop/configuration");
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateConfigurationRequest::~CreateConfigurationRequest()
+{}
+
+std::string CreateConfigurationRequest::getDataId()const
+{
+	return dataId_;
+}
+
+void CreateConfigurationRequest::setDataId(const std::string& dataId)
+{
+	dataId_ = dataId;
+	setBodyParameter("DataId", dataId);
+}
+
+std::string CreateConfigurationRequest::getAppName()const
+{
+	return appName_;
+}
+
+void CreateConfigurationRequest::setAppName(const std::string& appName)
+{
+	appName_ = appName;
+	setBodyParameter("AppName", appName);
+}
+
+std::string CreateConfigurationRequest::getNamespaceId()const
+{
+	return namespaceId_;
+}
+
+void CreateConfigurationRequest::setNamespaceId(const std::string& namespaceId)
+{
+	namespaceId_ = namespaceId;
+	setBodyParameter("NamespaceId", namespaceId);
+}
+
+std::string CreateConfigurationRequest::getType()const
+{
+	return type_;
+}
+
+void CreateConfigurationRequest::setType(const std::string& type)
+{
+	type_ = type;
+	setBodyParameter("Type", type);
+}
+
+std::string CreateConfigurationRequest::getContent()const
+{
+	return content_;
+}
+
+void CreateConfigurationRequest::setContent(const std::string& content)
+{
+	content_ = content;
+	setBodyParameter("Content", content);
+}
+
+std::string CreateConfigurationRequest::getGroup()const
+{
+	return group_;
+}
+
+void CreateConfigurationRequest::setGroup(const std::string& group)
+{
+	group_ = group;
+	setBodyParameter("Group", group);
+}
+
+std::string CreateConfigurationRequest::getDesc()const
+{
+	return desc_;
+}
+
+void CreateConfigurationRequest::setDesc(const std::string& desc)
+{
+	desc_ = desc;
+	setBodyParameter("Desc", desc);
+}
+
+std::string CreateConfigurationRequest::getTags()const
+{
+	return tags_;
+}
+
+void CreateConfigurationRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setBodyParameter("Tags", tags);
+}
+

acms-open/src/model/CreateConfigurationResult.cc

@@ -0,0 +1,58 @@
+/*
+ * 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/acms-open/model/CreateConfigurationResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Acms_open;
+using namespace AlibabaCloud::Acms_open::Model;
+
+CreateConfigurationResult::CreateConfigurationResult() :
+	ServiceResult()
+{}
+
+CreateConfigurationResult::CreateConfigurationResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateConfigurationResult::~CreateConfigurationResult()
+{}
+
+void CreateConfigurationResult::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["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string CreateConfigurationResult::getMessage()const
+{
+	return message_;
+}
+
+std::string CreateConfigurationResult::getCode()const
+{
+	return code_;
+}
+

acms-open/src/model/CreateNamespaceRequest.cc

@@ -0,0 +1,41 @@
+/*
+ * 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/acms-open/model/CreateNamespaceRequest.h>
+
+using AlibabaCloud::Acms_open::Model::CreateNamespaceRequest;
+
+CreateNamespaceRequest::CreateNamespaceRequest() :
+	RoaServiceRequest("acms-open", "2020-02-06")
+{
+	setResourcePath("/diamond-ops/pop/namespace");
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateNamespaceRequest::~CreateNamespaceRequest()
+{}
+
+std::string CreateNamespaceRequest::getName()const
+{
+	return name_;
+}
+
+void CreateNamespaceRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setBodyParameter("Name", name);
+}
+

acms-open/src/model/CreateNamespaceResult.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/acms-open/model/CreateNamespaceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Acms_open;
+using namespace AlibabaCloud::Acms_open::Model;
+
+CreateNamespaceResult::CreateNamespaceResult() :
+	ServiceResult()
+{}
+
+CreateNamespaceResult::CreateNamespaceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateNamespaceResult::~CreateNamespaceResult()
+{}
+
+void CreateNamespaceResult::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["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["NamespaceId"].isNull())
+		namespaceId_ = value["NamespaceId"].asString();
+
+}
+
+std::string CreateNamespaceResult::getMessage()const
+{
+	return message_;
+}
+
+std::string CreateNamespaceResult::getNamespaceId()const
+{
+	return namespaceId_;
+}
+
+std::string CreateNamespaceResult::getCode()const
+{
+	return code_;
+}
+

acms-open/src/model/DeleteConfigurationRequest.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/acms-open/model/DeleteConfigurationRequest.h>
+
+using AlibabaCloud::Acms_open::Model::DeleteConfigurationRequest;
+
+DeleteConfigurationRequest::DeleteConfigurationRequest() :
+	RoaServiceRequest("acms-open", "2020-02-06")
+{
+	setResourcePath("/diamond-ops/pop/configuration");
+	setMethod(HttpRequest::Method::Delete);
+}
+
+DeleteConfigurationRequest::~DeleteConfigurationRequest()
+{}
+
+std::string DeleteConfigurationRequest::getDataId()const
+{
+	return dataId_;
+}
+
+void DeleteConfigurationRequest::setDataId(const std::string& dataId)
+{
+	dataId_ = dataId;
+	setParameter("DataId", dataId);
+}
+
+std::string DeleteConfigurationRequest::getNamespaceId()const
+{
+	return namespaceId_;
+}
+
+void DeleteConfigurationRequest::setNamespaceId(const std::string& namespaceId)
+{
+	namespaceId_ = namespaceId;
+	setParameter("NamespaceId", namespaceId);
+}
+
+std::string DeleteConfigurationRequest::getGroup()const
+{
+	return group_;
+}
+
+void DeleteConfigurationRequest::setGroup(const std::string& group)
+{
+	group_ = group;
+	setParameter("Group", group);
+}
+

acms-open/src/model/DeleteConfigurationResult.cc

@@ -0,0 +1,58 @@
+/*
+ * 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/acms-open/model/DeleteConfigurationResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Acms_open;
+using namespace AlibabaCloud::Acms_open::Model;
+
+DeleteConfigurationResult::DeleteConfigurationResult() :
+	ServiceResult()
+{}
+
+DeleteConfigurationResult::DeleteConfigurationResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteConfigurationResult::~DeleteConfigurationResult()
+{}
+
+void DeleteConfigurationResult::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["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string DeleteConfigurationResult::getMessage()const
+{
+	return message_;
+}
+
+std::string DeleteConfigurationResult::getCode()const
+{
+	return code_;
+}
+

acms-open/src/model/DeleteNamespaceRequest.cc

@@ -0,0 +1,41 @@
+/*
+ * 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/acms-open/model/DeleteNamespaceRequest.h>
+
+using AlibabaCloud::Acms_open::Model::DeleteNamespaceRequest;
+
+DeleteNamespaceRequest::DeleteNamespaceRequest() :
+	RoaServiceRequest("acms-open", "2020-02-06")
+{
+	setResourcePath("/diamond-ops/pop/namespace");
+	setMethod(HttpRequest::Method::Delete);
+}
+
+DeleteNamespaceRequest::~DeleteNamespaceRequest()
+{}
+
+std::string DeleteNamespaceRequest::getNamespaceId()const
+{
+	return namespaceId_;
+}
+
+void DeleteNamespaceRequest::setNamespaceId(const std::string& namespaceId)
+{
+	namespaceId_ = namespaceId;
+	setParameter("NamespaceId", namespaceId);
+}
+

acms-open/src/model/DeleteNamespaceResult.cc

@@ -0,0 +1,58 @@
+/*
+ * 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/acms-open/model/DeleteNamespaceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Acms_open;
+using namespace AlibabaCloud::Acms_open::Model;
+
+DeleteNamespaceResult::DeleteNamespaceResult() :
+	ServiceResult()
+{}
+
+DeleteNamespaceResult::DeleteNamespaceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteNamespaceResult::~DeleteNamespaceResult()
+{}
+
+void DeleteNamespaceResult::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["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string DeleteNamespaceResult::getMessage()const
+{
+	return message_;
+}
+
+std::string DeleteNamespaceResult::getCode()const
+{
+	return code_;
+}
+

acms-open/src/model/DeployConfigurationRequest.cc

@@ -0,0 +1,118 @@
+/*
+ * 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/acms-open/model/DeployConfigurationRequest.h>
+
+using AlibabaCloud::Acms_open::Model::DeployConfigurationRequest;
+
+DeployConfigurationRequest::DeployConfigurationRequest() :
+	RoaServiceRequest("acms-open", "2020-02-06")
+{
+	setResourcePath("/diamond-ops/pop/configuration");
+	setMethod(HttpRequest::Method::Put);
+}
+
+DeployConfigurationRequest::~DeployConfigurationRequest()
+{}
+
+std::string DeployConfigurationRequest::getDataId()const
+{
+	return dataId_;
+}
+
+void DeployConfigurationRequest::setDataId(const std::string& dataId)
+{
+	dataId_ = dataId;
+	setBodyParameter("DataId", dataId);
+}
+
+std::string DeployConfigurationRequest::getAppName()const
+{
+	return appName_;
+}
+
+void DeployConfigurationRequest::setAppName(const std::string& appName)
+{
+	appName_ = appName;
+	setBodyParameter("AppName", appName);
+}
+
+std::string DeployConfigurationRequest::getNamespaceId()const
+{
+	return namespaceId_;
+}
+
+void DeployConfigurationRequest::setNamespaceId(const std::string& namespaceId)
+{
+	namespaceId_ = namespaceId;
+	setBodyParameter("NamespaceId", namespaceId);
+}
+
+std::string DeployConfigurationRequest::getType()const
+{
+	return type_;
+}
+
+void DeployConfigurationRequest::setType(const std::string& type)
+{
+	type_ = type;
+	setBodyParameter("Type", type);
+}
+
+std::string DeployConfigurationRequest::getContent()const
+{
+	return content_;
+}
+
+void DeployConfigurationRequest::setContent(const std::string& content)
+{
+	content_ = content;
+	setBodyParameter("Content", content);
+}
+
+std::string DeployConfigurationRequest::getGroup()const
+{
+	return group_;
+}
+
+void DeployConfigurationRequest::setGroup(const std::string& group)
+{
+	group_ = group;
+	setBodyParameter("Group", group);
+}
+
+std::string DeployConfigurationRequest::getDesc()const
+{
+	return desc_;
+}
+
+void DeployConfigurationRequest::setDesc(const std::string& desc)
+{
+	desc_ = desc;
+	setBodyParameter("Desc", desc);
+}
+
+std::string DeployConfigurationRequest::getTags()const
+{
+	return tags_;
+}
+
+void DeployConfigurationRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setBodyParameter("Tags", tags);
+}
+

acms-open/src/model/DeployConfigurationResult.cc

@@ -0,0 +1,58 @@
+/*
+ * 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/acms-open/model/DeployConfigurationResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Acms_open;
+using namespace AlibabaCloud::Acms_open::Model;
+
+DeployConfigurationResult::DeployConfigurationResult() :
+	ServiceResult()
+{}
+
+DeployConfigurationResult::DeployConfigurationResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeployConfigurationResult::~DeployConfigurationResult()
+{}
+
+void DeployConfigurationResult::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["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string DeployConfigurationResult::getMessage()const
+{
+	return message_;
+}
+
+std::string DeployConfigurationResult::getCode()const
+{
+	return code_;
+}
+

acms-open/src/model/DescribeConfigurationRequest.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/acms-open/model/DescribeConfigurationRequest.h>
+
+using AlibabaCloud::Acms_open::Model::DescribeConfigurationRequest;
+
+DescribeConfigurationRequest::DescribeConfigurationRequest() :
+	RoaServiceRequest("acms-open", "2020-02-06")
+{
+	setResourcePath("/diamond-ops/pop/configuration");
+	setMethod(HttpRequest::Method::Get);
+}
+
+DescribeConfigurationRequest::~DescribeConfigurationRequest()
+{}
+
+std::string DescribeConfigurationRequest::getDataId()const
+{
+	return dataId_;
+}
+
+void DescribeConfigurationRequest::setDataId(const std::string& dataId)
+{
+	dataId_ = dataId;
+	setParameter("DataId", dataId);
+}
+
+std::string DescribeConfigurationRequest::getNamespaceId()const
+{
+	return namespaceId_;
+}
+
+void DescribeConfigurationRequest::setNamespaceId(const std::string& namespaceId)
+{
+	namespaceId_ = namespaceId;
+	setParameter("NamespaceId", namespaceId);
+}
+
+std::string DescribeConfigurationRequest::getGroup()const
+{
+	return group_;
+}
+
+void DescribeConfigurationRequest::setGroup(const std::string& group)
+{
+	group_ = group;
+	setParameter("Group", group);
+}
+

acms-open/src/model/DescribeConfigurationResult.cc

@@ -0,0 +1,78 @@
+/*
+ * 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/acms-open/model/DescribeConfigurationResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Acms_open;
+using namespace AlibabaCloud::Acms_open::Model;
+
+DescribeConfigurationResult::DescribeConfigurationResult() :
+	ServiceResult()
+{}
+
+DescribeConfigurationResult::DescribeConfigurationResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeConfigurationResult::~DescribeConfigurationResult()
+{}
+
+void DescribeConfigurationResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto configurationNode = value["Configuration"];
+	if(!configurationNode["DataId"].isNull())
+		configuration_.dataId = configurationNode["DataId"].asString();
+	if(!configurationNode["Group"].isNull())
+		configuration_.group = configurationNode["Group"].asString();
+	if(!configurationNode["Content"].isNull())
+		configuration_.content = configurationNode["Content"].asString();
+	if(!configurationNode["Md5"].isNull())
+		configuration_.md5 = configurationNode["Md5"].asString();
+	if(!configurationNode["AppName"].isNull())
+		configuration_.appName = configurationNode["AppName"].asString();
+	if(!configurationNode["Desc"].isNull())
+		configuration_.desc = configurationNode["Desc"].asString();
+	if(!configurationNode["Tags"].isNull())
+		configuration_.tags = configurationNode["Tags"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+
+}
+
+DescribeConfigurationResult::Configuration DescribeConfigurationResult::getConfiguration()const
+{
+	return configuration_;
+}
+
+std::string DescribeConfigurationResult::getMessage()const
+{
+	return message_;
+}
+
+std::string DescribeConfigurationResult::getCode()const
+{
+	return code_;
+}
+

acms-open/src/model/DescribeNamespaceRequest.cc

@@ -0,0 +1,41 @@
+/*
+ * 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/acms-open/model/DescribeNamespaceRequest.h>
+
+using AlibabaCloud::Acms_open::Model::DescribeNamespaceRequest;
+
+DescribeNamespaceRequest::DescribeNamespaceRequest() :
+	RoaServiceRequest("acms-open", "2020-02-06")
+{
+	setResourcePath("/diamond-ops/pop/namespace");
+	setMethod(HttpRequest::Method::Get);
+}
+
+DescribeNamespaceRequest::~DescribeNamespaceRequest()
+{}
+
+std::string DescribeNamespaceRequest::getNamespaceId()const
+{
+	return namespaceId_;
+}
+
+void DescribeNamespaceRequest::setNamespaceId(const std::string& namespaceId)
+{
+	namespaceId_ = namespaceId;
+	setParameter("NamespaceId", namespaceId);
+}
+

acms-open/src/model/DescribeNamespaceResult.cc

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/acms-open/model/DescribeNamespaceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Acms_open;
+using namespace AlibabaCloud::Acms_open::Model;
+
+DescribeNamespaceResult::DescribeNamespaceResult() :
+	ServiceResult()
+{}
+
+DescribeNamespaceResult::DescribeNamespaceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeNamespaceResult::~DescribeNamespaceResult()
+{}
+
+void DescribeNamespaceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto _namespaceNode = value["Namespace"];
+	if(!_namespaceNode["RegionId"].isNull())
+		_namespace_.regionId = _namespaceNode["RegionId"].asString();
+	if(!_namespaceNode["Endpoint"].isNull())
+		_namespace_.endpoint = _namespaceNode["Endpoint"].asString();
+	if(!_namespaceNode["AccessKey"].isNull())
+		_namespace_.accessKey = _namespaceNode["AccessKey"].asString();
+	if(!_namespaceNode["SecretKey"].isNull())
+		_namespace_.secretKey = _namespaceNode["SecretKey"].asString();
+	if(!_namespaceNode["Name"].isNull())
+		_namespace_.name = _namespaceNode["Name"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string DescribeNamespaceResult::getMessage()const
+{
+	return message_;
+}
+
+DescribeNamespaceResult::_Namespace DescribeNamespaceResult::get_Namespace()const
+{
+	return _namespace_;
+}
+
+std::string DescribeNamespaceResult::getCode()const
+{
+	return code_;
+}
+

acms-open/src/model/UpdateNamespaceRequest.cc

@@ -0,0 +1,52 @@
+/*
+ * 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/acms-open/model/UpdateNamespaceRequest.h>
+
+using AlibabaCloud::Acms_open::Model::UpdateNamespaceRequest;
+
+UpdateNamespaceRequest::UpdateNamespaceRequest() :
+	RoaServiceRequest("acms-open", "2020-02-06")
+{
+	setResourcePath("/diamond-ops/pop/namespace");
+	setMethod(HttpRequest::Method::Put);
+}
+
+UpdateNamespaceRequest::~UpdateNamespaceRequest()
+{}
+
+std::string UpdateNamespaceRequest::getNamespaceName()const
+{
+	return namespaceName_;
+}
+
+void UpdateNamespaceRequest::setNamespaceName(const std::string& namespaceName)
+{
+	namespaceName_ = namespaceName;
+	setBodyParameter("NamespaceName", namespaceName);
+}
+
+std::string UpdateNamespaceRequest::getNamespaceId()const
+{
+	return namespaceId_;
+}
+
+void UpdateNamespaceRequest::setNamespaceId(const std::string& namespaceId)
+{
+	namespaceId_ = namespaceId;
+	setBodyParameter("NamespaceId", namespaceId);
+}
+

acms-open/src/model/UpdateNamespaceResult.cc

@@ -0,0 +1,58 @@
+/*
+ * 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/acms-open/model/UpdateNamespaceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Acms_open;
+using namespace AlibabaCloud::Acms_open::Model;
+
+UpdateNamespaceResult::UpdateNamespaceResult() :
+	ServiceResult()
+{}
+
+UpdateNamespaceResult::UpdateNamespaceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateNamespaceResult::~UpdateNamespaceResult()
+{}
+
+void UpdateNamespaceResult::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["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string UpdateNamespaceResult::getMessage()const
+{
+	return message_;
+}
+
+std::string UpdateNamespaceResult::getCode()const
+{
+	return code_;
+}
+

alimt/CMakeLists.txt

@@ -27,6 +27,8 @@ set(alimt_public_header_model
 	include/alibabacloud/alimt/model/GetDocTranslateTaskResult.h
 	include/alibabacloud/alimt/model/TranslateRequest.h
 	include/alibabacloud/alimt/model/TranslateResult.h
+	include/alibabacloud/alimt/model/TranslateCertificateRequest.h
+	include/alibabacloud/alimt/model/TranslateCertificateResult.h
 	include/alibabacloud/alimt/model/TranslateECommerceRequest.h
 	include/alibabacloud/alimt/model/TranslateECommerceResult.h
 	include/alibabacloud/alimt/model/TranslateGeneralRequest.h
@@ -40,6 +42,8 @@ set(alimt_src
 	src/model/GetDocTranslateTaskResult.cc
 	src/model/TranslateRequest.cc
 	src/model/TranslateResult.cc
+	src/model/TranslateCertificateRequest.cc
+	src/model/TranslateCertificateResult.cc
 	src/model/TranslateECommerceRequest.cc
 	src/model/TranslateECommerceResult.cc
 	src/model/TranslateGeneralRequest.cc

alimt/include/alibabacloud/alimt/AlimtClient.h

@@ -28,6 +28,8 @@
 #include "model/GetDocTranslateTaskResult.h"
 #include "model/TranslateRequest.h"
 #include "model/TranslateResult.h"
+#include "model/TranslateCertificateRequest.h"
+#include "model/TranslateCertificateResult.h"
 #include "model/TranslateECommerceRequest.h"
 #include "model/TranslateECommerceResult.h"
 #include "model/TranslateGeneralRequest.h"
@@ -50,6 +52,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::TranslateResult> TranslateOutcome;
 			typedef std::future<TranslateOutcome> TranslateOutcomeCallable;
 			typedef std::function<void(const AlimtClient*, const Model::TranslateRequest&, const TranslateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TranslateAsyncHandler;
+			typedef Outcome<Error, Model::TranslateCertificateResult> TranslateCertificateOutcome;
+			typedef std::future<TranslateCertificateOutcome> TranslateCertificateOutcomeCallable;
+			typedef std::function<void(const AlimtClient*, const Model::TranslateCertificateRequest&, const TranslateCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TranslateCertificateAsyncHandler;
 			typedef Outcome<Error, Model::TranslateECommerceResult> TranslateECommerceOutcome;
 			typedef std::future<TranslateECommerceOutcome> TranslateECommerceOutcomeCallable;
 			typedef std::function<void(const AlimtClient*, const Model::TranslateECommerceRequest&, const TranslateECommerceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TranslateECommerceAsyncHandler;
@@ -70,6 +75,9 @@ namespace AlibabaCloud
 			TranslateOutcome translate(const Model::TranslateRequest &request)const;
 			void translateAsync(const Model::TranslateRequest& request, const TranslateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			TranslateOutcomeCallable translateCallable(const Model::TranslateRequest& request) const;
+			TranslateCertificateOutcome translateCertificate(const Model::TranslateCertificateRequest &request)const;
+			void translateCertificateAsync(const Model::TranslateCertificateRequest& request, const TranslateCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			TranslateCertificateOutcomeCallable translateCertificateCallable(const Model::TranslateCertificateRequest& request) const;
 			TranslateECommerceOutcome translateECommerce(const Model::TranslateECommerceRequest &request)const;
 			void translateECommerceAsync(const Model::TranslateECommerceRequest& request, const TranslateECommerceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			TranslateECommerceOutcomeCallable translateECommerceCallable(const Model::TranslateECommerceRequest& request) const;

alimt/include/alibabacloud/alimt/model/TranslateCertificateRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALIMT_MODEL_TRANSLATECERTIFICATEREQUEST_H_
+#define ALIBABACLOUD_ALIMT_MODEL_TRANSLATECERTIFICATEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alimt/AlimtExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alimt
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIMT_EXPORT TranslateCertificateRequest : public RpcServiceRequest
+			{
+
+			public:
+				TranslateCertificateRequest();
+				~TranslateCertificateRequest();
+
+				std::string getSourceLanguage()const;
+				void setSourceLanguage(const std::string& sourceLanguage);
+				std::string getCertificateType()const;
+				void setCertificateType(const std::string& certificateType);
+				std::string getResultType()const;
+				void setResultType(const std::string& resultType);
+				std::string getImageUrl()const;
+				void setImageUrl(const std::string& imageUrl);
+				std::string getTargetLanguage()const;
+				void setTargetLanguage(const std::string& targetLanguage);
+
+            private:
+				std::string sourceLanguage_;
+				std::string certificateType_;
+				std::string resultType_;
+				std::string imageUrl_;
+				std::string targetLanguage_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIMT_MODEL_TRANSLATECERTIFICATEREQUEST_H_

alimt/include/alibabacloud/alimt/model/TranslateCertificateResult.h

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

alimt/src/AlimtClient.cc

@@ -31,21 +31,21 @@ AlimtClient::AlimtClient(const Credentials &credentials, const ClientConfigurati
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "alimt");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "alimtct");
 }
 
 AlimtClient::AlimtClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "alimt");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "alimtct");
 }
 
 AlimtClient::AlimtClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "alimt");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "alimtct");
 }
 
 AlimtClient::~AlimtClient()
@@ -159,6 +159,42 @@ AlimtClient::TranslateOutcomeCallable AlimtClient::translateCallable(const Trans
 	return task->get_future();
 }
 
+AlimtClient::TranslateCertificateOutcome AlimtClient::translateCertificate(const TranslateCertificateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return TranslateCertificateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return TranslateCertificateOutcome(TranslateCertificateResult(outcome.result()));
+	else
+		return TranslateCertificateOutcome(outcome.error());
+}
+
+void AlimtClient::translateCertificateAsync(const TranslateCertificateRequest& request, const TranslateCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, translateCertificate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlimtClient::TranslateCertificateOutcomeCallable AlimtClient::translateCertificateCallable(const TranslateCertificateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<TranslateCertificateOutcome()>>(
+			[this, request]()
+			{
+			return this->translateCertificate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AlimtClient::TranslateECommerceOutcome AlimtClient::translateECommerce(const TranslateECommerceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

alimt/src/model/CreateDocTranslateTaskRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Alimt::Model::CreateDocTranslateTaskRequest;
 CreateDocTranslateTaskRequest::CreateDocTranslateTaskRequest() :
 	RpcServiceRequest("alimt", "2018-10-12", "CreateDocTranslateTask")
 {
-	setMethod(HttpRequest::Method::POST);
+	setMethod(HttpRequest::Method::Post);
 }
 
 CreateDocTranslateTaskRequest::~CreateDocTranslateTaskRequest()

alimt/src/model/GetDocTranslateTaskRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Alimt::Model::GetDocTranslateTaskRequest;
 GetDocTranslateTaskRequest::GetDocTranslateTaskRequest() :
 	RpcServiceRequest("alimt", "2018-10-12", "GetDocTranslateTask")
 {
-	setMethod(HttpRequest::Method::GET);
+	setMethod(HttpRequest::Method::Get);
 }
 
 GetDocTranslateTaskRequest::~GetDocTranslateTaskRequest()

alimt/src/model/TranslateCertificateRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/alimt/model/TranslateCertificateRequest.h>
+
+using AlibabaCloud::Alimt::Model::TranslateCertificateRequest;
+
+TranslateCertificateRequest::TranslateCertificateRequest() :
+	RpcServiceRequest("alimt", "2018-10-12", "TranslateCertificate")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+TranslateCertificateRequest::~TranslateCertificateRequest()
+{}
+
+std::string TranslateCertificateRequest::getSourceLanguage()const
+{
+	return sourceLanguage_;
+}
+
+void TranslateCertificateRequest::setSourceLanguage(const std::string& sourceLanguage)
+{
+	sourceLanguage_ = sourceLanguage;
+	setBodyParameter("SourceLanguage", sourceLanguage);
+}
+
+std::string TranslateCertificateRequest::getCertificateType()const
+{
+	return certificateType_;
+}
+
+void TranslateCertificateRequest::setCertificateType(const std::string& certificateType)
+{
+	certificateType_ = certificateType;
+	setBodyParameter("CertificateType", certificateType);
+}
+
+std::string TranslateCertificateRequest::getResultType()const
+{
+	return resultType_;
+}
+
+void TranslateCertificateRequest::setResultType(const std::string& resultType)
+{
+	resultType_ = resultType;
+	setBodyParameter("ResultType", resultType);
+}
+
+std::string TranslateCertificateRequest::getImageUrl()const
+{
+	return imageUrl_;
+}
+
+void TranslateCertificateRequest::setImageUrl(const std::string& imageUrl)
+{
+	imageUrl_ = imageUrl;
+	setBodyParameter("ImageUrl", imageUrl);
+}
+
+std::string TranslateCertificateRequest::getTargetLanguage()const
+{
+	return targetLanguage_;
+}
+
+void TranslateCertificateRequest::setTargetLanguage(const std::string& targetLanguage)
+{
+	targetLanguage_ = targetLanguage;
+	setBodyParameter("TargetLanguage", targetLanguage);
+}
+

alimt/src/model/TranslateCertificateResult.cc

@@ -0,0 +1,64 @@
+/*
+ * 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/alimt/model/TranslateCertificateResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Alimt;
+using namespace AlibabaCloud::Alimt::Model;
+
+TranslateCertificateResult::TranslateCertificateResult() :
+	ServiceResult()
+{}
+
+TranslateCertificateResult::TranslateCertificateResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+TranslateCertificateResult::~TranslateCertificateResult()
+{}
+
+void TranslateCertificateResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto allTranslatedValuesNode = dataNode["TranslatedValues"]["CertificateTranslateItemDTO"];
+	for (auto dataNodeTranslatedValuesCertificateTranslateItemDTO : allTranslatedValuesNode)
+	{
+		Data::CertificateTranslateItemDTO certificateTranslateItemDTOObject;
+		if(!dataNodeTranslatedValuesCertificateTranslateItemDTO["Key"].isNull())
+			certificateTranslateItemDTOObject.key = dataNodeTranslatedValuesCertificateTranslateItemDTO["Key"].asString();
+		if(!dataNodeTranslatedValuesCertificateTranslateItemDTO["Value"].isNull())
+			certificateTranslateItemDTOObject.value = dataNodeTranslatedValuesCertificateTranslateItemDTO["Value"].asString();
+		if(!dataNodeTranslatedValuesCertificateTranslateItemDTO["ValueTranslation"].isNull())
+			certificateTranslateItemDTOObject.valueTranslation = dataNodeTranslatedValuesCertificateTranslateItemDTO["ValueTranslation"].asString();
+		if(!dataNodeTranslatedValuesCertificateTranslateItemDTO["KeyTranslation"].isNull())
+			certificateTranslateItemDTOObject.keyTranslation = dataNodeTranslatedValuesCertificateTranslateItemDTO["KeyTranslation"].asString();
+		data_.translatedValues.push_back(certificateTranslateItemDTOObject);
+	}
+
+}
+
+TranslateCertificateResult::Data TranslateCertificateResult::getData()const
+{
+	return data_;
+}
+

alimt/src/model/TranslateECommerceRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Alimt::Model::TranslateECommerceRequest;
 TranslateECommerceRequest::TranslateECommerceRequest() :
 	RpcServiceRequest("alimt", "2018-10-12", "TranslateECommerce")
 {
-	setMethod(HttpRequest::Method::POST);
+	setMethod(HttpRequest::Method::Post);
 }
 
 TranslateECommerceRequest::~TranslateECommerceRequest()

alimt/src/model/TranslateGeneralRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Alimt::Model::TranslateGeneralRequest;
 TranslateGeneralRequest::TranslateGeneralRequest() :
 	RpcServiceRequest("alimt", "2018-10-12", "TranslateGeneral")
 {
-	setMethod(HttpRequest::Method::POST);
+	setMethod(HttpRequest::Method::Post);
 }
 
 TranslateGeneralRequest::~TranslateGeneralRequest()

alimt/src/model/TranslateRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Alimt::Model::TranslateRequest;
 TranslateRequest::TranslateRequest() :
 	RpcServiceRequest("alimt", "2018-10-12", "Translate")
 {
-	setMethod(HttpRequest::Method::POST);
+	setMethod(HttpRequest::Method::Post);
 }
 
 TranslateRequest::~TranslateRequest()

dds/CMakeLists.txt

@@ -29,8 +29,6 @@ set(dds_public_header_model
 	include/alibabacloud/dds/model/CheckCloudResourceAuthorizedResult.h
 	include/alibabacloud/dds/model/CheckRecoveryConditionRequest.h
 	include/alibabacloud/dds/model/CheckRecoveryConditionResult.h
-	include/alibabacloud/dds/model/CreateAccountRequest.h
-	include/alibabacloud/dds/model/CreateAccountResult.h
 	include/alibabacloud/dds/model/CreateBackupRequest.h
 	include/alibabacloud/dds/model/CreateBackupResult.h
 	include/alibabacloud/dds/model/CreateDBInstanceRequest.h
@@ -69,6 +67,8 @@ set(dds_public_header_model
 	include/alibabacloud/dds/model/DescribeBackupsResult.h
 	include/alibabacloud/dds/model/DescribeDBInstanceAttributeRequest.h
 	include/alibabacloud/dds/model/DescribeDBInstanceAttributeResult.h
+	include/alibabacloud/dds/model/DescribeDBInstanceEncryptionKeyRequest.h
+	include/alibabacloud/dds/model/DescribeDBInstanceEncryptionKeyResult.h
 	include/alibabacloud/dds/model/DescribeDBInstanceMonitorRequest.h
 	include/alibabacloud/dds/model/DescribeDBInstanceMonitorResult.h
 	include/alibabacloud/dds/model/DescribeDBInstancePerformanceRequest.h
@@ -113,6 +113,8 @@ set(dds_public_header_model
 	include/alibabacloud/dds/model/DescribeSlowLogRecordsResult.h
 	include/alibabacloud/dds/model/DescribeTagsRequest.h
 	include/alibabacloud/dds/model/DescribeTagsResult.h
+	include/alibabacloud/dds/model/DescribeUserEncryptionKeyListRequest.h
+	include/alibabacloud/dds/model/DescribeUserEncryptionKeyListResult.h
 	include/alibabacloud/dds/model/DestroyInstanceRequest.h
 	include/alibabacloud/dds/model/DestroyInstanceResult.h
 	include/alibabacloud/dds/model/ListTagResourcesRequest.h
@@ -194,8 +196,6 @@ set(dds_src
 	src/model/CheckCloudResourceAuthorizedResult.cc
 	src/model/CheckRecoveryConditionRequest.cc
 	src/model/CheckRecoveryConditionResult.cc
-	src/model/CreateAccountRequest.cc
-	src/model/CreateAccountResult.cc
 	src/model/CreateBackupRequest.cc
 	src/model/CreateBackupResult.cc
 	src/model/CreateDBInstanceRequest.cc
@@ -234,6 +234,8 @@ set(dds_src
 	src/model/DescribeBackupsResult.cc
 	src/model/DescribeDBInstanceAttributeRequest.cc
 	src/model/DescribeDBInstanceAttributeResult.cc
+	src/model/DescribeDBInstanceEncryptionKeyRequest.cc
+	src/model/DescribeDBInstanceEncryptionKeyResult.cc
 	src/model/DescribeDBInstanceMonitorRequest.cc
 	src/model/DescribeDBInstanceMonitorResult.cc
 	src/model/DescribeDBInstancePerformanceRequest.cc
@@ -278,6 +280,8 @@ set(dds_src
 	src/model/DescribeSlowLogRecordsResult.cc
 	src/model/DescribeTagsRequest.cc
 	src/model/DescribeTagsResult.cc
+	src/model/DescribeUserEncryptionKeyListRequest.cc
+	src/model/DescribeUserEncryptionKeyListResult.cc
 	src/model/DestroyInstanceRequest.cc
 	src/model/DestroyInstanceResult.cc
 	src/model/ListTagResourcesRequest.cc

dds/include/alibabacloud/dds/DdsClient.h

@@ -30,8 +30,6 @@
 #include "model/CheckCloudResourceAuthorizedResult.h"
 #include "model/CheckRecoveryConditionRequest.h"
 #include "model/CheckRecoveryConditionResult.h"
-#include "model/CreateAccountRequest.h"
-#include "model/CreateAccountResult.h"
 #include "model/CreateBackupRequest.h"
 #include "model/CreateBackupResult.h"
 #include "model/CreateDBInstanceRequest.h"
@@ -70,6 +68,8 @@
 #include "model/DescribeBackupsResult.h"
 #include "model/DescribeDBInstanceAttributeRequest.h"
 #include "model/DescribeDBInstanceAttributeResult.h"
+#include "model/DescribeDBInstanceEncryptionKeyRequest.h"
+#include "model/DescribeDBInstanceEncryptionKeyResult.h"
 #include "model/DescribeDBInstanceMonitorRequest.h"
 #include "model/DescribeDBInstanceMonitorResult.h"
 #include "model/DescribeDBInstancePerformanceRequest.h"
@@ -114,6 +114,8 @@
 #include "model/DescribeSlowLogRecordsResult.h"
 #include "model/DescribeTagsRequest.h"
 #include "model/DescribeTagsResult.h"
+#include "model/DescribeUserEncryptionKeyListRequest.h"
+#include "model/DescribeUserEncryptionKeyListResult.h"
 #include "model/DestroyInstanceRequest.h"
 #include "model/DestroyInstanceResult.h"
 #include "model/ListTagResourcesRequest.h"
@@ -205,9 +207,6 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CheckRecoveryConditionResult> CheckRecoveryConditionOutcome;
 			typedef std::future<CheckRecoveryConditionOutcome> CheckRecoveryConditionOutcomeCallable;
 			typedef std::function<void(const DdsClient*, const Model::CheckRecoveryConditionRequest&, const CheckRecoveryConditionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckRecoveryConditionAsyncHandler;
-			typedef Outcome<Error, Model::CreateAccountResult> CreateAccountOutcome;
-			typedef std::future<CreateAccountOutcome> CreateAccountOutcomeCallable;
-			typedef std::function<void(const DdsClient*, const Model::CreateAccountRequest&, const CreateAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAccountAsyncHandler;
 			typedef Outcome<Error, Model::CreateBackupResult> CreateBackupOutcome;
 			typedef std::future<CreateBackupOutcome> CreateBackupOutcomeCallable;
 			typedef std::function<void(const DdsClient*, const Model::CreateBackupRequest&, const CreateBackupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateBackupAsyncHandler;
@@ -265,6 +264,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeDBInstanceAttributeResult> DescribeDBInstanceAttributeOutcome;
 			typedef std::future<DescribeDBInstanceAttributeOutcome> DescribeDBInstanceAttributeOutcomeCallable;
 			typedef std::function<void(const DdsClient*, const Model::DescribeDBInstanceAttributeRequest&, const DescribeDBInstanceAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInstanceAttributeAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDBInstanceEncryptionKeyResult> DescribeDBInstanceEncryptionKeyOutcome;
+			typedef std::future<DescribeDBInstanceEncryptionKeyOutcome> DescribeDBInstanceEncryptionKeyOutcomeCallable;
+			typedef std::function<void(const DdsClient*, const Model::DescribeDBInstanceEncryptionKeyRequest&, const DescribeDBInstanceEncryptionKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInstanceEncryptionKeyAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDBInstanceMonitorResult> DescribeDBInstanceMonitorOutcome;
 			typedef std::future<DescribeDBInstanceMonitorOutcome> DescribeDBInstanceMonitorOutcomeCallable;
 			typedef std::function<void(const DdsClient*, const Model::DescribeDBInstanceMonitorRequest&, const DescribeDBInstanceMonitorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInstanceMonitorAsyncHandler;
@@ -331,6 +333,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeTagsResult> DescribeTagsOutcome;
 			typedef std::future<DescribeTagsOutcome> DescribeTagsOutcomeCallable;
 			typedef std::function<void(const DdsClient*, const Model::DescribeTagsRequest&, const DescribeTagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTagsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeUserEncryptionKeyListResult> DescribeUserEncryptionKeyListOutcome;
+			typedef std::future<DescribeUserEncryptionKeyListOutcome> DescribeUserEncryptionKeyListOutcomeCallable;
+			typedef std::function<void(const DdsClient*, const Model::DescribeUserEncryptionKeyListRequest&, const DescribeUserEncryptionKeyListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeUserEncryptionKeyListAsyncHandler;
 			typedef Outcome<Error, Model::DestroyInstanceResult> DestroyInstanceOutcome;
 			typedef std::future<DestroyInstanceOutcome> DestroyInstanceOutcomeCallable;
 			typedef std::function<void(const DdsClient*, const Model::DestroyInstanceRequest&, const DestroyInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DestroyInstanceAsyncHandler;
@@ -453,9 +458,6 @@ namespace AlibabaCloud
 			CheckRecoveryConditionOutcome checkRecoveryCondition(const Model::CheckRecoveryConditionRequest &request)const;
 			void checkRecoveryConditionAsync(const Model::CheckRecoveryConditionRequest& request, const CheckRecoveryConditionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CheckRecoveryConditionOutcomeCallable checkRecoveryConditionCallable(const Model::CheckRecoveryConditionRequest& request) const;
-			CreateAccountOutcome createAccount(const Model::CreateAccountRequest &request)const;
-			void createAccountAsync(const Model::CreateAccountRequest& request, const CreateAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateAccountOutcomeCallable createAccountCallable(const Model::CreateAccountRequest& request) const;
 			CreateBackupOutcome createBackup(const Model::CreateBackupRequest &request)const;
 			void createBackupAsync(const Model::CreateBackupRequest& request, const CreateBackupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateBackupOutcomeCallable createBackupCallable(const Model::CreateBackupRequest& request) const;
@@ -513,6 +515,9 @@ namespace AlibabaCloud
 			DescribeDBInstanceAttributeOutcome describeDBInstanceAttribute(const Model::DescribeDBInstanceAttributeRequest &request)const;
 			void describeDBInstanceAttributeAsync(const Model::DescribeDBInstanceAttributeRequest& request, const DescribeDBInstanceAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDBInstanceAttributeOutcomeCallable describeDBInstanceAttributeCallable(const Model::DescribeDBInstanceAttributeRequest& request) const;
+			DescribeDBInstanceEncryptionKeyOutcome describeDBInstanceEncryptionKey(const Model::DescribeDBInstanceEncryptionKeyRequest &request)const;
+			void describeDBInstanceEncryptionKeyAsync(const Model::DescribeDBInstanceEncryptionKeyRequest& request, const DescribeDBInstanceEncryptionKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDBInstanceEncryptionKeyOutcomeCallable describeDBInstanceEncryptionKeyCallable(const Model::DescribeDBInstanceEncryptionKeyRequest& request) const;
 			DescribeDBInstanceMonitorOutcome describeDBInstanceMonitor(const Model::DescribeDBInstanceMonitorRequest &request)const;
 			void describeDBInstanceMonitorAsync(const Model::DescribeDBInstanceMonitorRequest& request, const DescribeDBInstanceMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDBInstanceMonitorOutcomeCallable describeDBInstanceMonitorCallable(const Model::DescribeDBInstanceMonitorRequest& request) const;
@@ -579,6 +584,9 @@ namespace AlibabaCloud
 			DescribeTagsOutcome describeTags(const Model::DescribeTagsRequest &request)const;
 			void describeTagsAsync(const Model::DescribeTagsRequest& request, const DescribeTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeTagsOutcomeCallable describeTagsCallable(const Model::DescribeTagsRequest& request) const;
+			DescribeUserEncryptionKeyListOutcome describeUserEncryptionKeyList(const Model::DescribeUserEncryptionKeyListRequest &request)const;
+			void describeUserEncryptionKeyListAsync(const Model::DescribeUserEncryptionKeyListRequest& request, const DescribeUserEncryptionKeyListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeUserEncryptionKeyListOutcomeCallable describeUserEncryptionKeyListCallable(const Model::DescribeUserEncryptionKeyListRequest& request) const;
 			DestroyInstanceOutcome destroyInstance(const Model::DestroyInstanceRequest &request)const;
 			void destroyInstanceAsync(const Model::DestroyInstanceRequest& request, const DestroyInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DestroyInstanceOutcomeCallable destroyInstanceCallable(const Model::DestroyInstanceRequest& request) const;

dds/include/alibabacloud/dds/model/CreateShardingDBInstanceRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_DDS_EXPORT CreateShardingDBInstanceRequest : public RpcServiceRequest
 			{
+			public:
 				struct ReplicaSet
 				{
 					int storage;

dds/include/alibabacloud/dds/model/DescribeAvailableResourceResult.h

@@ -32,43 +32,49 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_DDS_EXPORT DescribeAvailableResourceResult : public ServiceResult
 			{
 			public:
-				struct AvailableZone
+				struct SupportedDBType
 				{
-					struct SupportedEngineVersion
+					struct AvailableZone
 					{
-						struct SupportedEngine
+						struct SupportedEngineVersion
 						{
-							struct SupportedNodeType
+							struct SupportedEngine
 							{
-								struct AvailableResource
+								struct SupportedNodeType
 								{
-									std::string instanceClass;
+									struct AvailableResource
+									{
+										std::string instanceClassRemark;
+										std::string instanceClass;
+									};
+									std::string networkTypes;
+									std::string nodeType;
+									std::vector<SupportedNodeType::AvailableResource> availableResources;
 								};
-								std::string networkTypes;
-								std::string nodeType;
-								std::vector<SupportedNodeType::AvailableResource> availableResources;
+								std::vector<SupportedEngine::SupportedNodeType> supportedNodeTypes;
+								std::string engine;
 							};
-							std::vector<SupportedEngine::SupportedNodeType> supportedNodeTypes;
-							std::string engine;
+							std::string version;
+							std::vector<SupportedEngineVersion::SupportedEngine> supportedEngines;
 						};
-						std::string version;
-						std::vector<SupportedEngineVersion::SupportedEngine> supportedEngines;
+						std::string zoneId;
+						std::vector<AvailableZone::SupportedEngineVersion> supportedEngineVersions;
+						std::string regionId;
 					};
-					std::string zoneId;
-					std::vector<AvailableZone::SupportedEngineVersion> supportedEngineVersions;
-					std::string regionId;
+					std::string dbType;
+					std::vector<SupportedDBType::AvailableZone> availableZones;
 				};
 
 
 				DescribeAvailableResourceResult();
 				explicit DescribeAvailableResourceResult(const std::string &payload);
 				~DescribeAvailableResourceResult();
-				std::vector<AvailableZone> getAvailableZones()const;
+				std::vector<SupportedDBType> getSupportedDBTypes()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::vector<AvailableZone> availableZones_;
+				std::vector<SupportedDBType> supportedDBTypes_;
 
 			};
 		}

dds/include/alibabacloud/dds/model/DescribeDBInstanceEncryptionKeyRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_DDS_MODEL_CREATEACCOUNTREQUEST_H_
-#define ALIBABACLOUD_DDS_MODEL_CREATEACCOUNTREQUEST_H_
+#ifndef ALIBABACLOUD_DDS_MODEL_DESCRIBEDBINSTANCEENCRYPTIONKEYREQUEST_H_
+#define ALIBABACLOUD_DDS_MODEL_DESCRIBEDBINSTANCEENCRYPTIONKEYREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,21 +28,17 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_DDS_EXPORT CreateAccountRequest : public RpcServiceRequest
+			class ALIBABACLOUD_DDS_EXPORT DescribeDBInstanceEncryptionKeyRequest : public RpcServiceRequest
 			{
 
 			public:
-				CreateAccountRequest();
-				~CreateAccountRequest();
+				DescribeDBInstanceEncryptionKeyRequest();
+				~DescribeDBInstanceEncryptionKeyRequest();
 
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
-				std::string getAccountDescription()const;
-				void setAccountDescription(const std::string& accountDescription);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
-				std::string getAccountName()const;
-				void setAccountName(const std::string& accountName);
 				std::string getSecurityToken()const;
 				void setSecurityToken(const std::string& securityToken);
 				std::string getDBInstanceId()const;
@@ -51,25 +47,23 @@ namespace AlibabaCloud
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getEncryptionKey()const;
+				void setEncryptionKey(const std::string& encryptionKey);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
-				std::string getAccountPassword()const;
-				void setAccountPassword(const std::string& accountPassword);
 
             private:
 				long resourceOwnerId_;
-				std::string accountDescription_;
 				std::string accessKeyId_;
-				std::string accountName_;
 				std::string securityToken_;
 				std::string dBInstanceId_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
+				std::string encryptionKey_;
 				long ownerId_;
-				std::string accountPassword_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_DDS_MODEL_CREATEACCOUNTREQUEST_H_
+#endif // !ALIBABACLOUD_DDS_MODEL_DESCRIBEDBINSTANCEENCRYPTIONKEYREQUEST_H_

dds/include/alibabacloud/dds/model/DescribeDBInstanceEncryptionKeyResult.h

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

dds/include/alibabacloud/dds/model/DescribeDBInstancesRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_DDS_EXPORT DescribeDBInstancesRequest : public RpcServiceRequest
 			{
+			public:
 				struct Tag
 				{
 					std::string value;

dds/include/alibabacloud/dds/model/DescribeInstanceAutoRenewalAttributeRequest.h

@@ -43,6 +43,8 @@ namespace AlibabaCloud
 				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 getPageSize()const;
 				void setPageSize(const std::string& pageSize);
 				std::string getDBInstanceId()const;
@@ -61,6 +63,7 @@ namespace AlibabaCloud
 				std::string pageNumber_;
 				std::string accessKeyId_;
 				std::string securityToken_;
+				std::string regionId_;
 				std::string pageSize_;
 				std::string dBInstanceId_;
 				std::string resourceOwnerAccount_;

dds/include/alibabacloud/dds/model/DescribeUserEncryptionKeyListRequest.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_DDS_MODEL_DESCRIBEUSERENCRYPTIONKEYLISTREQUEST_H_
+#define ALIBABACLOUD_DDS_MODEL_DESCRIBEUSERENCRYPTIONKEYLISTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dds/DdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DDS_EXPORT DescribeUserEncryptionKeyListRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeUserEncryptionKeyListRequest();
+				~DescribeUserEncryptionKeyListRequest();
+
+				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 getDBInstanceId()const;
+				void setDBInstanceId(const std::string& dBInstanceId);
+				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);
+
+            private:
+				long resourceOwnerId_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string dBInstanceId_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DDS_MODEL_DESCRIBEUSERENCRYPTIONKEYLISTREQUEST_H_

dds/include/alibabacloud/dds/model/DescribeUserEncryptionKeyListResult.h

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

dds/include/alibabacloud/dds/model/ListTagResourcesRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_DDS_EXPORT ListTagResourcesRequest : public RpcServiceRequest
 			{
+			public:
 				struct Tag
 				{
 					std::string value;

dds/include/alibabacloud/dds/model/ModifyDBInstanceTDERequest.h

@@ -47,10 +47,14 @@ namespace AlibabaCloud
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getEncryptionKey()const;
+				void setEncryptionKey(const std::string& encryptionKey);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
 				std::string getEncryptorName()const;
 				void setEncryptorName(const std::string& encryptorName);
+				std::string getRoleARN()const;
+				void setRoleARN(const std::string& roleARN);
 				std::string getTDEStatus()const;
 				void setTDEStatus(const std::string& tDEStatus);
 
@@ -61,8 +65,10 @@ namespace AlibabaCloud
 				std::string dBInstanceId_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
+				std::string encryptionKey_;
 				long ownerId_;
 				std::string encryptorName_;
+				std::string roleARN_;
 				std::string tDEStatus_;
 
 			};

dds/include/alibabacloud/dds/model/ModifyInstanceAutoRenewalAttributeRequest.h

@@ -43,6 +43,8 @@ namespace AlibabaCloud
 				void setDuration(const std::string& duration);
 				std::string getSecurityToken()const;
 				void setSecurityToken(const std::string& securityToken);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
 				std::string getDBInstanceId()const;
 				void setDBInstanceId(const std::string& dBInstanceId);
 				std::string getResourceOwnerAccount()const;
@@ -59,6 +61,7 @@ namespace AlibabaCloud
 				std::string accessKeyId_;
 				std::string duration_;
 				std::string securityToken_;
+				std::string regionId_;
 				std::string dBInstanceId_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;

dds/include/alibabacloud/dds/model/TagResourcesRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_DDS_EXPORT TagResourcesRequest : public RpcServiceRequest
 			{
+			public:
 				struct Tag
 				{
 					std::string value;

dds/src/DdsClient.cc

@@ -31,21 +31,21 @@ DdsClient::DdsClient(const Credentials &credentials, const ClientConfiguration &
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "Dds");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "dds");
 }
 
 DdsClient::DdsClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "Dds");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "dds");
 }
 
 DdsClient::DdsClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "Dds");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "dds");
 }
 
 DdsClient::~DdsClient()
@@ -195,42 +195,6 @@ DdsClient::CheckRecoveryConditionOutcomeCallable DdsClient::checkRecoveryConditi
 	return task->get_future();
 }
 
-DdsClient::CreateAccountOutcome DdsClient::createAccount(const CreateAccountRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return CreateAccountOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return CreateAccountOutcome(CreateAccountResult(outcome.result()));
-	else
-		return CreateAccountOutcome(outcome.error());
-}
-
-void DdsClient::createAccountAsync(const CreateAccountRequest& request, const CreateAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, createAccount(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-DdsClient::CreateAccountOutcomeCallable DdsClient::createAccountCallable(const CreateAccountRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<CreateAccountOutcome()>>(
-			[this, request]()
-			{
-			return this->createAccount(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 DdsClient::CreateBackupOutcome DdsClient::createBackup(const CreateBackupRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -915,6 +879,42 @@ DdsClient::DescribeDBInstanceAttributeOutcomeCallable DdsClient::describeDBInsta
 	return task->get_future();
 }
 
+DdsClient::DescribeDBInstanceEncryptionKeyOutcome DdsClient::describeDBInstanceEncryptionKey(const DescribeDBInstanceEncryptionKeyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDBInstanceEncryptionKeyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDBInstanceEncryptionKeyOutcome(DescribeDBInstanceEncryptionKeyResult(outcome.result()));
+	else
+		return DescribeDBInstanceEncryptionKeyOutcome(outcome.error());
+}
+
+void DdsClient::describeDBInstanceEncryptionKeyAsync(const DescribeDBInstanceEncryptionKeyRequest& request, const DescribeDBInstanceEncryptionKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDBInstanceEncryptionKey(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DdsClient::DescribeDBInstanceEncryptionKeyOutcomeCallable DdsClient::describeDBInstanceEncryptionKeyCallable(const DescribeDBInstanceEncryptionKeyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDBInstanceEncryptionKeyOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDBInstanceEncryptionKey(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DdsClient::DescribeDBInstanceMonitorOutcome DdsClient::describeDBInstanceMonitor(const DescribeDBInstanceMonitorRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1707,6 +1707,42 @@ DdsClient::DescribeTagsOutcomeCallable DdsClient::describeTagsCallable(const Des
 	return task->get_future();
 }
 
+DdsClient::DescribeUserEncryptionKeyListOutcome DdsClient::describeUserEncryptionKeyList(const DescribeUserEncryptionKeyListRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeUserEncryptionKeyListOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeUserEncryptionKeyListOutcome(DescribeUserEncryptionKeyListResult(outcome.result()));
+	else
+		return DescribeUserEncryptionKeyListOutcome(outcome.error());
+}
+
+void DdsClient::describeUserEncryptionKeyListAsync(const DescribeUserEncryptionKeyListRequest& request, const DescribeUserEncryptionKeyListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeUserEncryptionKeyList(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DdsClient::DescribeUserEncryptionKeyListOutcomeCallable DdsClient::describeUserEncryptionKeyListCallable(const DescribeUserEncryptionKeyListRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeUserEncryptionKeyListOutcome()>>(
+			[this, request]()
+			{
+			return this->describeUserEncryptionKeyList(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DdsClient::DestroyInstanceOutcome DdsClient::destroyInstance(const DestroyInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

dds/src/model/AllocateNodePrivateNetworkAddressRequest.cc

@@ -35,7 +35,7 @@ long AllocateNodePrivateNetworkAddressRequest::getResourceOwnerId()const
 void AllocateNodePrivateNetworkAddressRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string AllocateNodePrivateNetworkAddressRequest::getAccessKeyId()const
@@ -46,7 +46,7 @@ std::string AllocateNodePrivateNetworkAddressRequest::getAccessKeyId()const
 void AllocateNodePrivateNetworkAddressRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string AllocateNodePrivateNetworkAddressRequest::getAccountName()const
@@ -57,7 +57,7 @@ std::string AllocateNodePrivateNetworkAddressRequest::getAccountName()const
 void AllocateNodePrivateNetworkAddressRequest::setAccountName(const std::string& accountName)
 {
 	accountName_ = accountName;
-	setCoreParameter("AccountName", accountName);
+	setParameter("AccountName", accountName);
 }
 
 std::string AllocateNodePrivateNetworkAddressRequest::getSecurityToken()const
@@ -68,7 +68,7 @@ std::string AllocateNodePrivateNetworkAddressRequest::getSecurityToken()const
 void AllocateNodePrivateNetworkAddressRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string AllocateNodePrivateNetworkAddressRequest::getDBInstanceId()const
@@ -79,7 +79,7 @@ std::string AllocateNodePrivateNetworkAddressRequest::getDBInstanceId()const
 void AllocateNodePrivateNetworkAddressRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string AllocateNodePrivateNetworkAddressRequest::getNodeId()const
@@ -90,7 +90,7 @@ std::string AllocateNodePrivateNetworkAddressRequest::getNodeId()const
 void AllocateNodePrivateNetworkAddressRequest::setNodeId(const std::string& nodeId)
 {
 	nodeId_ = nodeId;
-	setCoreParameter("NodeId", nodeId);
+	setParameter("NodeId", nodeId);
 }
 
 std::string AllocateNodePrivateNetworkAddressRequest::getResourceOwnerAccount()const
@@ -101,7 +101,7 @@ std::string AllocateNodePrivateNetworkAddressRequest::getResourceOwnerAccount()c
 void AllocateNodePrivateNetworkAddressRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string AllocateNodePrivateNetworkAddressRequest::getOwnerAccount()const
@@ -112,7 +112,7 @@ std::string AllocateNodePrivateNetworkAddressRequest::getOwnerAccount()const
 void AllocateNodePrivateNetworkAddressRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long AllocateNodePrivateNetworkAddressRequest::getOwnerId()const
@@ -123,7 +123,7 @@ long AllocateNodePrivateNetworkAddressRequest::getOwnerId()const
 void AllocateNodePrivateNetworkAddressRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string AllocateNodePrivateNetworkAddressRequest::getAccountPassword()const
@@ -134,7 +134,7 @@ std::string AllocateNodePrivateNetworkAddressRequest::getAccountPassword()const
 void AllocateNodePrivateNetworkAddressRequest::setAccountPassword(const std::string& accountPassword)
 {
 	accountPassword_ = accountPassword;
-	setCoreParameter("AccountPassword", accountPassword);
+	setParameter("AccountPassword", accountPassword);
 }
 
 std::string AllocateNodePrivateNetworkAddressRequest::getZoneId()const
@@ -145,6 +145,6 @@ std::string AllocateNodePrivateNetworkAddressRequest::getZoneId()const
 void AllocateNodePrivateNetworkAddressRequest::setZoneId(const std::string& zoneId)
 {
 	zoneId_ = zoneId;
-	setCoreParameter("ZoneId", zoneId);
+	setParameter("ZoneId", zoneId);
 }
 

dds/src/model/AllocatePublicNetworkAddressRequest.cc

@@ -35,7 +35,7 @@ long AllocatePublicNetworkAddressRequest::getResourceOwnerId()const
 void AllocatePublicNetworkAddressRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string AllocatePublicNetworkAddressRequest::getAccessKeyId()const
@@ -46,7 +46,7 @@ std::string AllocatePublicNetworkAddressRequest::getAccessKeyId()const
 void AllocatePublicNetworkAddressRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string AllocatePublicNetworkAddressRequest::getSecurityToken()const
@@ -57,7 +57,7 @@ std::string AllocatePublicNetworkAddressRequest::getSecurityToken()const
 void AllocatePublicNetworkAddressRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string AllocatePublicNetworkAddressRequest::getDBInstanceId()const
@@ -68,7 +68,7 @@ std::string AllocatePublicNetworkAddressRequest::getDBInstanceId()const
 void AllocatePublicNetworkAddressRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string AllocatePublicNetworkAddressRequest::getNodeId()const
@@ -79,7 +79,7 @@ std::string AllocatePublicNetworkAddressRequest::getNodeId()const
 void AllocatePublicNetworkAddressRequest::setNodeId(const std::string& nodeId)
 {
 	nodeId_ = nodeId;
-	setCoreParameter("NodeId", nodeId);
+	setParameter("NodeId", nodeId);
 }
 
 std::string AllocatePublicNetworkAddressRequest::getResourceOwnerAccount()const
@@ -90,7 +90,7 @@ std::string AllocatePublicNetworkAddressRequest::getResourceOwnerAccount()const
 void AllocatePublicNetworkAddressRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string AllocatePublicNetworkAddressRequest::getOwnerAccount()const
@@ -101,7 +101,7 @@ std::string AllocatePublicNetworkAddressRequest::getOwnerAccount()const
 void AllocatePublicNetworkAddressRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long AllocatePublicNetworkAddressRequest::getOwnerId()const
@@ -112,6 +112,6 @@ long AllocatePublicNetworkAddressRequest::getOwnerId()const
 void AllocatePublicNetworkAddressRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

dds/src/model/CheckCloudResourceAuthorizedRequest.cc

@@ -35,7 +35,7 @@ long CheckCloudResourceAuthorizedRequest::getResourceOwnerId()const
 void CheckCloudResourceAuthorizedRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string CheckCloudResourceAuthorizedRequest::getAccessKeyId()const
@@ -46,7 +46,7 @@ std::string CheckCloudResourceAuthorizedRequest::getAccessKeyId()const
 void CheckCloudResourceAuthorizedRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string CheckCloudResourceAuthorizedRequest::getSecurityToken()const
@@ -57,7 +57,7 @@ std::string CheckCloudResourceAuthorizedRequest::getSecurityToken()const
 void CheckCloudResourceAuthorizedRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string CheckCloudResourceAuthorizedRequest::getDBInstanceId()const
@@ -68,7 +68,7 @@ std::string CheckCloudResourceAuthorizedRequest::getDBInstanceId()const
 void CheckCloudResourceAuthorizedRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string CheckCloudResourceAuthorizedRequest::getResourceOwnerAccount()const
@@ -79,7 +79,7 @@ std::string CheckCloudResourceAuthorizedRequest::getResourceOwnerAccount()const
 void CheckCloudResourceAuthorizedRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string CheckCloudResourceAuthorizedRequest::getOwnerAccount()const
@@ -90,7 +90,7 @@ std::string CheckCloudResourceAuthorizedRequest::getOwnerAccount()const
 void CheckCloudResourceAuthorizedRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long CheckCloudResourceAuthorizedRequest::getOwnerId()const
@@ -101,7 +101,7 @@ long CheckCloudResourceAuthorizedRequest::getOwnerId()const
 void CheckCloudResourceAuthorizedRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string CheckCloudResourceAuthorizedRequest::getTargetRegionId()const
@@ -112,6 +112,6 @@ std::string CheckCloudResourceAuthorizedRequest::getTargetRegionId()const
 void CheckCloudResourceAuthorizedRequest::setTargetRegionId(const std::string& targetRegionId)
 {
 	targetRegionId_ = targetRegionId;
-	setCoreParameter("TargetRegionId", targetRegionId);
+	setParameter("TargetRegionId", targetRegionId);
 }
 

dds/src/model/CheckRecoveryConditionRequest.cc

@@ -35,7 +35,7 @@ long CheckRecoveryConditionRequest::getResourceOwnerId()const
 void CheckRecoveryConditionRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string CheckRecoveryConditionRequest::getAccessKeyId()const
@@ -46,7 +46,7 @@ std::string CheckRecoveryConditionRequest::getAccessKeyId()const
 void CheckRecoveryConditionRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string CheckRecoveryConditionRequest::getDatabaseNames()const
@@ -57,7 +57,7 @@ std::string CheckRecoveryConditionRequest::getDatabaseNames()const
 void CheckRecoveryConditionRequest::setDatabaseNames(const std::string& databaseNames)
 {
 	databaseNames_ = databaseNames;
-	setCoreParameter("DatabaseNames", databaseNames);
+	setParameter("DatabaseNames", databaseNames);
 }
 
 std::string CheckRecoveryConditionRequest::getSecurityToken()const
@@ -68,7 +68,7 @@ std::string CheckRecoveryConditionRequest::getSecurityToken()const
 void CheckRecoveryConditionRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string CheckRecoveryConditionRequest::getRestoreTime()const
@@ -79,7 +79,7 @@ std::string CheckRecoveryConditionRequest::getRestoreTime()const
 void CheckRecoveryConditionRequest::setRestoreTime(const std::string& restoreTime)
 {
 	restoreTime_ = restoreTime;
-	setCoreParameter("RestoreTime", restoreTime);
+	setParameter("RestoreTime", restoreTime);
 }
 
 std::string CheckRecoveryConditionRequest::getResourceOwnerAccount()const
@@ -90,7 +90,7 @@ std::string CheckRecoveryConditionRequest::getResourceOwnerAccount()const
 void CheckRecoveryConditionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string CheckRecoveryConditionRequest::getOwnerAccount()const
@@ -101,7 +101,7 @@ std::string CheckRecoveryConditionRequest::getOwnerAccount()const
 void CheckRecoveryConditionRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 std::string CheckRecoveryConditionRequest::getBackupId()const
@@ -112,7 +112,7 @@ std::string CheckRecoveryConditionRequest::getBackupId()const
 void CheckRecoveryConditionRequest::setBackupId(const std::string& backupId)
 {
 	backupId_ = backupId;
-	setCoreParameter("BackupId", backupId);
+	setParameter("BackupId", backupId);
 }
 
 std::string CheckRecoveryConditionRequest::getSourceDBInstance()const
@@ -123,7 +123,7 @@ std::string CheckRecoveryConditionRequest::getSourceDBInstance()const
 void CheckRecoveryConditionRequest::setSourceDBInstance(const std::string& sourceDBInstance)
 {
 	sourceDBInstance_ = sourceDBInstance;
-	setCoreParameter("SourceDBInstance", sourceDBInstance);
+	setParameter("SourceDBInstance", sourceDBInstance);
 }
 
 long CheckRecoveryConditionRequest::getOwnerId()const
@@ -134,6 +134,6 @@ long CheckRecoveryConditionRequest::getOwnerId()const
 void CheckRecoveryConditionRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

dds/src/model/CreateAccountRequest.cc

@@ -1,139 +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/dds/model/CreateAccountRequest.h>
-
-using AlibabaCloud::Dds::Model::CreateAccountRequest;
-
-CreateAccountRequest::CreateAccountRequest() :
-	RpcServiceRequest("dds", "2015-12-01", "CreateAccount")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateAccountRequest::~CreateAccountRequest()
-{}
-
-long CreateAccountRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
-}
-
-void CreateAccountRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
-}
-
-std::string CreateAccountRequest::getAccountDescription()const
-{
-	return accountDescription_;
-}
-
-void CreateAccountRequest::setAccountDescription(const std::string& accountDescription)
-{
-	accountDescription_ = accountDescription;
-	setCoreParameter("AccountDescription", accountDescription);
-}
-
-std::string CreateAccountRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
-}
-
-void CreateAccountRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
-}
-
-std::string CreateAccountRequest::getAccountName()const
-{
-	return accountName_;
-}
-
-void CreateAccountRequest::setAccountName(const std::string& accountName)
-{
-	accountName_ = accountName;
-	setCoreParameter("AccountName", accountName);
-}
-
-std::string CreateAccountRequest::getSecurityToken()const
-{
-	return securityToken_;
-}
-
-void CreateAccountRequest::setSecurityToken(const std::string& securityToken)
-{
-	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
-}
-
-std::string CreateAccountRequest::getDBInstanceId()const
-{
-	return dBInstanceId_;
-}
-
-void CreateAccountRequest::setDBInstanceId(const std::string& dBInstanceId)
-{
-	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
-}
-
-std::string CreateAccountRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
-}
-
-void CreateAccountRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
-}
-
-std::string CreateAccountRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
-}
-
-void CreateAccountRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
-}
-
-long CreateAccountRequest::getOwnerId()const
-{
-	return ownerId_;
-}
-
-void CreateAccountRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
-}
-
-std::string CreateAccountRequest::getAccountPassword()const
-{
-	return accountPassword_;
-}
-
-void CreateAccountRequest::setAccountPassword(const std::string& accountPassword)
-{
-	accountPassword_ = accountPassword;
-	setCoreParameter("AccountPassword", accountPassword);
-}
-

dds/src/model/CreateBackupRequest.cc

@@ -35,7 +35,7 @@ long CreateBackupRequest::getResourceOwnerId()const
 void CreateBackupRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string CreateBackupRequest::getAccessKeyId()const
@@ -46,7 +46,7 @@ std::string CreateBackupRequest::getAccessKeyId()const
 void CreateBackupRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string CreateBackupRequest::getSecurityToken()const
@@ -57,7 +57,7 @@ std::string CreateBackupRequest::getSecurityToken()const
 void CreateBackupRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string CreateBackupRequest::getDBInstanceId()const
@@ -68,7 +68,7 @@ std::string CreateBackupRequest::getDBInstanceId()const
 void CreateBackupRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string CreateBackupRequest::getResourceOwnerAccount()const
@@ -79,7 +79,7 @@ std::string CreateBackupRequest::getResourceOwnerAccount()const
 void CreateBackupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string CreateBackupRequest::getOwnerAccount()const
@@ -90,7 +90,7 @@ std::string CreateBackupRequest::getOwnerAccount()const
 void CreateBackupRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long CreateBackupRequest::getOwnerId()const
@@ -101,7 +101,7 @@ long CreateBackupRequest::getOwnerId()const
 void CreateBackupRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string CreateBackupRequest::getBackupMethod()const
@@ -112,6 +112,6 @@ std::string CreateBackupRequest::getBackupMethod()const
 void CreateBackupRequest::setBackupMethod(const std::string& backupMethod)
 {
 	backupMethod_ = backupMethod;
-	setCoreParameter("BackupMethod", backupMethod);
+	setParameter("BackupMethod", backupMethod);
 }
 

dds/src/model/CreateDBInstanceRequest.cc

@@ -35,7 +35,7 @@ long CreateDBInstanceRequest::getResourceOwnerId()const
 void CreateDBInstanceRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 int CreateDBInstanceRequest::getDBInstanceStorage()const
@@ -46,7 +46,7 @@ int CreateDBInstanceRequest::getDBInstanceStorage()const
 void CreateDBInstanceRequest::setDBInstanceStorage(int dBInstanceStorage)
 {
 	dBInstanceStorage_ = dBInstanceStorage;
-	setCoreParameter("DBInstanceStorage", std::to_string(dBInstanceStorage));
+	setParameter("DBInstanceStorage", std::to_string(dBInstanceStorage));
 }
 
 std::string CreateDBInstanceRequest::getCouponNo()const
@@ -57,7 +57,7 @@ std::string CreateDBInstanceRequest::getCouponNo()const
 void CreateDBInstanceRequest::setCouponNo(const std::string& couponNo)
 {
 	couponNo_ = couponNo;
-	setCoreParameter("CouponNo", couponNo);
+	setParameter("CouponNo", couponNo);
 }
 
 std::string CreateDBInstanceRequest::getEngineVersion()const
@@ -68,7 +68,7 @@ std::string CreateDBInstanceRequest::getEngineVersion()const
 void CreateDBInstanceRequest::setEngineVersion(const std::string& engineVersion)
 {
 	engineVersion_ = engineVersion;
-	setCoreParameter("EngineVersion", engineVersion);
+	setParameter("EngineVersion", engineVersion);
 }
 
 std::string CreateDBInstanceRequest::getNetworkType()const
@@ -79,7 +79,7 @@ std::string CreateDBInstanceRequest::getNetworkType()const
 void CreateDBInstanceRequest::setNetworkType(const std::string& networkType)
 {
 	networkType_ = networkType;
-	setCoreParameter("NetworkType", networkType);
+	setParameter("NetworkType", networkType);
 }
 
 std::string CreateDBInstanceRequest::getResourceGroupId()const
@@ -90,7 +90,7 @@ std::string CreateDBInstanceRequest::getResourceGroupId()const
 void CreateDBInstanceRequest::setResourceGroupId(const std::string& resourceGroupId)
 {
 	resourceGroupId_ = resourceGroupId;
-	setCoreParameter("ResourceGroupId", resourceGroupId);
+	setParameter("ResourceGroupId", resourceGroupId);
 }
 
 std::string CreateDBInstanceRequest::getSecurityToken()const
@@ -101,7 +101,7 @@ std::string CreateDBInstanceRequest::getSecurityToken()const
 void CreateDBInstanceRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string CreateDBInstanceRequest::getDBInstanceDescription()const
@@ -112,7 +112,7 @@ std::string CreateDBInstanceRequest::getDBInstanceDescription()const
 void CreateDBInstanceRequest::setDBInstanceDescription(const std::string& dBInstanceDescription)
 {
 	dBInstanceDescription_ = dBInstanceDescription;
-	setCoreParameter("DBInstanceDescription", dBInstanceDescription);
+	setParameter("DBInstanceDescription", dBInstanceDescription);
 }
 
 std::string CreateDBInstanceRequest::getBusinessInfo()const
@@ -123,7 +123,7 @@ std::string CreateDBInstanceRequest::getBusinessInfo()const
 void CreateDBInstanceRequest::setBusinessInfo(const std::string& businessInfo)
 {
 	businessInfo_ = businessInfo;
-	setCoreParameter("BusinessInfo", businessInfo);
+	setParameter("BusinessInfo", businessInfo);
 }
 
 int CreateDBInstanceRequest::getPeriod()const
@@ -134,7 +134,7 @@ int CreateDBInstanceRequest::getPeriod()const
 void CreateDBInstanceRequest::setPeriod(int period)
 {
 	period_ = period;
-	setCoreParameter("Period", std::to_string(period));
+	setParameter("Period", std::to_string(period));
 }
 
 std::string CreateDBInstanceRequest::getBackupId()const
@@ -145,7 +145,7 @@ std::string CreateDBInstanceRequest::getBackupId()const
 void CreateDBInstanceRequest::setBackupId(const std::string& backupId)
 {
 	backupId_ = backupId;
-	setCoreParameter("BackupId", backupId);
+	setParameter("BackupId", backupId);
 }
 
 long CreateDBInstanceRequest::getOwnerId()const
@@ -156,7 +156,7 @@ long CreateDBInstanceRequest::getOwnerId()const
 void CreateDBInstanceRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string CreateDBInstanceRequest::getDBInstanceClass()const
@@ -167,7 +167,7 @@ std::string CreateDBInstanceRequest::getDBInstanceClass()const
 void CreateDBInstanceRequest::setDBInstanceClass(const std::string& dBInstanceClass)
 {
 	dBInstanceClass_ = dBInstanceClass;
-	setCoreParameter("DBInstanceClass", dBInstanceClass);
+	setParameter("DBInstanceClass", dBInstanceClass);
 }
 
 std::string CreateDBInstanceRequest::getSecurityIPList()const
@@ -178,7 +178,7 @@ std::string CreateDBInstanceRequest::getSecurityIPList()const
 void CreateDBInstanceRequest::setSecurityIPList(const std::string& securityIPList)
 {
 	securityIPList_ = securityIPList;
-	setCoreParameter("SecurityIPList", securityIPList);
+	setParameter("SecurityIPList", securityIPList);
 }
 
 std::string CreateDBInstanceRequest::getVSwitchId()const
@@ -189,7 +189,7 @@ std::string CreateDBInstanceRequest::getVSwitchId()const
 void CreateDBInstanceRequest::setVSwitchId(const std::string& vSwitchId)
 {
 	vSwitchId_ = vSwitchId;
-	setCoreParameter("VSwitchId", vSwitchId);
+	setParameter("VSwitchId", vSwitchId);
 }
 
 std::string CreateDBInstanceRequest::getAutoRenew()const
@@ -200,7 +200,7 @@ std::string CreateDBInstanceRequest::getAutoRenew()const
 void CreateDBInstanceRequest::setAutoRenew(const std::string& autoRenew)
 {
 	autoRenew_ = autoRenew;
-	setCoreParameter("AutoRenew", autoRenew);
+	setParameter("AutoRenew", autoRenew);
 }
 
 std::string CreateDBInstanceRequest::getZoneId()const
@@ -211,7 +211,7 @@ std::string CreateDBInstanceRequest::getZoneId()const
 void CreateDBInstanceRequest::setZoneId(const std::string& zoneId)
 {
 	zoneId_ = zoneId;
-	setCoreParameter("ZoneId", zoneId);
+	setParameter("ZoneId", zoneId);
 }
 
 std::string CreateDBInstanceRequest::getClientToken()const
@@ -222,7 +222,7 @@ std::string CreateDBInstanceRequest::getClientToken()const
 void CreateDBInstanceRequest::setClientToken(const std::string& clientToken)
 {
 	clientToken_ = clientToken;
-	setCoreParameter("ClientToken", clientToken);
+	setParameter("ClientToken", clientToken);
 }
 
 std::string CreateDBInstanceRequest::getReadonlyReplicas()const
@@ -233,7 +233,7 @@ std::string CreateDBInstanceRequest::getReadonlyReplicas()const
 void CreateDBInstanceRequest::setReadonlyReplicas(const std::string& readonlyReplicas)
 {
 	readonlyReplicas_ = readonlyReplicas;
-	setCoreParameter("ReadonlyReplicas", readonlyReplicas);
+	setParameter("ReadonlyReplicas", readonlyReplicas);
 }
 
 std::string CreateDBInstanceRequest::getReplicationFactor()const
@@ -244,7 +244,7 @@ std::string CreateDBInstanceRequest::getReplicationFactor()const
 void CreateDBInstanceRequest::setReplicationFactor(const std::string& replicationFactor)
 {
 	replicationFactor_ = replicationFactor;
-	setCoreParameter("ReplicationFactor", replicationFactor);
+	setParameter("ReplicationFactor", replicationFactor);
 }
 
 std::string CreateDBInstanceRequest::getAccessKeyId()const
@@ -255,7 +255,7 @@ std::string CreateDBInstanceRequest::getAccessKeyId()const
 void CreateDBInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string CreateDBInstanceRequest::getStorageEngine()const
@@ -266,7 +266,7 @@ std::string CreateDBInstanceRequest::getStorageEngine()const
 void CreateDBInstanceRequest::setStorageEngine(const std::string& storageEngine)
 {
 	storageEngine_ = storageEngine;
-	setCoreParameter("StorageEngine", storageEngine);
+	setParameter("StorageEngine", storageEngine);
 }
 
 std::string CreateDBInstanceRequest::getDatabaseNames()const
@@ -277,7 +277,7 @@ std::string CreateDBInstanceRequest::getDatabaseNames()const
 void CreateDBInstanceRequest::setDatabaseNames(const std::string& databaseNames)
 {
 	databaseNames_ = databaseNames;
-	setCoreParameter("DatabaseNames", databaseNames);
+	setParameter("DatabaseNames", databaseNames);
 }
 
 std::string CreateDBInstanceRequest::getEngine()const
@@ -288,7 +288,7 @@ std::string CreateDBInstanceRequest::getEngine()const
 void CreateDBInstanceRequest::setEngine(const std::string& engine)
 {
 	engine_ = engine;
-	setCoreParameter("Engine", engine);
+	setParameter("Engine", engine);
 }
 
 std::string CreateDBInstanceRequest::getRestoreTime()const
@@ -299,7 +299,7 @@ std::string CreateDBInstanceRequest::getRestoreTime()const
 void CreateDBInstanceRequest::setRestoreTime(const std::string& restoreTime)
 {
 	restoreTime_ = restoreTime;
-	setCoreParameter("RestoreTime", restoreTime);
+	setParameter("RestoreTime", restoreTime);
 }
 
 std::string CreateDBInstanceRequest::getResourceOwnerAccount()const
@@ -310,7 +310,7 @@ std::string CreateDBInstanceRequest::getResourceOwnerAccount()const
 void CreateDBInstanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string CreateDBInstanceRequest::getSrcDBInstanceId()const
@@ -321,7 +321,7 @@ std::string CreateDBInstanceRequest::getSrcDBInstanceId()const
 void CreateDBInstanceRequest::setSrcDBInstanceId(const std::string& srcDBInstanceId)
 {
 	srcDBInstanceId_ = srcDBInstanceId;
-	setCoreParameter("SrcDBInstanceId", srcDBInstanceId);
+	setParameter("SrcDBInstanceId", srcDBInstanceId);
 }
 
 std::string CreateDBInstanceRequest::getOwnerAccount()const
@@ -332,7 +332,7 @@ std::string CreateDBInstanceRequest::getOwnerAccount()const
 void CreateDBInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 std::string CreateDBInstanceRequest::getAccountPassword()const
@@ -343,7 +343,7 @@ std::string CreateDBInstanceRequest::getAccountPassword()const
 void CreateDBInstanceRequest::setAccountPassword(const std::string& accountPassword)
 {
 	accountPassword_ = accountPassword;
-	setCoreParameter("AccountPassword", accountPassword);
+	setParameter("AccountPassword", accountPassword);
 }
 
 std::string CreateDBInstanceRequest::getVpcId()const
@@ -354,7 +354,7 @@ std::string CreateDBInstanceRequest::getVpcId()const
 void CreateDBInstanceRequest::setVpcId(const std::string& vpcId)
 {
 	vpcId_ = vpcId;
-	setCoreParameter("VpcId", vpcId);
+	setParameter("VpcId", vpcId);
 }
 
 std::string CreateDBInstanceRequest::getChargeType()const
@@ -365,6 +365,6 @@ std::string CreateDBInstanceRequest::getChargeType()const
 void CreateDBInstanceRequest::setChargeType(const std::string& chargeType)
 {
 	chargeType_ = chargeType;
-	setCoreParameter("ChargeType", chargeType);
+	setParameter("ChargeType", chargeType);
 }
 

dds/src/model/CreateNodeRequest.cc

@@ -35,7 +35,7 @@ long CreateNodeRequest::getResourceOwnerId()const
 void CreateNodeRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string CreateNodeRequest::getNodeType()const
@@ -46,7 +46,7 @@ std::string CreateNodeRequest::getNodeType()const
 void CreateNodeRequest::setNodeType(const std::string& nodeType)
 {
 	nodeType_ = nodeType;
-	setCoreParameter("NodeType", nodeType);
+	setParameter("NodeType", nodeType);
 }
 
 std::string CreateNodeRequest::getClientToken()const
@@ -57,7 +57,7 @@ std::string CreateNodeRequest::getClientToken()const
 void CreateNodeRequest::setClientToken(const std::string& clientToken)
 {
 	clientToken_ = clientToken;
-	setCoreParameter("ClientToken", clientToken);
+	setParameter("ClientToken", clientToken);
 }
 
 std::string CreateNodeRequest::getNodeClass()const
@@ -68,7 +68,7 @@ std::string CreateNodeRequest::getNodeClass()const
 void CreateNodeRequest::setNodeClass(const std::string& nodeClass)
 {
 	nodeClass_ = nodeClass;
-	setCoreParameter("NodeClass", nodeClass);
+	setParameter("NodeClass", nodeClass);
 }
 
 std::string CreateNodeRequest::getAccessKeyId()const
@@ -79,7 +79,7 @@ std::string CreateNodeRequest::getAccessKeyId()const
 void CreateNodeRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string CreateNodeRequest::getSecurityToken()const
@@ -90,7 +90,7 @@ std::string CreateNodeRequest::getSecurityToken()const
 void CreateNodeRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string CreateNodeRequest::getDBInstanceId()const
@@ -101,7 +101,7 @@ std::string CreateNodeRequest::getDBInstanceId()const
 void CreateNodeRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 bool CreateNodeRequest::getAutoPay()const
@@ -112,7 +112,7 @@ bool CreateNodeRequest::getAutoPay()const
 void CreateNodeRequest::setAutoPay(bool autoPay)
 {
 	autoPay_ = autoPay;
-	setCoreParameter("AutoPay", autoPay ? "true" : "false");
+	setParameter("AutoPay", autoPay ? "true" : "false");
 }
 
 std::string CreateNodeRequest::getFromApp()const
@@ -123,7 +123,7 @@ std::string CreateNodeRequest::getFromApp()const
 void CreateNodeRequest::setFromApp(const std::string& fromApp)
 {
 	fromApp_ = fromApp;
-	setCoreParameter("FromApp", fromApp);
+	setParameter("FromApp", fromApp);
 }
 
 std::string CreateNodeRequest::getResourceOwnerAccount()const
@@ -134,7 +134,7 @@ std::string CreateNodeRequest::getResourceOwnerAccount()const
 void CreateNodeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 int CreateNodeRequest::getNodeStorage()const
@@ -145,7 +145,7 @@ int CreateNodeRequest::getNodeStorage()const
 void CreateNodeRequest::setNodeStorage(int nodeStorage)
 {
 	nodeStorage_ = nodeStorage;
-	setCoreParameter("NodeStorage", std::to_string(nodeStorage));
+	setParameter("NodeStorage", std::to_string(nodeStorage));
 }
 
 std::string CreateNodeRequest::getOwnerAccount()const
@@ -156,7 +156,7 @@ std::string CreateNodeRequest::getOwnerAccount()const
 void CreateNodeRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long CreateNodeRequest::getOwnerId()const
@@ -167,6 +167,6 @@ long CreateNodeRequest::getOwnerId()const
 void CreateNodeRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

dds/src/model/CreateRecommendationTaskRequest.cc

@@ -35,7 +35,7 @@ long CreateRecommendationTaskRequest::getResourceOwnerId()const
 void CreateRecommendationTaskRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string CreateRecommendationTaskRequest::getStartTime()const
@@ -46,7 +46,7 @@ std::string CreateRecommendationTaskRequest::getStartTime()const
 void CreateRecommendationTaskRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string CreateRecommendationTaskRequest::getAccessKeyId()const
@@ -57,7 +57,7 @@ std::string CreateRecommendationTaskRequest::getAccessKeyId()const
 void CreateRecommendationTaskRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string CreateRecommendationTaskRequest::getSecurityToken()const
@@ -68,7 +68,7 @@ std::string CreateRecommendationTaskRequest::getSecurityToken()const
 void CreateRecommendationTaskRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string CreateRecommendationTaskRequest::getNodeId()const
@@ -79,7 +79,7 @@ std::string CreateRecommendationTaskRequest::getNodeId()const
 void CreateRecommendationTaskRequest::setNodeId(const std::string& nodeId)
 {
 	nodeId_ = nodeId;
-	setCoreParameter("NodeId", nodeId);
+	setParameter("NodeId", nodeId);
 }
 
 std::string CreateRecommendationTaskRequest::getResourceOwnerAccount()const
@@ -90,7 +90,7 @@ std::string CreateRecommendationTaskRequest::getResourceOwnerAccount()const
 void CreateRecommendationTaskRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string CreateRecommendationTaskRequest::getOwnerAccount()const
@@ -101,7 +101,7 @@ std::string CreateRecommendationTaskRequest::getOwnerAccount()const
 void CreateRecommendationTaskRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 std::string CreateRecommendationTaskRequest::getEndTime()const
@@ -112,7 +112,7 @@ std::string CreateRecommendationTaskRequest::getEndTime()const
 void CreateRecommendationTaskRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long CreateRecommendationTaskRequest::getOwnerId()const
@@ -123,7 +123,7 @@ long CreateRecommendationTaskRequest::getOwnerId()const
 void CreateRecommendationTaskRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string CreateRecommendationTaskRequest::getInstanceId()const
@@ -134,6 +134,6 @@ std::string CreateRecommendationTaskRequest::getInstanceId()const
 void CreateRecommendationTaskRequest::setInstanceId(const std::string& instanceId)
 {
 	instanceId_ = instanceId;
-	setCoreParameter("InstanceId", instanceId);
+	setParameter("InstanceId", instanceId);
 }
 

dds/src/model/CreateShardingDBInstanceRequest.cc

@@ -35,7 +35,7 @@ long CreateShardingDBInstanceRequest::getResourceOwnerId()const
 void CreateShardingDBInstanceRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string CreateShardingDBInstanceRequest::getClientToken()const
@@ -46,7 +46,7 @@ std::string CreateShardingDBInstanceRequest::getClientToken()const
 void CreateShardingDBInstanceRequest::setClientToken(const std::string& clientToken)
 {
 	clientToken_ = clientToken;
-	setCoreParameter("ClientToken", clientToken);
+	setParameter("ClientToken", clientToken);
 }
 
 std::string CreateShardingDBInstanceRequest::getEngineVersion()const
@@ -57,7 +57,7 @@ std::string CreateShardingDBInstanceRequest::getEngineVersion()const
 void CreateShardingDBInstanceRequest::setEngineVersion(const std::string& engineVersion)
 {
 	engineVersion_ = engineVersion;
-	setCoreParameter("EngineVersion", engineVersion);
+	setParameter("EngineVersion", engineVersion);
 }
 
 std::string CreateShardingDBInstanceRequest::getNetworkType()const
@@ -68,7 +68,7 @@ std::string CreateShardingDBInstanceRequest::getNetworkType()const
 void CreateShardingDBInstanceRequest::setNetworkType(const std::string& networkType)
 {
 	networkType_ = networkType;
-	setCoreParameter("NetworkType", networkType);
+	setParameter("NetworkType", networkType);
 }
 
 std::vector<CreateShardingDBInstanceRequest::ReplicaSet> CreateShardingDBInstanceRequest::getReplicaSet()const
@@ -81,9 +81,9 @@ void CreateShardingDBInstanceRequest::setReplicaSet(const std::vector<ReplicaSet
 	replicaSet_ = replicaSet;
 	for(int dep1 = 0; dep1!= replicaSet.size(); dep1++) {
 		auto replicaSetObj = replicaSet.at(dep1);
-		std::string replicaSetObjStr = "ReplicaSet." + std::to_string(dep1);
-		setCoreParameter(replicaSetObjStr + ".Storage", std::to_string(replicaSetObj.storage));
-		setCoreParameter(replicaSetObjStr + "._Class", replicaSetObj._class);
+		std::string replicaSetObjStr = "ReplicaSet." + std::to_string(dep1 + 1);
+		setParameter(replicaSetObjStr + ".Storage", std::to_string(replicaSetObj.storage));
+		setParameter(replicaSetObjStr + "._Class", replicaSetObj._class);
 	}
 }
 
@@ -95,7 +95,7 @@ std::string CreateShardingDBInstanceRequest::getAccessKeyId()const
 void CreateShardingDBInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string CreateShardingDBInstanceRequest::getStorageEngine()const
@@ -106,7 +106,7 @@ std::string CreateShardingDBInstanceRequest::getStorageEngine()const
 void CreateShardingDBInstanceRequest::setStorageEngine(const std::string& storageEngine)
 {
 	storageEngine_ = storageEngine;
-	setCoreParameter("StorageEngine", storageEngine);
+	setParameter("StorageEngine", storageEngine);
 }
 
 std::string CreateShardingDBInstanceRequest::getSecurityToken()const
@@ -117,7 +117,7 @@ std::string CreateShardingDBInstanceRequest::getSecurityToken()const
 void CreateShardingDBInstanceRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string CreateShardingDBInstanceRequest::getEngine()const
@@ -128,7 +128,7 @@ std::string CreateShardingDBInstanceRequest::getEngine()const
 void CreateShardingDBInstanceRequest::setEngine(const std::string& engine)
 {
 	engine_ = engine;
-	setCoreParameter("Engine", engine);
+	setParameter("Engine", engine);
 }
 
 std::string CreateShardingDBInstanceRequest::getDBInstanceDescription()const
@@ -139,7 +139,7 @@ std::string CreateShardingDBInstanceRequest::getDBInstanceDescription()const
 void CreateShardingDBInstanceRequest::setDBInstanceDescription(const std::string& dBInstanceDescription)
 {
 	dBInstanceDescription_ = dBInstanceDescription;
-	setCoreParameter("DBInstanceDescription", dBInstanceDescription);
+	setParameter("DBInstanceDescription", dBInstanceDescription);
 }
 
 int CreateShardingDBInstanceRequest::getPeriod()const
@@ -150,7 +150,7 @@ int CreateShardingDBInstanceRequest::getPeriod()const
 void CreateShardingDBInstanceRequest::setPeriod(int period)
 {
 	period_ = period;
-	setCoreParameter("Period", std::to_string(period));
+	setParameter("Period", std::to_string(period));
 }
 
 std::string CreateShardingDBInstanceRequest::getRestoreTime()const
@@ -161,7 +161,7 @@ std::string CreateShardingDBInstanceRequest::getRestoreTime()const
 void CreateShardingDBInstanceRequest::setRestoreTime(const std::string& restoreTime)
 {
 	restoreTime_ = restoreTime;
-	setCoreParameter("RestoreTime", restoreTime);
+	setParameter("RestoreTime", restoreTime);
 }
 
 std::string CreateShardingDBInstanceRequest::getResourceOwnerAccount()const
@@ -172,7 +172,7 @@ std::string CreateShardingDBInstanceRequest::getResourceOwnerAccount()const
 void CreateShardingDBInstanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string CreateShardingDBInstanceRequest::getSrcDBInstanceId()const
@@ -183,7 +183,7 @@ std::string CreateShardingDBInstanceRequest::getSrcDBInstanceId()const
 void CreateShardingDBInstanceRequest::setSrcDBInstanceId(const std::string& srcDBInstanceId)
 {
 	srcDBInstanceId_ = srcDBInstanceId;
-	setCoreParameter("SrcDBInstanceId", srcDBInstanceId);
+	setParameter("SrcDBInstanceId", srcDBInstanceId);
 }
 
 std::string CreateShardingDBInstanceRequest::getOwnerAccount()const
@@ -194,7 +194,7 @@ std::string CreateShardingDBInstanceRequest::getOwnerAccount()const
 void CreateShardingDBInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 std::vector<CreateShardingDBInstanceRequest::ConfigServer> CreateShardingDBInstanceRequest::getConfigServer()const
@@ -207,9 +207,9 @@ void CreateShardingDBInstanceRequest::setConfigServer(const std::vector<ConfigSe
 	configServer_ = configServer;
 	for(int dep1 = 0; dep1!= configServer.size(); dep1++) {
 		auto configServerObj = configServer.at(dep1);
-		std::string configServerObjStr = "ConfigServer." + std::to_string(dep1);
-		setCoreParameter(configServerObjStr + ".Storage", std::to_string(configServerObj.storage));
-		setCoreParameter(configServerObjStr + "._Class", configServerObj._class);
+		std::string configServerObjStr = "ConfigServer." + std::to_string(dep1 + 1);
+		setParameter(configServerObjStr + ".Storage", std::to_string(configServerObj.storage));
+		setParameter(configServerObjStr + "._Class", configServerObj._class);
 	}
 }
 
@@ -221,7 +221,7 @@ long CreateShardingDBInstanceRequest::getOwnerId()const
 void CreateShardingDBInstanceRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::vector<CreateShardingDBInstanceRequest::Mongos> CreateShardingDBInstanceRequest::getMongos()const
@@ -234,8 +234,8 @@ void CreateShardingDBInstanceRequest::setMongos(const std::vector<Mongos>& mongo
 	mongos_ = mongos;
 	for(int dep1 = 0; dep1!= mongos.size(); dep1++) {
 		auto mongosObj = mongos.at(dep1);
-		std::string mongosObjStr = "Mongos." + std::to_string(dep1);
-		setCoreParameter(mongosObjStr + "._Class", mongosObj._class);
+		std::string mongosObjStr = "Mongos." + std::to_string(dep1 + 1);
+		setParameter(mongosObjStr + "._Class", mongosObj._class);
 	}
 }
 
@@ -247,7 +247,7 @@ std::string CreateShardingDBInstanceRequest::getSecurityIPList()const
 void CreateShardingDBInstanceRequest::setSecurityIPList(const std::string& securityIPList)
 {
 	securityIPList_ = securityIPList;
-	setCoreParameter("SecurityIPList", securityIPList);
+	setParameter("SecurityIPList", securityIPList);
 }
 
 std::string CreateShardingDBInstanceRequest::getVSwitchId()const
@@ -258,7 +258,7 @@ std::string CreateShardingDBInstanceRequest::getVSwitchId()const
 void CreateShardingDBInstanceRequest::setVSwitchId(const std::string& vSwitchId)
 {
 	vSwitchId_ = vSwitchId;
-	setCoreParameter("VSwitchId", vSwitchId);
+	setParameter("VSwitchId", vSwitchId);
 }
 
 std::string CreateShardingDBInstanceRequest::getAccountPassword()const
@@ -269,7 +269,7 @@ std::string CreateShardingDBInstanceRequest::getAccountPassword()const
 void CreateShardingDBInstanceRequest::setAccountPassword(const std::string& accountPassword)
 {
 	accountPassword_ = accountPassword;
-	setCoreParameter("AccountPassword", accountPassword);
+	setParameter("AccountPassword", accountPassword);
 }
 
 std::string CreateShardingDBInstanceRequest::getAutoRenew()const
@@ -280,7 +280,7 @@ std::string CreateShardingDBInstanceRequest::getAutoRenew()const
 void CreateShardingDBInstanceRequest::setAutoRenew(const std::string& autoRenew)
 {
 	autoRenew_ = autoRenew;
-	setCoreParameter("AutoRenew", autoRenew);
+	setParameter("AutoRenew", autoRenew);
 }
 
 std::string CreateShardingDBInstanceRequest::getVpcId()const
@@ -291,7 +291,7 @@ std::string CreateShardingDBInstanceRequest::getVpcId()const
 void CreateShardingDBInstanceRequest::setVpcId(const std::string& vpcId)
 {
 	vpcId_ = vpcId;
-	setCoreParameter("VpcId", vpcId);
+	setParameter("VpcId", vpcId);
 }
 
 std::string CreateShardingDBInstanceRequest::getZoneId()const
@@ -302,7 +302,7 @@ std::string CreateShardingDBInstanceRequest::getZoneId()const
 void CreateShardingDBInstanceRequest::setZoneId(const std::string& zoneId)
 {
 	zoneId_ = zoneId;
-	setCoreParameter("ZoneId", zoneId);
+	setParameter("ZoneId", zoneId);
 }
 
 std::string CreateShardingDBInstanceRequest::getChargeType()const
@@ -313,6 +313,6 @@ std::string CreateShardingDBInstanceRequest::getChargeType()const
 void CreateShardingDBInstanceRequest::setChargeType(const std::string& chargeType)
 {
 	chargeType_ = chargeType;
-	setCoreParameter("ChargeType", chargeType);
+	setParameter("ChargeType", chargeType);
 }
 

dds/src/model/DeleteDBInstanceRequest.cc

@@ -35,7 +35,7 @@ long DeleteDBInstanceRequest::getResourceOwnerId()const
 void DeleteDBInstanceRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DeleteDBInstanceRequest::getClientToken()const
@@ -46,7 +46,7 @@ std::string DeleteDBInstanceRequest::getClientToken()const
 void DeleteDBInstanceRequest::setClientToken(const std::string& clientToken)
 {
 	clientToken_ = clientToken;
-	setCoreParameter("ClientToken", clientToken);
+	setParameter("ClientToken", clientToken);
 }
 
 std::string DeleteDBInstanceRequest::getAccessKeyId()const
@@ -57,7 +57,7 @@ std::string DeleteDBInstanceRequest::getAccessKeyId()const
 void DeleteDBInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DeleteDBInstanceRequest::getSecurityToken()const
@@ -68,7 +68,7 @@ std::string DeleteDBInstanceRequest::getSecurityToken()const
 void DeleteDBInstanceRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string DeleteDBInstanceRequest::getDBInstanceId()const
@@ -79,7 +79,7 @@ std::string DeleteDBInstanceRequest::getDBInstanceId()const
 void DeleteDBInstanceRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string DeleteDBInstanceRequest::getResourceOwnerAccount()const
@@ -90,7 +90,7 @@ std::string DeleteDBInstanceRequest::getResourceOwnerAccount()const
 void DeleteDBInstanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DeleteDBInstanceRequest::getOwnerAccount()const
@@ -101,7 +101,7 @@ std::string DeleteDBInstanceRequest::getOwnerAccount()const
 void DeleteDBInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long DeleteDBInstanceRequest::getOwnerId()const
@@ -112,6 +112,6 @@ long DeleteDBInstanceRequest::getOwnerId()const
 void DeleteDBInstanceRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

dds/src/model/DeleteNodeRequest.cc

@@ -35,7 +35,7 @@ long DeleteNodeRequest::getResourceOwnerId()const
 void DeleteNodeRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DeleteNodeRequest::getClientToken()const
@@ -46,7 +46,7 @@ std::string DeleteNodeRequest::getClientToken()const
 void DeleteNodeRequest::setClientToken(const std::string& clientToken)
 {
 	clientToken_ = clientToken;
-	setCoreParameter("ClientToken", clientToken);
+	setParameter("ClientToken", clientToken);
 }
 
 std::string DeleteNodeRequest::getAccessKeyId()const
@@ -57,7 +57,7 @@ std::string DeleteNodeRequest::getAccessKeyId()const
 void DeleteNodeRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DeleteNodeRequest::getSecurityToken()const
@@ -68,7 +68,7 @@ std::string DeleteNodeRequest::getSecurityToken()const
 void DeleteNodeRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string DeleteNodeRequest::getDBInstanceId()const
@@ -79,7 +79,7 @@ std::string DeleteNodeRequest::getDBInstanceId()const
 void DeleteNodeRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string DeleteNodeRequest::getNodeId()const
@@ -90,7 +90,7 @@ std::string DeleteNodeRequest::getNodeId()const
 void DeleteNodeRequest::setNodeId(const std::string& nodeId)
 {
 	nodeId_ = nodeId;
-	setCoreParameter("NodeId", nodeId);
+	setParameter("NodeId", nodeId);
 }
 
 std::string DeleteNodeRequest::getResourceOwnerAccount()const
@@ -101,7 +101,7 @@ std::string DeleteNodeRequest::getResourceOwnerAccount()const
 void DeleteNodeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DeleteNodeRequest::getOwnerAccount()const
@@ -112,7 +112,7 @@ std::string DeleteNodeRequest::getOwnerAccount()const
 void DeleteNodeRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long DeleteNodeRequest::getOwnerId()const
@@ -123,6 +123,6 @@ long DeleteNodeRequest::getOwnerId()const
 void DeleteNodeRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

dds/src/model/DescribeAccountsRequest.cc

@@ -35,7 +35,7 @@ long DescribeAccountsRequest::getResourceOwnerId()const
 void DescribeAccountsRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeAccountsRequest::getAccessKeyId()const
@@ -46,7 +46,7 @@ std::string DescribeAccountsRequest::getAccessKeyId()const
 void DescribeAccountsRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeAccountsRequest::getAccountName()const
@@ -57,7 +57,7 @@ std::string DescribeAccountsRequest::getAccountName()const
 void DescribeAccountsRequest::setAccountName(const std::string& accountName)
 {
 	accountName_ = accountName;
-	setCoreParameter("AccountName", accountName);
+	setParameter("AccountName", accountName);
 }
 
 std::string DescribeAccountsRequest::getSecurityToken()const
@@ -68,7 +68,7 @@ std::string DescribeAccountsRequest::getSecurityToken()const
 void DescribeAccountsRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string DescribeAccountsRequest::getDBInstanceId()const
@@ -79,7 +79,7 @@ std::string DescribeAccountsRequest::getDBInstanceId()const
 void DescribeAccountsRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string DescribeAccountsRequest::getResourceOwnerAccount()const
@@ -90,7 +90,7 @@ std::string DescribeAccountsRequest::getResourceOwnerAccount()const
 void DescribeAccountsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeAccountsRequest::getOwnerAccount()const
@@ -101,7 +101,7 @@ std::string DescribeAccountsRequest::getOwnerAccount()const
 void DescribeAccountsRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long DescribeAccountsRequest::getOwnerId()const
@@ -112,6 +112,6 @@ long DescribeAccountsRequest::getOwnerId()const
 void DescribeAccountsRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

dds/src/model/DescribeAuditFilesRequest.cc

@@ -35,7 +35,7 @@ long DescribeAuditFilesRequest::getResourceOwnerId()const
 void DescribeAuditFilesRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 int DescribeAuditFilesRequest::getPageNumber()const
@@ -46,7 +46,7 @@ int DescribeAuditFilesRequest::getPageNumber()const
 void DescribeAuditFilesRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setCoreParameter("PageNumber", std::to_string(pageNumber));
+	setParameter("PageNumber", std::to_string(pageNumber));
 }
 
 std::string DescribeAuditFilesRequest::getAccessKeyId()const
@@ -57,7 +57,7 @@ std::string DescribeAuditFilesRequest::getAccessKeyId()const
 void DescribeAuditFilesRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeAuditFilesRequest::getSecurityToken()const
@@ -68,7 +68,7 @@ std::string DescribeAuditFilesRequest::getSecurityToken()const
 void DescribeAuditFilesRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 int DescribeAuditFilesRequest::getPageSize()const
@@ -79,7 +79,7 @@ int DescribeAuditFilesRequest::getPageSize()const
 void DescribeAuditFilesRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setCoreParameter("PageSize", std::to_string(pageSize));
+	setParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string DescribeAuditFilesRequest::getDBInstanceId()const
@@ -90,7 +90,7 @@ std::string DescribeAuditFilesRequest::getDBInstanceId()const
 void DescribeAuditFilesRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string DescribeAuditFilesRequest::getNodeId()const
@@ -101,7 +101,7 @@ std::string DescribeAuditFilesRequest::getNodeId()const
 void DescribeAuditFilesRequest::setNodeId(const std::string& nodeId)
 {
 	nodeId_ = nodeId;
-	setCoreParameter("NodeId", nodeId);
+	setParameter("NodeId", nodeId);
 }
 
 std::string DescribeAuditFilesRequest::getResourceOwnerAccount()const
@@ -112,7 +112,7 @@ std::string DescribeAuditFilesRequest::getResourceOwnerAccount()const
 void DescribeAuditFilesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeAuditFilesRequest::getOwnerAccount()const
@@ -123,7 +123,7 @@ std::string DescribeAuditFilesRequest::getOwnerAccount()const
 void DescribeAuditFilesRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long DescribeAuditFilesRequest::getOwnerId()const
@@ -134,6 +134,6 @@ long DescribeAuditFilesRequest::getOwnerId()const
 void DescribeAuditFilesRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

dds/src/model/DescribeAuditLogFilterRequest.cc

@@ -35,7 +35,7 @@ long DescribeAuditLogFilterRequest::getResourceOwnerId()const
 void DescribeAuditLogFilterRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeAuditLogFilterRequest::getAccessKeyId()const
@@ -46,7 +46,7 @@ std::string DescribeAuditLogFilterRequest::getAccessKeyId()const
 void DescribeAuditLogFilterRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeAuditLogFilterRequest::getSecurityToken()const
@@ -57,7 +57,7 @@ std::string DescribeAuditLogFilterRequest::getSecurityToken()const
 void DescribeAuditLogFilterRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string DescribeAuditLogFilterRequest::getDBInstanceId()const
@@ -68,7 +68,7 @@ std::string DescribeAuditLogFilterRequest::getDBInstanceId()const
 void DescribeAuditLogFilterRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string DescribeAuditLogFilterRequest::getRoleType()const
@@ -79,7 +79,7 @@ std::string DescribeAuditLogFilterRequest::getRoleType()const
 void DescribeAuditLogFilterRequest::setRoleType(const std::string& roleType)
 {
 	roleType_ = roleType;
-	setCoreParameter("RoleType", roleType);
+	setParameter("RoleType", roleType);
 }
 
 std::string DescribeAuditLogFilterRequest::getResourceOwnerAccount()const
@@ -90,7 +90,7 @@ std::string DescribeAuditLogFilterRequest::getResourceOwnerAccount()const
 void DescribeAuditLogFilterRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeAuditLogFilterRequest::getOwnerAccount()const
@@ -101,7 +101,7 @@ std::string DescribeAuditLogFilterRequest::getOwnerAccount()const
 void DescribeAuditLogFilterRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long DescribeAuditLogFilterRequest::getOwnerId()const
@@ -112,6 +112,6 @@ long DescribeAuditLogFilterRequest::getOwnerId()const
 void DescribeAuditLogFilterRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

dds/src/model/DescribeAuditPolicyRequest.cc

@@ -35,7 +35,7 @@ long DescribeAuditPolicyRequest::getResourceOwnerId()const
 void DescribeAuditPolicyRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeAuditPolicyRequest::getAccessKeyId()const
@@ -46,7 +46,7 @@ std::string DescribeAuditPolicyRequest::getAccessKeyId()const
 void DescribeAuditPolicyRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeAuditPolicyRequest::getSecurityToken()const
@@ -57,7 +57,7 @@ std::string DescribeAuditPolicyRequest::getSecurityToken()const
 void DescribeAuditPolicyRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string DescribeAuditPolicyRequest::getDBInstanceId()const
@@ -68,7 +68,7 @@ std::string DescribeAuditPolicyRequest::getDBInstanceId()const
 void DescribeAuditPolicyRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string DescribeAuditPolicyRequest::getResourceOwnerAccount()const
@@ -79,7 +79,7 @@ std::string DescribeAuditPolicyRequest::getResourceOwnerAccount()const
 void DescribeAuditPolicyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeAuditPolicyRequest::getOwnerAccount()const
@@ -90,7 +90,7 @@ std::string DescribeAuditPolicyRequest::getOwnerAccount()const
 void DescribeAuditPolicyRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long DescribeAuditPolicyRequest::getOwnerId()const
@@ -101,6 +101,6 @@ long DescribeAuditPolicyRequest::getOwnerId()const
 void DescribeAuditPolicyRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

dds/src/model/DescribeAuditRecordsRequest.cc

@@ -35,7 +35,7 @@ long DescribeAuditRecordsRequest::getResourceOwnerId()const
 void DescribeAuditRecordsRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeAuditRecordsRequest::getStartTime()const
@@ -46,7 +46,7 @@ std::string DescribeAuditRecordsRequest::getStartTime()const
 void DescribeAuditRecordsRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeAuditRecordsRequest::getQueryKeywords()const
@@ -57,7 +57,7 @@ std::string DescribeAuditRecordsRequest::getQueryKeywords()const
 void DescribeAuditRecordsRequest::setQueryKeywords(const std::string& queryKeywords)
 {
 	queryKeywords_ = queryKeywords;
-	setCoreParameter("QueryKeywords", queryKeywords);
+	setParameter("QueryKeywords", queryKeywords);
 }
 
 int DescribeAuditRecordsRequest::getPageNumber()const
@@ -68,7 +68,7 @@ int DescribeAuditRecordsRequest::getPageNumber()const
 void DescribeAuditRecordsRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setCoreParameter("PageNumber", std::to_string(pageNumber));
+	setParameter("PageNumber", std::to_string(pageNumber));
 }
 
 std::string DescribeAuditRecordsRequest::getAccessKeyId()const
@@ -79,7 +79,7 @@ std::string DescribeAuditRecordsRequest::getAccessKeyId()const
 void DescribeAuditRecordsRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeAuditRecordsRequest::getDatabase()const
@@ -90,7 +90,7 @@ std::string DescribeAuditRecordsRequest::getDatabase()const
 void DescribeAuditRecordsRequest::setDatabase(const std::string& database)
 {
 	database_ = database;
-	setCoreParameter("Database", database);
+	setParameter("Database", database);
 }
 
 std::string DescribeAuditRecordsRequest::getSecurityToken()const
@@ -101,7 +101,7 @@ std::string DescribeAuditRecordsRequest::getSecurityToken()const
 void DescribeAuditRecordsRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 int DescribeAuditRecordsRequest::getPageSize()const
@@ -112,7 +112,7 @@ int DescribeAuditRecordsRequest::getPageSize()const
 void DescribeAuditRecordsRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setCoreParameter("PageSize", std::to_string(pageSize));
+	setParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string DescribeAuditRecordsRequest::getDBInstanceId()const
@@ -123,7 +123,7 @@ std::string DescribeAuditRecordsRequest::getDBInstanceId()const
 void DescribeAuditRecordsRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string DescribeAuditRecordsRequest::getNodeId()const
@@ -134,7 +134,7 @@ std::string DescribeAuditRecordsRequest::getNodeId()const
 void DescribeAuditRecordsRequest::setNodeId(const std::string& nodeId)
 {
 	nodeId_ = nodeId;
-	setCoreParameter("NodeId", nodeId);
+	setParameter("NodeId", nodeId);
 }
 
 std::string DescribeAuditRecordsRequest::getResourceOwnerAccount()const
@@ -145,7 +145,7 @@ std::string DescribeAuditRecordsRequest::getResourceOwnerAccount()const
 void DescribeAuditRecordsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeAuditRecordsRequest::getOwnerAccount()const
@@ -156,7 +156,7 @@ std::string DescribeAuditRecordsRequest::getOwnerAccount()const
 void DescribeAuditRecordsRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 std::string DescribeAuditRecordsRequest::getEndTime()const
@@ -167,7 +167,7 @@ std::string DescribeAuditRecordsRequest::getEndTime()const
 void DescribeAuditRecordsRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeAuditRecordsRequest::getOwnerId()const
@@ -178,7 +178,7 @@ long DescribeAuditRecordsRequest::getOwnerId()const
 void DescribeAuditRecordsRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeAuditRecordsRequest::getForm()const
@@ -189,7 +189,7 @@ std::string DescribeAuditRecordsRequest::getForm()const
 void DescribeAuditRecordsRequest::setForm(const std::string& form)
 {
 	form_ = form;
-	setCoreParameter("Form", form);
+	setParameter("Form", form);
 }
 
 std::string DescribeAuditRecordsRequest::getUser()const
@@ -200,6 +200,6 @@ std::string DescribeAuditRecordsRequest::getUser()const
 void DescribeAuditRecordsRequest::setUser(const std::string& user)
 {
 	user_ = user;
-	setCoreParameter("User", user);
+	setParameter("User", user);
 }
 

dds/src/model/DescribeAvailableEngineVersionRequest.cc

@@ -35,7 +35,7 @@ long DescribeAvailableEngineVersionRequest::getResourceOwnerId()const
 void DescribeAvailableEngineVersionRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeAvailableEngineVersionRequest::getAccessKeyId()const
@@ -46,7 +46,7 @@ std::string DescribeAvailableEngineVersionRequest::getAccessKeyId()const
 void DescribeAvailableEngineVersionRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeAvailableEngineVersionRequest::getSecurityToken()const
@@ -57,7 +57,7 @@ std::string DescribeAvailableEngineVersionRequest::getSecurityToken()const
 void DescribeAvailableEngineVersionRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string DescribeAvailableEngineVersionRequest::getDBInstanceId()const
@@ -68,7 +68,7 @@ std::string DescribeAvailableEngineVersionRequest::getDBInstanceId()const
 void DescribeAvailableEngineVersionRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string DescribeAvailableEngineVersionRequest::getResourceOwnerAccount()const
@@ -79,7 +79,7 @@ std::string DescribeAvailableEngineVersionRequest::getResourceOwnerAccount()cons
 void DescribeAvailableEngineVersionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeAvailableEngineVersionRequest::getOwnerAccount()const
@@ -90,7 +90,7 @@ std::string DescribeAvailableEngineVersionRequest::getOwnerAccount()const
 void DescribeAvailableEngineVersionRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long DescribeAvailableEngineVersionRequest::getOwnerId()const
@@ -101,6 +101,6 @@ long DescribeAvailableEngineVersionRequest::getOwnerId()const
 void DescribeAvailableEngineVersionRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

dds/src/model/DescribeAvailableResourceRequest.cc

@@ -35,7 +35,7 @@ long DescribeAvailableResourceRequest::getResourceOwnerId()const
 void DescribeAvailableResourceRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeAvailableResourceRequest::getAccessKeyId()const
@@ -46,7 +46,7 @@ std::string DescribeAvailableResourceRequest::getAccessKeyId()const
 void DescribeAvailableResourceRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeAvailableResourceRequest::getSecurityToken()const
@@ -57,7 +57,7 @@ std::string DescribeAvailableResourceRequest::getSecurityToken()const
 void DescribeAvailableResourceRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string DescribeAvailableResourceRequest::getRegionId()const
@@ -68,7 +68,7 @@ std::string DescribeAvailableResourceRequest::getRegionId()const
 void DescribeAvailableResourceRequest::setRegionId(const std::string& regionId)
 {
 	regionId_ = regionId;
-	setCoreParameter("RegionId", regionId);
+	setParameter("RegionId", regionId);
 }
 
 std::string DescribeAvailableResourceRequest::getInstanceChargeType()const
@@ -79,7 +79,7 @@ std::string DescribeAvailableResourceRequest::getInstanceChargeType()const
 void DescribeAvailableResourceRequest::setInstanceChargeType(const std::string& instanceChargeType)
 {
 	instanceChargeType_ = instanceChargeType;
-	setCoreParameter("InstanceChargeType", instanceChargeType);
+	setParameter("InstanceChargeType", instanceChargeType);
 }
 
 std::string DescribeAvailableResourceRequest::getResourceOwnerAccount()const
@@ -90,7 +90,7 @@ std::string DescribeAvailableResourceRequest::getResourceOwnerAccount()const
 void DescribeAvailableResourceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeAvailableResourceRequest::getOwnerAccount()const
@@ -101,7 +101,7 @@ std::string DescribeAvailableResourceRequest::getOwnerAccount()const
 void DescribeAvailableResourceRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long DescribeAvailableResourceRequest::getOwnerId()const
@@ -112,7 +112,7 @@ long DescribeAvailableResourceRequest::getOwnerId()const
 void DescribeAvailableResourceRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeAvailableResourceRequest::getZoneId()const
@@ -123,6 +123,6 @@ std::string DescribeAvailableResourceRequest::getZoneId()const
 void DescribeAvailableResourceRequest::setZoneId(const std::string& zoneId)
 {
 	zoneId_ = zoneId;
-	setCoreParameter("ZoneId", zoneId);
+	setParameter("ZoneId", zoneId);
 }
 

dds/src/model/DescribeAvailableResourceResult.cc

@@ -39,55 +39,65 @@ void DescribeAvailableResourceResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	auto allAvailableZonesNode = value["AvailableZones"]["AvailableZone"];
-	for (auto valueAvailableZonesAvailableZone : allAvailableZonesNode)
+	auto allSupportedDBTypesNode = value["SupportedDBTypes"]["SupportedDBType"];
+	for (auto valueSupportedDBTypesSupportedDBType : allSupportedDBTypesNode)
 	{
-		AvailableZone availableZonesObject;
-		if(!valueAvailableZonesAvailableZone["RegionId"].isNull())
-			availableZonesObject.regionId = valueAvailableZonesAvailableZone["RegionId"].asString();
-		if(!valueAvailableZonesAvailableZone["ZoneId"].isNull())
-			availableZonesObject.zoneId = valueAvailableZonesAvailableZone["ZoneId"].asString();
-		auto allSupportedEngineVersionsNode = allAvailableZonesNode["SupportedEngineVersions"]["SupportedEngineVersion"];
-		for (auto allAvailableZonesNodeSupportedEngineVersionsSupportedEngineVersion : allSupportedEngineVersionsNode)
+		SupportedDBType supportedDBTypesObject;
+		if(!valueSupportedDBTypesSupportedDBType["DbType"].isNull())
+			supportedDBTypesObject.dbType = valueSupportedDBTypesSupportedDBType["DbType"].asString();
+		auto allAvailableZonesNode = allSupportedDBTypesNode["AvailableZones"]["AvailableZone"];
+		for (auto allSupportedDBTypesNodeAvailableZonesAvailableZone : allAvailableZonesNode)
 		{
-			AvailableZone::SupportedEngineVersion supportedEngineVersionsObject;
-			if(!allAvailableZonesNodeSupportedEngineVersionsSupportedEngineVersion["Version"].isNull())
-				supportedEngineVersionsObject.version = allAvailableZonesNodeSupportedEngineVersionsSupportedEngineVersion["Version"].asString();
-			auto allSupportedEnginesNode = allSupportedEngineVersionsNode["SupportedEngines"]["SupportedEngine"];
-			for (auto allSupportedEngineVersionsNodeSupportedEnginesSupportedEngine : allSupportedEnginesNode)
+			SupportedDBType::AvailableZone availableZonesObject;
+			if(!allSupportedDBTypesNodeAvailableZonesAvailableZone["RegionId"].isNull())
+				availableZonesObject.regionId = allSupportedDBTypesNodeAvailableZonesAvailableZone["RegionId"].asString();
+			if(!allSupportedDBTypesNodeAvailableZonesAvailableZone["ZoneId"].isNull())
+				availableZonesObject.zoneId = allSupportedDBTypesNodeAvailableZonesAvailableZone["ZoneId"].asString();
+			auto allSupportedEngineVersionsNode = allAvailableZonesNode["SupportedEngineVersions"]["SupportedEngineVersion"];
+			for (auto allAvailableZonesNodeSupportedEngineVersionsSupportedEngineVersion : allSupportedEngineVersionsNode)
 			{
-				AvailableZone::SupportedEngineVersion::SupportedEngine supportedEnginesObject;
-				if(!allSupportedEngineVersionsNodeSupportedEnginesSupportedEngine["Engine"].isNull())
-					supportedEnginesObject.engine = allSupportedEngineVersionsNodeSupportedEnginesSupportedEngine["Engine"].asString();
-				auto allSupportedNodeTypesNode = allSupportedEnginesNode["SupportedNodeTypes"]["SupportedNodeType"];
-				for (auto allSupportedEnginesNodeSupportedNodeTypesSupportedNodeType : allSupportedNodeTypesNode)
+				SupportedDBType::AvailableZone::SupportedEngineVersion supportedEngineVersionsObject;
+				if(!allAvailableZonesNodeSupportedEngineVersionsSupportedEngineVersion["Version"].isNull())
+					supportedEngineVersionsObject.version = allAvailableZonesNodeSupportedEngineVersionsSupportedEngineVersion["Version"].asString();
+				auto allSupportedEnginesNode = allSupportedEngineVersionsNode["SupportedEngines"]["SupportedEngine"];
+				for (auto allSupportedEngineVersionsNodeSupportedEnginesSupportedEngine : allSupportedEnginesNode)
 				{
-					AvailableZone::SupportedEngineVersion::SupportedEngine::SupportedNodeType supportedNodeTypesObject;
-					if(!allSupportedEnginesNodeSupportedNodeTypesSupportedNodeType["NodeType"].isNull())
-						supportedNodeTypesObject.nodeType = allSupportedEnginesNodeSupportedNodeTypesSupportedNodeType["NodeType"].asString();
-					if(!allSupportedEnginesNodeSupportedNodeTypesSupportedNodeType["NetworkTypes"].isNull())
-						supportedNodeTypesObject.networkTypes = allSupportedEnginesNodeSupportedNodeTypesSupportedNodeType["NetworkTypes"].asString();
-					auto allAvailableResourcesNode = allSupportedNodeTypesNode["AvailableResources"]["AvailableResource"];
-					for (auto allSupportedNodeTypesNodeAvailableResourcesAvailableResource : allAvailableResourcesNode)
+					SupportedDBType::AvailableZone::SupportedEngineVersion::SupportedEngine supportedEnginesObject;
+					if(!allSupportedEngineVersionsNodeSupportedEnginesSupportedEngine["Engine"].isNull())
+						supportedEnginesObject.engine = allSupportedEngineVersionsNodeSupportedEnginesSupportedEngine["Engine"].asString();
+					auto allSupportedNodeTypesNode = allSupportedEnginesNode["SupportedNodeTypes"]["SupportedNodeType"];
+					for (auto allSupportedEnginesNodeSupportedNodeTypesSupportedNodeType : allSupportedNodeTypesNode)
 					{
-						AvailableZone::SupportedEngineVersion::SupportedEngine::SupportedNodeType::AvailableResource availableResourcesObject;
-						if(!allSupportedNodeTypesNodeAvailableResourcesAvailableResource["InstanceClass"].isNull())
-							availableResourcesObject.instanceClass = allSupportedNodeTypesNodeAvailableResourcesAvailableResource["InstanceClass"].asString();
-						supportedNodeTypesObject.availableResources.push_back(availableResourcesObject);
+						SupportedDBType::AvailableZone::SupportedEngineVersion::SupportedEngine::SupportedNodeType supportedNodeTypesObject;
+						if(!allSupportedEnginesNodeSupportedNodeTypesSupportedNodeType["NodeType"].isNull())
+							supportedNodeTypesObject.nodeType = allSupportedEnginesNodeSupportedNodeTypesSupportedNodeType["NodeType"].asString();
+						if(!allSupportedEnginesNodeSupportedNodeTypesSupportedNodeType["NetworkTypes"].isNull())
+							supportedNodeTypesObject.networkTypes = allSupportedEnginesNodeSupportedNodeTypesSupportedNodeType["NetworkTypes"].asString();
+						auto allAvailableResourcesNode = allSupportedNodeTypesNode["AvailableResources"]["AvailableResource"];
+						for (auto allSupportedNodeTypesNodeAvailableResourcesAvailableResource : allAvailableResourcesNode)
+						{
+							SupportedDBType::AvailableZone::SupportedEngineVersion::SupportedEngine::SupportedNodeType::AvailableResource availableResourcesObject;
+							if(!allSupportedNodeTypesNodeAvailableResourcesAvailableResource["InstanceClass"].isNull())
+								availableResourcesObject.instanceClass = allSupportedNodeTypesNodeAvailableResourcesAvailableResource["InstanceClass"].asString();
+							if(!allSupportedNodeTypesNodeAvailableResourcesAvailableResource["InstanceClassRemark"].isNull())
+								availableResourcesObject.instanceClassRemark = allSupportedNodeTypesNodeAvailableResourcesAvailableResource["InstanceClassRemark"].asString();
+							supportedNodeTypesObject.availableResources.push_back(availableResourcesObject);
+						}
+						supportedEnginesObject.supportedNodeTypes.push_back(supportedNodeTypesObject);
 					}
-					supportedEnginesObject.supportedNodeTypes.push_back(supportedNodeTypesObject);
+					supportedEngineVersionsObject.supportedEngines.push_back(supportedEnginesObject);
 				}
-				supportedEngineVersionsObject.supportedEngines.push_back(supportedEnginesObject);
+				availableZonesObject.supportedEngineVersions.push_back(supportedEngineVersionsObject);
 			}
-			availableZonesObject.supportedEngineVersions.push_back(supportedEngineVersionsObject);
+			supportedDBTypesObject.availableZones.push_back(availableZonesObject);
 		}
-		availableZones_.push_back(availableZonesObject);
+		supportedDBTypes_.push_back(supportedDBTypesObject);
 	}
 
 }
 
-std::vector<DescribeAvailableResourceResult::AvailableZone> DescribeAvailableResourceResult::getAvailableZones()const
+std::vector<DescribeAvailableResourceResult::SupportedDBType> DescribeAvailableResourceResult::getSupportedDBTypes()const
 {
-	return availableZones_;
+	return supportedDBTypes_;
 }
 

dds/src/model/DescribeAvailableTimeRangeRequest.cc

@@ -35,7 +35,7 @@ long DescribeAvailableTimeRangeRequest::getResourceOwnerId()const
 void DescribeAvailableTimeRangeRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeAvailableTimeRangeRequest::getAccessKeyId()const
@@ -46,7 +46,7 @@ std::string DescribeAvailableTimeRangeRequest::getAccessKeyId()const
 void DescribeAvailableTimeRangeRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeAvailableTimeRangeRequest::getSecurityToken()const
@@ -57,7 +57,7 @@ std::string DescribeAvailableTimeRangeRequest::getSecurityToken()const
 void DescribeAvailableTimeRangeRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string DescribeAvailableTimeRangeRequest::getNodeId()const
@@ -68,7 +68,7 @@ std::string DescribeAvailableTimeRangeRequest::getNodeId()const
 void DescribeAvailableTimeRangeRequest::setNodeId(const std::string& nodeId)
 {
 	nodeId_ = nodeId;
-	setCoreParameter("NodeId", nodeId);
+	setParameter("NodeId", nodeId);
 }
 
 std::string DescribeAvailableTimeRangeRequest::getResourceOwnerAccount()const
@@ -79,7 +79,7 @@ std::string DescribeAvailableTimeRangeRequest::getResourceOwnerAccount()const
 void DescribeAvailableTimeRangeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeAvailableTimeRangeRequest::getOwnerAccount()const
@@ -90,7 +90,7 @@ std::string DescribeAvailableTimeRangeRequest::getOwnerAccount()const
 void DescribeAvailableTimeRangeRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long DescribeAvailableTimeRangeRequest::getOwnerId()const
@@ -101,7 +101,7 @@ long DescribeAvailableTimeRangeRequest::getOwnerId()const
 void DescribeAvailableTimeRangeRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeAvailableTimeRangeRequest::getInstanceId()const
@@ -112,6 +112,6 @@ std::string DescribeAvailableTimeRangeRequest::getInstanceId()const
 void DescribeAvailableTimeRangeRequest::setInstanceId(const std::string& instanceId)
 {
 	instanceId_ = instanceId;
-	setCoreParameter("InstanceId", instanceId);
+	setParameter("InstanceId", instanceId);
 }
 

dds/src/model/DescribeBackupDBsRequest.cc

@@ -35,7 +35,7 @@ long DescribeBackupDBsRequest::getResourceOwnerId()const
 void DescribeBackupDBsRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 int DescribeBackupDBsRequest::getPageNumber()const
@@ -46,7 +46,7 @@ int DescribeBackupDBsRequest::getPageNumber()const
 void DescribeBackupDBsRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setCoreParameter("PageNumber", std::to_string(pageNumber));
+	setParameter("PageNumber", std::to_string(pageNumber));
 }
 
 std::string DescribeBackupDBsRequest::getAccessKeyId()const
@@ -57,7 +57,7 @@ std::string DescribeBackupDBsRequest::getAccessKeyId()const
 void DescribeBackupDBsRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeBackupDBsRequest::getSecurityToken()const
@@ -68,7 +68,7 @@ std::string DescribeBackupDBsRequest::getSecurityToken()const
 void DescribeBackupDBsRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 int DescribeBackupDBsRequest::getPageSize()const
@@ -79,7 +79,7 @@ int DescribeBackupDBsRequest::getPageSize()const
 void DescribeBackupDBsRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setCoreParameter("PageSize", std::to_string(pageSize));
+	setParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string DescribeBackupDBsRequest::getRestoreTime()const
@@ -90,7 +90,7 @@ std::string DescribeBackupDBsRequest::getRestoreTime()const
 void DescribeBackupDBsRequest::setRestoreTime(const std::string& restoreTime)
 {
 	restoreTime_ = restoreTime;
-	setCoreParameter("RestoreTime", restoreTime);
+	setParameter("RestoreTime", restoreTime);
 }
 
 std::string DescribeBackupDBsRequest::getResourceOwnerAccount()const
@@ -101,7 +101,7 @@ std::string DescribeBackupDBsRequest::getResourceOwnerAccount()const
 void DescribeBackupDBsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeBackupDBsRequest::getOwnerAccount()const
@@ -112,7 +112,7 @@ std::string DescribeBackupDBsRequest::getOwnerAccount()const
 void DescribeBackupDBsRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 std::string DescribeBackupDBsRequest::getBackupId()const
@@ -123,7 +123,7 @@ std::string DescribeBackupDBsRequest::getBackupId()const
 void DescribeBackupDBsRequest::setBackupId(const std::string& backupId)
 {
 	backupId_ = backupId;
-	setCoreParameter("BackupId", backupId);
+	setParameter("BackupId", backupId);
 }
 
 std::string DescribeBackupDBsRequest::getSourceDBInstance()const
@@ -134,7 +134,7 @@ std::string DescribeBackupDBsRequest::getSourceDBInstance()const
 void DescribeBackupDBsRequest::setSourceDBInstance(const std::string& sourceDBInstance)
 {
 	sourceDBInstance_ = sourceDBInstance;
-	setCoreParameter("SourceDBInstance", sourceDBInstance);
+	setParameter("SourceDBInstance", sourceDBInstance);
 }
 
 long DescribeBackupDBsRequest::getOwnerId()const
@@ -145,6 +145,6 @@ long DescribeBackupDBsRequest::getOwnerId()const
 void DescribeBackupDBsRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

dds/src/model/DescribeBackupPolicyRequest.cc

@@ -35,7 +35,7 @@ long DescribeBackupPolicyRequest::getResourceOwnerId()const
 void DescribeBackupPolicyRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeBackupPolicyRequest::getAccessKeyId()const
@@ -46,7 +46,7 @@ std::string DescribeBackupPolicyRequest::getAccessKeyId()const
 void DescribeBackupPolicyRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeBackupPolicyRequest::getSecurityToken()const
@@ -57,7 +57,7 @@ std::string DescribeBackupPolicyRequest::getSecurityToken()const
 void DescribeBackupPolicyRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string DescribeBackupPolicyRequest::getDBInstanceId()const
@@ -68,7 +68,7 @@ std::string DescribeBackupPolicyRequest::getDBInstanceId()const
 void DescribeBackupPolicyRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string DescribeBackupPolicyRequest::getResourceOwnerAccount()const
@@ -79,7 +79,7 @@ std::string DescribeBackupPolicyRequest::getResourceOwnerAccount()const
 void DescribeBackupPolicyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeBackupPolicyRequest::getOwnerAccount()const
@@ -90,7 +90,7 @@ std::string DescribeBackupPolicyRequest::getOwnerAccount()const
 void DescribeBackupPolicyRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long DescribeBackupPolicyRequest::getOwnerId()const
@@ -101,6 +101,6 @@ long DescribeBackupPolicyRequest::getOwnerId()const
 void DescribeBackupPolicyRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

dds/src/model/DescribeBackupsRequest.cc

@@ -35,7 +35,7 @@ long DescribeBackupsRequest::getResourceOwnerId()const
 void DescribeBackupsRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeBackupsRequest::getStartTime()const
@@ -46,7 +46,7 @@ std::string DescribeBackupsRequest::getStartTime()const
 void DescribeBackupsRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 int DescribeBackupsRequest::getPageNumber()const
@@ -57,7 +57,7 @@ int DescribeBackupsRequest::getPageNumber()const
 void DescribeBackupsRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setCoreParameter("PageNumber", std::to_string(pageNumber));
+	setParameter("PageNumber", std::to_string(pageNumber));
 }
 
 std::string DescribeBackupsRequest::getAccessKeyId()const
@@ -68,7 +68,7 @@ std::string DescribeBackupsRequest::getAccessKeyId()const
 void DescribeBackupsRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeBackupsRequest::getSecurityToken()const
@@ -79,7 +79,7 @@ std::string DescribeBackupsRequest::getSecurityToken()const
 void DescribeBackupsRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 int DescribeBackupsRequest::getPageSize()const
@@ -90,7 +90,7 @@ int DescribeBackupsRequest::getPageSize()const
 void DescribeBackupsRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setCoreParameter("PageSize", std::to_string(pageSize));
+	setParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string DescribeBackupsRequest::getDBInstanceId()const
@@ -101,7 +101,7 @@ std::string DescribeBackupsRequest::getDBInstanceId()const
 void DescribeBackupsRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string DescribeBackupsRequest::getNodeId()const
@@ -112,7 +112,7 @@ std::string DescribeBackupsRequest::getNodeId()const
 void DescribeBackupsRequest::setNodeId(const std::string& nodeId)
 {
 	nodeId_ = nodeId;
-	setCoreParameter("NodeId", nodeId);
+	setParameter("NodeId", nodeId);
 }
 
 std::string DescribeBackupsRequest::getResourceOwnerAccount()const
@@ -123,7 +123,7 @@ std::string DescribeBackupsRequest::getResourceOwnerAccount()const
 void DescribeBackupsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeBackupsRequest::getOwnerAccount()const
@@ -134,7 +134,7 @@ std::string DescribeBackupsRequest::getOwnerAccount()const
 void DescribeBackupsRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 std::string DescribeBackupsRequest::getBackupId()const
@@ -145,7 +145,7 @@ std::string DescribeBackupsRequest::getBackupId()const
 void DescribeBackupsRequest::setBackupId(const std::string& backupId)
 {
 	backupId_ = backupId;
-	setCoreParameter("BackupId", backupId);
+	setParameter("BackupId", backupId);
 }
 
 std::string DescribeBackupsRequest::getEndTime()const
@@ -156,7 +156,7 @@ std::string DescribeBackupsRequest::getEndTime()const
 void DescribeBackupsRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeBackupsRequest::getOwnerId()const
@@ -167,6 +167,6 @@ long DescribeBackupsRequest::getOwnerId()const
 void DescribeBackupsRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

dds/src/model/DescribeDBInstanceAttributeRequest.cc

@@ -35,7 +35,7 @@ long DescribeDBInstanceAttributeRequest::getResourceOwnerId()const
 void DescribeDBInstanceAttributeRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeDBInstanceAttributeRequest::getAccessKeyId()const
@@ -46,7 +46,7 @@ std::string DescribeDBInstanceAttributeRequest::getAccessKeyId()const
 void DescribeDBInstanceAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeDBInstanceAttributeRequest::getSecurityToken()const
@@ -57,7 +57,7 @@ std::string DescribeDBInstanceAttributeRequest::getSecurityToken()const
 void DescribeDBInstanceAttributeRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string DescribeDBInstanceAttributeRequest::getEngine()const
@@ -68,7 +68,7 @@ std::string DescribeDBInstanceAttributeRequest::getEngine()const
 void DescribeDBInstanceAttributeRequest::setEngine(const std::string& engine)
 {
 	engine_ = engine;
-	setCoreParameter("Engine", engine);
+	setParameter("Engine", engine);
 }
 
 std::string DescribeDBInstanceAttributeRequest::getDBInstanceId()const
@@ -79,7 +79,7 @@ std::string DescribeDBInstanceAttributeRequest::getDBInstanceId()const
 void DescribeDBInstanceAttributeRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string DescribeDBInstanceAttributeRequest::getResourceOwnerAccount()const
@@ -90,7 +90,7 @@ std::string DescribeDBInstanceAttributeRequest::getResourceOwnerAccount()const
 void DescribeDBInstanceAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeDBInstanceAttributeRequest::getOwnerAccount()const
@@ -101,7 +101,7 @@ std::string DescribeDBInstanceAttributeRequest::getOwnerAccount()const
 void DescribeDBInstanceAttributeRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long DescribeDBInstanceAttributeRequest::getOwnerId()const
@@ -112,6 +112,6 @@ long DescribeDBInstanceAttributeRequest::getOwnerId()const
 void DescribeDBInstanceAttributeRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

dds/src/model/DescribeDBInstanceEncryptionKeyRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dds/model/DescribeDBInstanceEncryptionKeyRequest.h>
+
+using AlibabaCloud::Dds::Model::DescribeDBInstanceEncryptionKeyRequest;
+
+DescribeDBInstanceEncryptionKeyRequest::DescribeDBInstanceEncryptionKeyRequest() :
+	RpcServiceRequest("dds", "2015-12-01", "DescribeDBInstanceEncryptionKey")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDBInstanceEncryptionKeyRequest::~DescribeDBInstanceEncryptionKeyRequest()
+{}
+
+long DescribeDBInstanceEncryptionKeyRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeDBInstanceEncryptionKeyRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeDBInstanceEncryptionKeyRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeDBInstanceEncryptionKeyRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeDBInstanceEncryptionKeyRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeDBInstanceEncryptionKeyRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeDBInstanceEncryptionKeyRequest::getDBInstanceId()const
+{
+	return dBInstanceId_;
+}
+
+void DescribeDBInstanceEncryptionKeyRequest::setDBInstanceId(const std::string& dBInstanceId)
+{
+	dBInstanceId_ = dBInstanceId;
+	setParameter("DBInstanceId", dBInstanceId);
+}
+
+std::string DescribeDBInstanceEncryptionKeyRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeDBInstanceEncryptionKeyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeDBInstanceEncryptionKeyRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeDBInstanceEncryptionKeyRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string DescribeDBInstanceEncryptionKeyRequest::getEncryptionKey()const
+{
+	return encryptionKey_;
+}
+
+void DescribeDBInstanceEncryptionKeyRequest::setEncryptionKey(const std::string& encryptionKey)
+{
+	encryptionKey_ = encryptionKey;
+	setParameter("EncryptionKey", encryptionKey);
+}
+
+long DescribeDBInstanceEncryptionKeyRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDBInstanceEncryptionKeyRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

dds/src/model/DescribeDBInstanceEncryptionKeyResult.cc

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dds/model/DescribeDBInstanceEncryptionKeyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dds;
+using namespace AlibabaCloud::Dds::Model;
+
+DescribeDBInstanceEncryptionKeyResult::DescribeDBInstanceEncryptionKeyResult() :
+	ServiceResult()
+{}
+
+DescribeDBInstanceEncryptionKeyResult::DescribeDBInstanceEncryptionKeyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDBInstanceEncryptionKeyResult::~DescribeDBInstanceEncryptionKeyResult()
+{}
+
+void DescribeDBInstanceEncryptionKeyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["EncryptionKey"].isNull())
+		encryptionKey_ = value["EncryptionKey"].asString();
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
+	if(!value["KeyUsage"].isNull())
+		keyUsage_ = value["KeyUsage"].asString();
+	if(!value["DeleteDate"].isNull())
+		deleteDate_ = value["DeleteDate"].asString();
+	if(!value["Creator"].isNull())
+		creator_ = value["Creator"].asString();
+	if(!value["EncryptionKeyStatus"].isNull())
+		encryptionKeyStatus_ = value["EncryptionKeyStatus"].asString();
+	if(!value["Origin"].isNull())
+		origin_ = value["Origin"].asString();
+	if(!value["MaterialExpireTime"].isNull())
+		materialExpireTime_ = value["MaterialExpireTime"].asString();
+
+}
+
+std::string DescribeDBInstanceEncryptionKeyResult::getOrigin()const
+{
+	return origin_;
+}
+
+std::string DescribeDBInstanceEncryptionKeyResult::getDescription()const
+{
+	return description_;
+}
+
+std::string DescribeDBInstanceEncryptionKeyResult::getEncryptionKeyStatus()const
+{
+	return encryptionKeyStatus_;
+}
+
+std::string DescribeDBInstanceEncryptionKeyResult::getMaterialExpireTime()const
+{
+	return materialExpireTime_;
+}
+
+std::string DescribeDBInstanceEncryptionKeyResult::getKeyUsage()const
+{
+	return keyUsage_;
+}
+
+std::string DescribeDBInstanceEncryptionKeyResult::getEncryptionKey()const
+{
+	return encryptionKey_;
+}
+
+std::string DescribeDBInstanceEncryptionKeyResult::getCreator()const
+{
+	return creator_;
+}
+
+std::string DescribeDBInstanceEncryptionKeyResult::getDeleteDate()const
+{
+	return deleteDate_;
+}
+

dds/src/model/DescribeDBInstanceMonitorRequest.cc

@@ -35,7 +35,7 @@ long DescribeDBInstanceMonitorRequest::getResourceOwnerId()const
 void DescribeDBInstanceMonitorRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeDBInstanceMonitorRequest::getAccessKeyId()const
@@ -46,7 +46,7 @@ std::string DescribeDBInstanceMonitorRequest::getAccessKeyId()const
 void DescribeDBInstanceMonitorRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeDBInstanceMonitorRequest::getSecurityToken()const
@@ -57,7 +57,7 @@ std::string DescribeDBInstanceMonitorRequest::getSecurityToken()const
 void DescribeDBInstanceMonitorRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string DescribeDBInstanceMonitorRequest::getDBInstanceId()const
@@ -68,7 +68,7 @@ std::string DescribeDBInstanceMonitorRequest::getDBInstanceId()const
 void DescribeDBInstanceMonitorRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string DescribeDBInstanceMonitorRequest::getResourceOwnerAccount()const
@@ -79,7 +79,7 @@ std::string DescribeDBInstanceMonitorRequest::getResourceOwnerAccount()const
 void DescribeDBInstanceMonitorRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeDBInstanceMonitorRequest::getOwnerAccount()const
@@ -90,7 +90,7 @@ std::string DescribeDBInstanceMonitorRequest::getOwnerAccount()const
 void DescribeDBInstanceMonitorRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long DescribeDBInstanceMonitorRequest::getOwnerId()const
@@ -101,6 +101,6 @@ long DescribeDBInstanceMonitorRequest::getOwnerId()const
 void DescribeDBInstanceMonitorRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

dds/src/model/DescribeDBInstancePerformanceRequest.cc

@@ -35,7 +35,7 @@ long DescribeDBInstancePerformanceRequest::getResourceOwnerId()const
 void DescribeDBInstancePerformanceRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeDBInstancePerformanceRequest::getRoleId()const
@@ -46,7 +46,7 @@ std::string DescribeDBInstancePerformanceRequest::getRoleId()const
 void DescribeDBInstancePerformanceRequest::setRoleId(const std::string& roleId)
 {
 	roleId_ = roleId;
-	setCoreParameter("RoleId", roleId);
+	setParameter("RoleId", roleId);
 }
 
 std::string DescribeDBInstancePerformanceRequest::getStartTime()const
@@ -57,7 +57,7 @@ std::string DescribeDBInstancePerformanceRequest::getStartTime()const
 void DescribeDBInstancePerformanceRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeDBInstancePerformanceRequest::getAccessKeyId()const
@@ -68,7 +68,7 @@ std::string DescribeDBInstancePerformanceRequest::getAccessKeyId()const
 void DescribeDBInstancePerformanceRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeDBInstancePerformanceRequest::getReplicaSetRole()const
@@ -79,7 +79,7 @@ std::string DescribeDBInstancePerformanceRequest::getReplicaSetRole()const
 void DescribeDBInstancePerformanceRequest::setReplicaSetRole(const std::string& replicaSetRole)
 {
 	replicaSetRole_ = replicaSetRole;
-	setCoreParameter("ReplicaSetRole", replicaSetRole);
+	setParameter("ReplicaSetRole", replicaSetRole);
 }
 
 std::string DescribeDBInstancePerformanceRequest::getSecurityToken()const
@@ -90,7 +90,7 @@ std::string DescribeDBInstancePerformanceRequest::getSecurityToken()const
 void DescribeDBInstancePerformanceRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string DescribeDBInstancePerformanceRequest::getDBInstanceId()const
@@ -101,7 +101,7 @@ std::string DescribeDBInstancePerformanceRequest::getDBInstanceId()const
 void DescribeDBInstancePerformanceRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string DescribeDBInstancePerformanceRequest::getNodeId()const
@@ -112,7 +112,7 @@ std::string DescribeDBInstancePerformanceRequest::getNodeId()const
 void DescribeDBInstancePerformanceRequest::setNodeId(const std::string& nodeId)
 {
 	nodeId_ = nodeId;
-	setCoreParameter("NodeId", nodeId);
+	setParameter("NodeId", nodeId);
 }
 
 std::string DescribeDBInstancePerformanceRequest::getKey()const
@@ -123,7 +123,7 @@ std::string DescribeDBInstancePerformanceRequest::getKey()const
 void DescribeDBInstancePerformanceRequest::setKey(const std::string& key)
 {
 	key_ = key;
-	setCoreParameter("Key", key);
+	setParameter("Key", key);
 }
 
 std::string DescribeDBInstancePerformanceRequest::getResourceOwnerAccount()const
@@ -134,7 +134,7 @@ std::string DescribeDBInstancePerformanceRequest::getResourceOwnerAccount()const
 void DescribeDBInstancePerformanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeDBInstancePerformanceRequest::getOwnerAccount()const
@@ -145,7 +145,7 @@ std::string DescribeDBInstancePerformanceRequest::getOwnerAccount()const
 void DescribeDBInstancePerformanceRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 std::string DescribeDBInstancePerformanceRequest::getEndTime()const
@@ -156,7 +156,7 @@ std::string DescribeDBInstancePerformanceRequest::getEndTime()const
 void DescribeDBInstancePerformanceRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeDBInstancePerformanceRequest::getOwnerId()const
@@ -167,6 +167,6 @@ long DescribeDBInstancePerformanceRequest::getOwnerId()const
 void DescribeDBInstancePerformanceRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

dds/src/model/DescribeDBInstanceSSLRequest.cc

@@ -35,7 +35,7 @@ long DescribeDBInstanceSSLRequest::getResourceOwnerId()const
 void DescribeDBInstanceSSLRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeDBInstanceSSLRequest::getAccessKeyId()const
@@ -46,7 +46,7 @@ std::string DescribeDBInstanceSSLRequest::getAccessKeyId()const
 void DescribeDBInstanceSSLRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeDBInstanceSSLRequest::getSecurityToken()const
@@ -57,7 +57,7 @@ std::string DescribeDBInstanceSSLRequest::getSecurityToken()const
 void DescribeDBInstanceSSLRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string DescribeDBInstanceSSLRequest::getDBInstanceId()const
@@ -68,7 +68,7 @@ std::string DescribeDBInstanceSSLRequest::getDBInstanceId()const
 void DescribeDBInstanceSSLRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string DescribeDBInstanceSSLRequest::getResourceOwnerAccount()const
@@ -79,7 +79,7 @@ std::string DescribeDBInstanceSSLRequest::getResourceOwnerAccount()const
 void DescribeDBInstanceSSLRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeDBInstanceSSLRequest::getOwnerAccount()const
@@ -90,7 +90,7 @@ std::string DescribeDBInstanceSSLRequest::getOwnerAccount()const
 void DescribeDBInstanceSSLRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long DescribeDBInstanceSSLRequest::getOwnerId()const
@@ -101,6 +101,6 @@ long DescribeDBInstanceSSLRequest::getOwnerId()const
 void DescribeDBInstanceSSLRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

dds/src/model/DescribeDBInstanceTDEInfoRequest.cc

@@ -35,7 +35,7 @@ long DescribeDBInstanceTDEInfoRequest::getResourceOwnerId()const
 void DescribeDBInstanceTDEInfoRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeDBInstanceTDEInfoRequest::getAccessKeyId()const
@@ -46,7 +46,7 @@ std::string DescribeDBInstanceTDEInfoRequest::getAccessKeyId()const
 void DescribeDBInstanceTDEInfoRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeDBInstanceTDEInfoRequest::getSecurityToken()const
@@ -57,7 +57,7 @@ std::string DescribeDBInstanceTDEInfoRequest::getSecurityToken()const
 void DescribeDBInstanceTDEInfoRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string DescribeDBInstanceTDEInfoRequest::getDBInstanceId()const
@@ -68,7 +68,7 @@ std::string DescribeDBInstanceTDEInfoRequest::getDBInstanceId()const
 void DescribeDBInstanceTDEInfoRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string DescribeDBInstanceTDEInfoRequest::getResourceOwnerAccount()const
@@ -79,7 +79,7 @@ std::string DescribeDBInstanceTDEInfoRequest::getResourceOwnerAccount()const
 void DescribeDBInstanceTDEInfoRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeDBInstanceTDEInfoRequest::getOwnerAccount()const
@@ -90,7 +90,7 @@ std::string DescribeDBInstanceTDEInfoRequest::getOwnerAccount()const
 void DescribeDBInstanceTDEInfoRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long DescribeDBInstanceTDEInfoRequest::getOwnerId()const
@@ -101,6 +101,6 @@ long DescribeDBInstanceTDEInfoRequest::getOwnerId()const
 void DescribeDBInstanceTDEInfoRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

dds/src/model/DescribeDBInstancesRequest.cc

@@ -35,7 +35,7 @@ long DescribeDBInstancesRequest::getResourceOwnerId()const
 void DescribeDBInstancesRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeDBInstancesRequest::getEngineVersion()const
@@ -46,7 +46,7 @@ std::string DescribeDBInstancesRequest::getEngineVersion()const
 void DescribeDBInstancesRequest::setEngineVersion(const std::string& engineVersion)
 {
 	engineVersion_ = engineVersion;
-	setCoreParameter("EngineVersion", engineVersion);
+	setParameter("EngineVersion", engineVersion);
 }
 
 std::string DescribeDBInstancesRequest::getNetworkType()const
@@ -57,7 +57,7 @@ std::string DescribeDBInstancesRequest::getNetworkType()const
 void DescribeDBInstancesRequest::setNetworkType(const std::string& networkType)
 {
 	networkType_ = networkType;
-	setCoreParameter("NetworkType", networkType);
+	setParameter("NetworkType", networkType);
 }
 
 int DescribeDBInstancesRequest::getPageNumber()const
@@ -68,7 +68,7 @@ int DescribeDBInstancesRequest::getPageNumber()const
 void DescribeDBInstancesRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setCoreParameter("PageNumber", std::to_string(pageNumber));
+	setParameter("PageNumber", std::to_string(pageNumber));
 }
 
 std::string DescribeDBInstancesRequest::getReplicationFactor()const
@@ -79,7 +79,7 @@ std::string DescribeDBInstancesRequest::getReplicationFactor()const
 void DescribeDBInstancesRequest::setReplicationFactor(const std::string& replicationFactor)
 {
 	replicationFactor_ = replicationFactor;
-	setCoreParameter("ReplicationFactor", replicationFactor);
+	setParameter("ReplicationFactor", replicationFactor);
 }
 
 std::string DescribeDBInstancesRequest::getAccessKeyId()const
@@ -90,7 +90,7 @@ std::string DescribeDBInstancesRequest::getAccessKeyId()const
 void DescribeDBInstancesRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeDBInstancesRequest::getExpired()const
@@ -101,7 +101,7 @@ std::string DescribeDBInstancesRequest::getExpired()const
 void DescribeDBInstancesRequest::setExpired(const std::string& expired)
 {
 	expired_ = expired;
-	setCoreParameter("Expired", expired);
+	setParameter("Expired", expired);
 }
 
 std::string DescribeDBInstancesRequest::getSecurityToken()const
@@ -112,7 +112,7 @@ std::string DescribeDBInstancesRequest::getSecurityToken()const
 void DescribeDBInstancesRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string DescribeDBInstancesRequest::getEngine()const
@@ -123,7 +123,7 @@ std::string DescribeDBInstancesRequest::getEngine()const
 void DescribeDBInstancesRequest::setEngine(const std::string& engine)
 {
 	engine_ = engine;
-	setCoreParameter("Engine", engine);
+	setParameter("Engine", engine);
 }
 
 int DescribeDBInstancesRequest::getPageSize()const
@@ -134,7 +134,7 @@ int DescribeDBInstancesRequest::getPageSize()const
 void DescribeDBInstancesRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setCoreParameter("PageSize", std::to_string(pageSize));
+	setParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string DescribeDBInstancesRequest::getDBInstanceId()const
@@ -145,7 +145,7 @@ std::string DescribeDBInstancesRequest::getDBInstanceId()const
 void DescribeDBInstancesRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string DescribeDBInstancesRequest::getDBInstanceDescription()const
@@ -156,7 +156,7 @@ std::string DescribeDBInstancesRequest::getDBInstanceDescription()const
 void DescribeDBInstancesRequest::setDBInstanceDescription(const std::string& dBInstanceDescription)
 {
 	dBInstanceDescription_ = dBInstanceDescription;
-	setCoreParameter("DBInstanceDescription", dBInstanceDescription);
+	setParameter("DBInstanceDescription", dBInstanceDescription);
 }
 
 std::string DescribeDBInstancesRequest::getDBInstanceStatus()const
@@ -167,7 +167,7 @@ std::string DescribeDBInstancesRequest::getDBInstanceStatus()const
 void DescribeDBInstancesRequest::setDBInstanceStatus(const std::string& dBInstanceStatus)
 {
 	dBInstanceStatus_ = dBInstanceStatus;
-	setCoreParameter("DBInstanceStatus", dBInstanceStatus);
+	setParameter("DBInstanceStatus", dBInstanceStatus);
 }
 
 std::vector<DescribeDBInstancesRequest::Tag> DescribeDBInstancesRequest::getTag()const
@@ -180,9 +180,9 @@ void DescribeDBInstancesRequest::setTag(const std::vector<Tag>& tag)
 	tag_ = tag;
 	for(int dep1 = 0; dep1!= tag.size(); dep1++) {
 		auto tagObj = tag.at(dep1);
-		std::string tagObjStr = "Tag." + std::to_string(dep1);
-		setCoreParameter(tagObjStr + ".Value", tagObj.value);
-		setCoreParameter(tagObjStr + ".Key", tagObj.key);
+		std::string tagObjStr = "Tag." + std::to_string(dep1 + 1);
+		setParameter(tagObjStr + ".Value", tagObj.value);
+		setParameter(tagObjStr + ".Key", tagObj.key);
 	}
 }
 
@@ -194,7 +194,7 @@ std::string DescribeDBInstancesRequest::getExpireTime()const
 void DescribeDBInstancesRequest::setExpireTime(const std::string& expireTime)
 {
 	expireTime_ = expireTime;
-	setCoreParameter("ExpireTime", expireTime);
+	setParameter("ExpireTime", expireTime);
 }
 
 std::string DescribeDBInstancesRequest::getResourceOwnerAccount()const
@@ -205,7 +205,7 @@ std::string DescribeDBInstancesRequest::getResourceOwnerAccount()const
 void DescribeDBInstancesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeDBInstancesRequest::getOwnerAccount()const
@@ -216,7 +216,7 @@ std::string DescribeDBInstancesRequest::getOwnerAccount()const
 void DescribeDBInstancesRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long DescribeDBInstancesRequest::getOwnerId()const
@@ -227,7 +227,7 @@ long DescribeDBInstancesRequest::getOwnerId()const
 void DescribeDBInstancesRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeDBInstancesRequest::getDBInstanceType()const
@@ -238,7 +238,7 @@ std::string DescribeDBInstancesRequest::getDBInstanceType()const
 void DescribeDBInstancesRequest::setDBInstanceType(const std::string& dBInstanceType)
 {
 	dBInstanceType_ = dBInstanceType;
-	setCoreParameter("DBInstanceType", dBInstanceType);
+	setParameter("DBInstanceType", dBInstanceType);
 }
 
 std::string DescribeDBInstancesRequest::getDBInstanceClass()const
@@ -249,7 +249,7 @@ std::string DescribeDBInstancesRequest::getDBInstanceClass()const
 void DescribeDBInstancesRequest::setDBInstanceClass(const std::string& dBInstanceClass)
 {
 	dBInstanceClass_ = dBInstanceClass;
-	setCoreParameter("DBInstanceClass", dBInstanceClass);
+	setParameter("DBInstanceClass", dBInstanceClass);
 }
 
 std::string DescribeDBInstancesRequest::getVSwitchId()const
@@ -260,7 +260,7 @@ std::string DescribeDBInstancesRequest::getVSwitchId()const
 void DescribeDBInstancesRequest::setVSwitchId(const std::string& vSwitchId)
 {
 	vSwitchId_ = vSwitchId;
-	setCoreParameter("VSwitchId", vSwitchId);
+	setParameter("VSwitchId", vSwitchId);
 }
 
 std::string DescribeDBInstancesRequest::getVpcId()const
@@ -271,7 +271,7 @@ std::string DescribeDBInstancesRequest::getVpcId()const
 void DescribeDBInstancesRequest::setVpcId(const std::string& vpcId)
 {
 	vpcId_ = vpcId;
-	setCoreParameter("VpcId", vpcId);
+	setParameter("VpcId", vpcId);
 }
 
 std::string DescribeDBInstancesRequest::getZoneId()const
@@ -282,7 +282,7 @@ std::string DescribeDBInstancesRequest::getZoneId()const
 void DescribeDBInstancesRequest::setZoneId(const std::string& zoneId)
 {
 	zoneId_ = zoneId;
-	setCoreParameter("ZoneId", zoneId);
+	setParameter("ZoneId", zoneId);
 }
 
 std::string DescribeDBInstancesRequest::getChargeType()const
@@ -293,6 +293,6 @@ std::string DescribeDBInstancesRequest::getChargeType()const
 void DescribeDBInstancesRequest::setChargeType(const std::string& chargeType)
 {
 	chargeType_ = chargeType;
-	setCoreParameter("ChargeType", chargeType);
+	setParameter("ChargeType", chargeType);
 }
 

dds/src/model/DescribeErrorLogRecordsRequest.cc

@@ -35,7 +35,7 @@ long DescribeErrorLogRecordsRequest::getResourceOwnerId()const
 void DescribeErrorLogRecordsRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeErrorLogRecordsRequest::getStartTime()const
@@ -46,7 +46,7 @@ std::string DescribeErrorLogRecordsRequest::getStartTime()const
 void DescribeErrorLogRecordsRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 int DescribeErrorLogRecordsRequest::getPageNumber()const
@@ -57,7 +57,7 @@ int DescribeErrorLogRecordsRequest::getPageNumber()const
 void DescribeErrorLogRecordsRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setCoreParameter("PageNumber", std::to_string(pageNumber));
+	setParameter("PageNumber", std::to_string(pageNumber));
 }
 
 std::string DescribeErrorLogRecordsRequest::getAccessKeyId()const
@@ -68,7 +68,7 @@ std::string DescribeErrorLogRecordsRequest::getAccessKeyId()const
 void DescribeErrorLogRecordsRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeErrorLogRecordsRequest::getSecurityToken()const
@@ -79,7 +79,7 @@ std::string DescribeErrorLogRecordsRequest::getSecurityToken()const
 void DescribeErrorLogRecordsRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 int DescribeErrorLogRecordsRequest::getPageSize()const
@@ -90,7 +90,7 @@ int DescribeErrorLogRecordsRequest::getPageSize()const
 void DescribeErrorLogRecordsRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setCoreParameter("PageSize", std::to_string(pageSize));
+	setParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string DescribeErrorLogRecordsRequest::getDBInstanceId()const
@@ -101,7 +101,7 @@ std::string DescribeErrorLogRecordsRequest::getDBInstanceId()const
 void DescribeErrorLogRecordsRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string DescribeErrorLogRecordsRequest::getRoleType()const
@@ -112,7 +112,7 @@ std::string DescribeErrorLogRecordsRequest::getRoleType()const
 void DescribeErrorLogRecordsRequest::setRoleType(const std::string& roleType)
 {
 	roleType_ = roleType;
-	setCoreParameter("RoleType", roleType);
+	setParameter("RoleType", roleType);
 }
 
 std::string DescribeErrorLogRecordsRequest::getNodeId()const
@@ -123,7 +123,7 @@ std::string DescribeErrorLogRecordsRequest::getNodeId()const
 void DescribeErrorLogRecordsRequest::setNodeId(const std::string& nodeId)
 {
 	nodeId_ = nodeId;
-	setCoreParameter("NodeId", nodeId);
+	setParameter("NodeId", nodeId);
 }
 
 long DescribeErrorLogRecordsRequest::getSQLId()const
@@ -134,7 +134,7 @@ long DescribeErrorLogRecordsRequest::getSQLId()const
 void DescribeErrorLogRecordsRequest::setSQLId(long sQLId)
 {
 	sQLId_ = sQLId;
-	setCoreParameter("SQLId", std::to_string(sQLId));
+	setParameter("SQLId", std::to_string(sQLId));
 }
 
 std::string DescribeErrorLogRecordsRequest::getResourceOwnerAccount()const
@@ -145,7 +145,7 @@ std::string DescribeErrorLogRecordsRequest::getResourceOwnerAccount()const
 void DescribeErrorLogRecordsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeErrorLogRecordsRequest::getOwnerAccount()const
@@ -156,7 +156,7 @@ std::string DescribeErrorLogRecordsRequest::getOwnerAccount()const
 void DescribeErrorLogRecordsRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 std::string DescribeErrorLogRecordsRequest::getEndTime()const
@@ -167,7 +167,7 @@ std::string DescribeErrorLogRecordsRequest::getEndTime()const
 void DescribeErrorLogRecordsRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeErrorLogRecordsRequest::getOwnerId()const
@@ -178,7 +178,7 @@ long DescribeErrorLogRecordsRequest::getOwnerId()const
 void DescribeErrorLogRecordsRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeErrorLogRecordsRequest::getDBName()const
@@ -189,6 +189,6 @@ std::string DescribeErrorLogRecordsRequest::getDBName()const
 void DescribeErrorLogRecordsRequest::setDBName(const std::string& dBName)
 {
 	dBName_ = dBName;
-	setCoreParameter("DBName", dBName);
+	setParameter("DBName", dBName);
 }
 

dds/src/model/DescribeIndexRecommendationRequest.cc

@@ -35,7 +35,7 @@ long DescribeIndexRecommendationRequest::getResourceOwnerId()const
 void DescribeIndexRecommendationRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeIndexRecommendationRequest::getStartTime()const
@@ -46,7 +46,7 @@ std::string DescribeIndexRecommendationRequest::getStartTime()const
 void DescribeIndexRecommendationRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 int DescribeIndexRecommendationRequest::getPageNumber()const
@@ -57,7 +57,7 @@ int DescribeIndexRecommendationRequest::getPageNumber()const
 void DescribeIndexRecommendationRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setCoreParameter("PageNumber", std::to_string(pageNumber));
+	setParameter("PageNumber", std::to_string(pageNumber));
 }
 
 std::string DescribeIndexRecommendationRequest::getAccessKeyId()const
@@ -68,7 +68,7 @@ std::string DescribeIndexRecommendationRequest::getAccessKeyId()const
 void DescribeIndexRecommendationRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeIndexRecommendationRequest::getDatabase()const
@@ -79,7 +79,7 @@ std::string DescribeIndexRecommendationRequest::getDatabase()const
 void DescribeIndexRecommendationRequest::setDatabase(const std::string& database)
 {
 	database_ = database;
-	setCoreParameter("Database", database);
+	setParameter("Database", database);
 }
 
 std::string DescribeIndexRecommendationRequest::getSecurityToken()const
@@ -90,7 +90,7 @@ std::string DescribeIndexRecommendationRequest::getSecurityToken()const
 void DescribeIndexRecommendationRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 int DescribeIndexRecommendationRequest::getPageSize()const
@@ -101,7 +101,7 @@ int DescribeIndexRecommendationRequest::getPageSize()const
 void DescribeIndexRecommendationRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setCoreParameter("PageSize", std::to_string(pageSize));
+	setParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string DescribeIndexRecommendationRequest::getNodeId()const
@@ -112,7 +112,7 @@ std::string DescribeIndexRecommendationRequest::getNodeId()const
 void DescribeIndexRecommendationRequest::setNodeId(const std::string& nodeId)
 {
 	nodeId_ = nodeId;
-	setCoreParameter("NodeId", nodeId);
+	setParameter("NodeId", nodeId);
 }
 
 std::string DescribeIndexRecommendationRequest::getTaskId()const
@@ -123,7 +123,7 @@ std::string DescribeIndexRecommendationRequest::getTaskId()const
 void DescribeIndexRecommendationRequest::setTaskId(const std::string& taskId)
 {
 	taskId_ = taskId;
-	setCoreParameter("TaskId", taskId);
+	setParameter("TaskId", taskId);
 }
 
 std::string DescribeIndexRecommendationRequest::getResourceOwnerAccount()const
@@ -134,7 +134,7 @@ std::string DescribeIndexRecommendationRequest::getResourceOwnerAccount()const
 void DescribeIndexRecommendationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeIndexRecommendationRequest::getOwnerAccount()const
@@ -145,7 +145,7 @@ std::string DescribeIndexRecommendationRequest::getOwnerAccount()const
 void DescribeIndexRecommendationRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 std::string DescribeIndexRecommendationRequest::getEndTime()const
@@ -156,7 +156,7 @@ std::string DescribeIndexRecommendationRequest::getEndTime()const
 void DescribeIndexRecommendationRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 std::string DescribeIndexRecommendationRequest::getCollection()const
@@ -167,7 +167,7 @@ std::string DescribeIndexRecommendationRequest::getCollection()const
 void DescribeIndexRecommendationRequest::setCollection(const std::string& collection)
 {
 	collection_ = collection;
-	setCoreParameter("Collection", collection);
+	setParameter("Collection", collection);
 }
 
 std::string DescribeIndexRecommendationRequest::getOperationType()const
@@ -178,7 +178,7 @@ std::string DescribeIndexRecommendationRequest::getOperationType()const
 void DescribeIndexRecommendationRequest::setOperationType(const std::string& operationType)
 {
 	operationType_ = operationType;
-	setCoreParameter("OperationType", operationType);
+	setParameter("OperationType", operationType);
 }
 
 long DescribeIndexRecommendationRequest::getOwnerId()const
@@ -189,7 +189,7 @@ long DescribeIndexRecommendationRequest::getOwnerId()const
 void DescribeIndexRecommendationRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeIndexRecommendationRequest::getInstanceId()const
@@ -200,6 +200,6 @@ std::string DescribeIndexRecommendationRequest::getInstanceId()const
 void DescribeIndexRecommendationRequest::setInstanceId(const std::string& instanceId)
 {
 	instanceId_ = instanceId;
-	setCoreParameter("InstanceId", instanceId);
+	setParameter("InstanceId", instanceId);
 }
 

dds/src/model/DescribeInstanceAutoRenewalAttributeRequest.cc

@@ -35,7 +35,7 @@ long DescribeInstanceAutoRenewalAttributeRequest::getResourceOwnerId()const
 void DescribeInstanceAutoRenewalAttributeRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeInstanceAutoRenewalAttributeRequest::getPageNumber()const
@@ -46,7 +46,7 @@ std::string DescribeInstanceAutoRenewalAttributeRequest::getPageNumber()const
 void DescribeInstanceAutoRenewalAttributeRequest::setPageNumber(const std::string& pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setCoreParameter("PageNumber", pageNumber);
+	setParameter("PageNumber", pageNumber);
 }
 
 std::string DescribeInstanceAutoRenewalAttributeRequest::getAccessKeyId()const
@@ -57,7 +57,7 @@ std::string DescribeInstanceAutoRenewalAttributeRequest::getAccessKeyId()const
 void DescribeInstanceAutoRenewalAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeInstanceAutoRenewalAttributeRequest::getSecurityToken()const
@@ -68,7 +68,18 @@ std::string DescribeInstanceAutoRenewalAttributeRequest::getSecurityToken()const
 void DescribeInstanceAutoRenewalAttributeRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeInstanceAutoRenewalAttributeRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeInstanceAutoRenewalAttributeRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
 }
 
 std::string DescribeInstanceAutoRenewalAttributeRequest::getPageSize()const
@@ -79,7 +90,7 @@ std::string DescribeInstanceAutoRenewalAttributeRequest::getPageSize()const
 void DescribeInstanceAutoRenewalAttributeRequest::setPageSize(const std::string& pageSize)
 {
 	pageSize_ = pageSize;
-	setCoreParameter("PageSize", pageSize);
+	setParameter("PageSize", pageSize);
 }
 
 std::string DescribeInstanceAutoRenewalAttributeRequest::getDBInstanceId()const
@@ -90,7 +101,7 @@ std::string DescribeInstanceAutoRenewalAttributeRequest::getDBInstanceId()const
 void DescribeInstanceAutoRenewalAttributeRequest::setDBInstanceId(const std::string& dBInstanceId)
 {
 	dBInstanceId_ = dBInstanceId;
-	setCoreParameter("DBInstanceId", dBInstanceId);
+	setParameter("DBInstanceId", dBInstanceId);
 }
 
 std::string DescribeInstanceAutoRenewalAttributeRequest::getResourceOwnerAccount()const
@@ -101,7 +112,7 @@ std::string DescribeInstanceAutoRenewalAttributeRequest::getResourceOwnerAccount
 void DescribeInstanceAutoRenewalAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeInstanceAutoRenewalAttributeRequest::getOwnerAccount()const
@@ -112,7 +123,7 @@ std::string DescribeInstanceAutoRenewalAttributeRequest::getOwnerAccount()const
 void DescribeInstanceAutoRenewalAttributeRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long DescribeInstanceAutoRenewalAttributeRequest::getOwnerId()const
@@ -123,7 +134,7 @@ long DescribeInstanceAutoRenewalAttributeRequest::getOwnerId()const
 void DescribeInstanceAutoRenewalAttributeRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeInstanceAutoRenewalAttributeRequest::getDBInstanceType()const
@@ -134,6 +145,6 @@ std::string DescribeInstanceAutoRenewalAttributeRequest::getDBInstanceType()cons
 void DescribeInstanceAutoRenewalAttributeRequest::setDBInstanceType(const std::string& dBInstanceType)
 {
 	dBInstanceType_ = dBInstanceType;
-	setCoreParameter("DBInstanceType", dBInstanceType);
+	setParameter("DBInstanceType", dBInstanceType);
 }