Supported CheckCloudResourceAuthorized API.

CHANGELOG

@@ -1,3 +1,6 @@
+2020-08-14 Version: 1.36.582
+- Supported CheckCloudResourceAuthorized API.
+
 2020-08-14 Version: 1.36.581
 - Add project Api.
 

VERSION

@@ -1 +1 @@
-1.36.581
+1.36.582

rds/CMakeLists.txt

@@ -33,6 +33,8 @@ set(rds_public_header_model
 	include/alibabacloud/rds/model/CancelImportResult.h
 	include/alibabacloud/rds/model/CheckAccountNameAvailableRequest.h
 	include/alibabacloud/rds/model/CheckAccountNameAvailableResult.h
+	include/alibabacloud/rds/model/CheckCloudResourceAuthorizedRequest.h
+	include/alibabacloud/rds/model/CheckCloudResourceAuthorizedResult.h
 	include/alibabacloud/rds/model/CheckCreateDdrDBInstanceRequest.h
 	include/alibabacloud/rds/model/CheckCreateDdrDBInstanceResult.h
 	include/alibabacloud/rds/model/CheckDBNameAvailableRequest.h
@@ -57,6 +59,8 @@ set(rds_public_header_model
 	include/alibabacloud/rds/model/CreateBackupResult.h
 	include/alibabacloud/rds/model/CreateDBInstanceRequest.h
 	include/alibabacloud/rds/model/CreateDBInstanceResult.h
+	include/alibabacloud/rds/model/CreateDBProxyEndpointAddressRequest.h
+	include/alibabacloud/rds/model/CreateDBProxyEndpointAddressResult.h
 	include/alibabacloud/rds/model/CreateDatabaseRequest.h
 	include/alibabacloud/rds/model/CreateDatabaseResult.h
 	include/alibabacloud/rds/model/CreateDdrInstanceRequest.h
@@ -93,6 +97,8 @@ set(rds_public_header_model
 	include/alibabacloud/rds/model/DeleteBackupFileResult.h
 	include/alibabacloud/rds/model/DeleteDBInstanceRequest.h
 	include/alibabacloud/rds/model/DeleteDBInstanceResult.h
+	include/alibabacloud/rds/model/DeleteDBProxyEndpointAddressRequest.h
+	include/alibabacloud/rds/model/DeleteDBProxyEndpointAddressResult.h
 	include/alibabacloud/rds/model/DeleteDatabaseRequest.h
 	include/alibabacloud/rds/model/DeleteDatabaseResult.h
 	include/alibabacloud/rds/model/DeleteDedicatedHostAccountRequest.h
@@ -187,6 +193,8 @@ set(rds_public_header_model
 	include/alibabacloud/rds/model/DescribeDBProxyPerformanceResult.h
 	include/alibabacloud/rds/model/DescribeDTCSecurityIpHostsForSQLServerRequest.h
 	include/alibabacloud/rds/model/DescribeDTCSecurityIpHostsForSQLServerResult.h
+	include/alibabacloud/rds/model/DescribeDasInstanceConfigRequest.h
+	include/alibabacloud/rds/model/DescribeDasInstanceConfigResult.h
 	include/alibabacloud/rds/model/DescribeDatabasesRequest.h
 	include/alibabacloud/rds/model/DescribeDatabasesResult.h
 	include/alibabacloud/rds/model/DescribeDedicatedHostAttributeRequest.h
@@ -351,6 +359,8 @@ set(rds_public_header_model
 	include/alibabacloud/rds/model/ModifyDBProxyInstanceResult.h
 	include/alibabacloud/rds/model/ModifyDTCSecurityIpHostsForSQLServerRequest.h
 	include/alibabacloud/rds/model/ModifyDTCSecurityIpHostsForSQLServerResult.h
+	include/alibabacloud/rds/model/ModifyDasInstanceConfigRequest.h
+	include/alibabacloud/rds/model/ModifyDasInstanceConfigResult.h
 	include/alibabacloud/rds/model/ModifyDedicatedHostAccountRequest.h
 	include/alibabacloud/rds/model/ModifyDedicatedHostAccountResult.h
 	include/alibabacloud/rds/model/ModifyDedicatedHostAttributeRequest.h
@@ -464,6 +474,8 @@ set(rds_src
 	src/model/CancelImportResult.cc
 	src/model/CheckAccountNameAvailableRequest.cc
 	src/model/CheckAccountNameAvailableResult.cc
+	src/model/CheckCloudResourceAuthorizedRequest.cc
+	src/model/CheckCloudResourceAuthorizedResult.cc
 	src/model/CheckCreateDdrDBInstanceRequest.cc
 	src/model/CheckCreateDdrDBInstanceResult.cc
 	src/model/CheckDBNameAvailableRequest.cc
@@ -488,6 +500,8 @@ set(rds_src
 	src/model/CreateBackupResult.cc
 	src/model/CreateDBInstanceRequest.cc
 	src/model/CreateDBInstanceResult.cc
+	src/model/CreateDBProxyEndpointAddressRequest.cc
+	src/model/CreateDBProxyEndpointAddressResult.cc
 	src/model/CreateDatabaseRequest.cc
 	src/model/CreateDatabaseResult.cc
 	src/model/CreateDdrInstanceRequest.cc
@@ -524,6 +538,8 @@ set(rds_src
 	src/model/DeleteBackupFileResult.cc
 	src/model/DeleteDBInstanceRequest.cc
 	src/model/DeleteDBInstanceResult.cc
+	src/model/DeleteDBProxyEndpointAddressRequest.cc
+	src/model/DeleteDBProxyEndpointAddressResult.cc
 	src/model/DeleteDatabaseRequest.cc
 	src/model/DeleteDatabaseResult.cc
 	src/model/DeleteDedicatedHostAccountRequest.cc
@@ -618,6 +634,8 @@ set(rds_src
 	src/model/DescribeDBProxyPerformanceResult.cc
 	src/model/DescribeDTCSecurityIpHostsForSQLServerRequest.cc
 	src/model/DescribeDTCSecurityIpHostsForSQLServerResult.cc
+	src/model/DescribeDasInstanceConfigRequest.cc
+	src/model/DescribeDasInstanceConfigResult.cc
 	src/model/DescribeDatabasesRequest.cc
 	src/model/DescribeDatabasesResult.cc
 	src/model/DescribeDedicatedHostAttributeRequest.cc
@@ -782,6 +800,8 @@ set(rds_src
 	src/model/ModifyDBProxyInstanceResult.cc
 	src/model/ModifyDTCSecurityIpHostsForSQLServerRequest.cc
 	src/model/ModifyDTCSecurityIpHostsForSQLServerResult.cc
+	src/model/ModifyDasInstanceConfigRequest.cc
+	src/model/ModifyDasInstanceConfigResult.cc
 	src/model/ModifyDedicatedHostAccountRequest.cc
 	src/model/ModifyDedicatedHostAccountResult.cc
 	src/model/ModifyDedicatedHostAttributeRequest.cc

rds/include/alibabacloud/rds/RdsClient.h

@@ -34,6 +34,8 @@
 #include "model/CancelImportResult.h"
 #include "model/CheckAccountNameAvailableRequest.h"
 #include "model/CheckAccountNameAvailableResult.h"
+#include "model/CheckCloudResourceAuthorizedRequest.h"
+#include "model/CheckCloudResourceAuthorizedResult.h"
 #include "model/CheckCreateDdrDBInstanceRequest.h"
 #include "model/CheckCreateDdrDBInstanceResult.h"
 #include "model/CheckDBNameAvailableRequest.h"
@@ -58,6 +60,8 @@
 #include "model/CreateBackupResult.h"
 #include "model/CreateDBInstanceRequest.h"
 #include "model/CreateDBInstanceResult.h"
+#include "model/CreateDBProxyEndpointAddressRequest.h"
+#include "model/CreateDBProxyEndpointAddressResult.h"
 #include "model/CreateDatabaseRequest.h"
 #include "model/CreateDatabaseResult.h"
 #include "model/CreateDdrInstanceRequest.h"
@@ -94,6 +98,8 @@
 #include "model/DeleteBackupFileResult.h"
 #include "model/DeleteDBInstanceRequest.h"
 #include "model/DeleteDBInstanceResult.h"
+#include "model/DeleteDBProxyEndpointAddressRequest.h"
+#include "model/DeleteDBProxyEndpointAddressResult.h"
 #include "model/DeleteDatabaseRequest.h"
 #include "model/DeleteDatabaseResult.h"
 #include "model/DeleteDedicatedHostAccountRequest.h"
@@ -188,6 +194,8 @@
 #include "model/DescribeDBProxyPerformanceResult.h"
 #include "model/DescribeDTCSecurityIpHostsForSQLServerRequest.h"
 #include "model/DescribeDTCSecurityIpHostsForSQLServerResult.h"
+#include "model/DescribeDasInstanceConfigRequest.h"
+#include "model/DescribeDasInstanceConfigResult.h"
 #include "model/DescribeDatabasesRequest.h"
 #include "model/DescribeDatabasesResult.h"
 #include "model/DescribeDedicatedHostAttributeRequest.h"
@@ -352,6 +360,8 @@
 #include "model/ModifyDBProxyInstanceResult.h"
 #include "model/ModifyDTCSecurityIpHostsForSQLServerRequest.h"
 #include "model/ModifyDTCSecurityIpHostsForSQLServerResult.h"
+#include "model/ModifyDasInstanceConfigRequest.h"
+#include "model/ModifyDasInstanceConfigResult.h"
 #include "model/ModifyDedicatedHostAccountRequest.h"
 #include "model/ModifyDedicatedHostAccountResult.h"
 #include "model/ModifyDedicatedHostAttributeRequest.h"
@@ -477,6 +487,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CheckAccountNameAvailableResult> CheckAccountNameAvailableOutcome;
 			typedef std::future<CheckAccountNameAvailableOutcome> CheckAccountNameAvailableOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::CheckAccountNameAvailableRequest&, const CheckAccountNameAvailableOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckAccountNameAvailableAsyncHandler;
+			typedef Outcome<Error, Model::CheckCloudResourceAuthorizedResult> CheckCloudResourceAuthorizedOutcome;
+			typedef std::future<CheckCloudResourceAuthorizedOutcome> CheckCloudResourceAuthorizedOutcomeCallable;
+			typedef std::function<void(const RdsClient*, const Model::CheckCloudResourceAuthorizedRequest&, const CheckCloudResourceAuthorizedOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckCloudResourceAuthorizedAsyncHandler;
 			typedef Outcome<Error, Model::CheckCreateDdrDBInstanceResult> CheckCreateDdrDBInstanceOutcome;
 			typedef std::future<CheckCreateDdrDBInstanceOutcome> CheckCreateDdrDBInstanceOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::CheckCreateDdrDBInstanceRequest&, const CheckCreateDdrDBInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckCreateDdrDBInstanceAsyncHandler;
@@ -513,6 +526,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateDBInstanceResult> CreateDBInstanceOutcome;
 			typedef std::future<CreateDBInstanceOutcome> CreateDBInstanceOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::CreateDBInstanceRequest&, const CreateDBInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDBInstanceAsyncHandler;
+			typedef Outcome<Error, Model::CreateDBProxyEndpointAddressResult> CreateDBProxyEndpointAddressOutcome;
+			typedef std::future<CreateDBProxyEndpointAddressOutcome> CreateDBProxyEndpointAddressOutcomeCallable;
+			typedef std::function<void(const RdsClient*, const Model::CreateDBProxyEndpointAddressRequest&, const CreateDBProxyEndpointAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDBProxyEndpointAddressAsyncHandler;
 			typedef Outcome<Error, Model::CreateDatabaseResult> CreateDatabaseOutcome;
 			typedef std::future<CreateDatabaseOutcome> CreateDatabaseOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::CreateDatabaseRequest&, const CreateDatabaseOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDatabaseAsyncHandler;
@@ -567,6 +583,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteDBInstanceResult> DeleteDBInstanceOutcome;
 			typedef std::future<DeleteDBInstanceOutcome> DeleteDBInstanceOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::DeleteDBInstanceRequest&, const DeleteDBInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDBInstanceAsyncHandler;
+			typedef Outcome<Error, Model::DeleteDBProxyEndpointAddressResult> DeleteDBProxyEndpointAddressOutcome;
+			typedef std::future<DeleteDBProxyEndpointAddressOutcome> DeleteDBProxyEndpointAddressOutcomeCallable;
+			typedef std::function<void(const RdsClient*, const Model::DeleteDBProxyEndpointAddressRequest&, const DeleteDBProxyEndpointAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDBProxyEndpointAddressAsyncHandler;
 			typedef Outcome<Error, Model::DeleteDatabaseResult> DeleteDatabaseOutcome;
 			typedef std::future<DeleteDatabaseOutcome> DeleteDatabaseOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::DeleteDatabaseRequest&, const DeleteDatabaseOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDatabaseAsyncHandler;
@@ -708,6 +727,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeDTCSecurityIpHostsForSQLServerResult> DescribeDTCSecurityIpHostsForSQLServerOutcome;
 			typedef std::future<DescribeDTCSecurityIpHostsForSQLServerOutcome> DescribeDTCSecurityIpHostsForSQLServerOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::DescribeDTCSecurityIpHostsForSQLServerRequest&, const DescribeDTCSecurityIpHostsForSQLServerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDTCSecurityIpHostsForSQLServerAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDasInstanceConfigResult> DescribeDasInstanceConfigOutcome;
+			typedef std::future<DescribeDasInstanceConfigOutcome> DescribeDasInstanceConfigOutcomeCallable;
+			typedef std::function<void(const RdsClient*, const Model::DescribeDasInstanceConfigRequest&, const DescribeDasInstanceConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDasInstanceConfigAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDatabasesResult> DescribeDatabasesOutcome;
 			typedef std::future<DescribeDatabasesOutcome> DescribeDatabasesOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::DescribeDatabasesRequest&, const DescribeDatabasesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDatabasesAsyncHandler;
@@ -954,6 +976,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ModifyDTCSecurityIpHostsForSQLServerResult> ModifyDTCSecurityIpHostsForSQLServerOutcome;
 			typedef std::future<ModifyDTCSecurityIpHostsForSQLServerOutcome> ModifyDTCSecurityIpHostsForSQLServerOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::ModifyDTCSecurityIpHostsForSQLServerRequest&, const ModifyDTCSecurityIpHostsForSQLServerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDTCSecurityIpHostsForSQLServerAsyncHandler;
+			typedef Outcome<Error, Model::ModifyDasInstanceConfigResult> ModifyDasInstanceConfigOutcome;
+			typedef std::future<ModifyDasInstanceConfigOutcome> ModifyDasInstanceConfigOutcomeCallable;
+			typedef std::function<void(const RdsClient*, const Model::ModifyDasInstanceConfigRequest&, const ModifyDasInstanceConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDasInstanceConfigAsyncHandler;
 			typedef Outcome<Error, Model::ModifyDedicatedHostAccountResult> ModifyDedicatedHostAccountOutcome;
 			typedef std::future<ModifyDedicatedHostAccountOutcome> ModifyDedicatedHostAccountOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::ModifyDedicatedHostAccountRequest&, const ModifyDedicatedHostAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDedicatedHostAccountAsyncHandler;
@@ -1124,6 +1149,9 @@ namespace AlibabaCloud
 			CheckAccountNameAvailableOutcome checkAccountNameAvailable(const Model::CheckAccountNameAvailableRequest &request)const;
 			void checkAccountNameAvailableAsync(const Model::CheckAccountNameAvailableRequest& request, const CheckAccountNameAvailableAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CheckAccountNameAvailableOutcomeCallable checkAccountNameAvailableCallable(const Model::CheckAccountNameAvailableRequest& request) const;
+			CheckCloudResourceAuthorizedOutcome checkCloudResourceAuthorized(const Model::CheckCloudResourceAuthorizedRequest &request)const;
+			void checkCloudResourceAuthorizedAsync(const Model::CheckCloudResourceAuthorizedRequest& request, const CheckCloudResourceAuthorizedAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CheckCloudResourceAuthorizedOutcomeCallable checkCloudResourceAuthorizedCallable(const Model::CheckCloudResourceAuthorizedRequest& request) const;
 			CheckCreateDdrDBInstanceOutcome checkCreateDdrDBInstance(const Model::CheckCreateDdrDBInstanceRequest &request)const;
 			void checkCreateDdrDBInstanceAsync(const Model::CheckCreateDdrDBInstanceRequest& request, const CheckCreateDdrDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CheckCreateDdrDBInstanceOutcomeCallable checkCreateDdrDBInstanceCallable(const Model::CheckCreateDdrDBInstanceRequest& request) const;
@@ -1160,6 +1188,9 @@ namespace AlibabaCloud
 			CreateDBInstanceOutcome createDBInstance(const Model::CreateDBInstanceRequest &request)const;
 			void createDBInstanceAsync(const Model::CreateDBInstanceRequest& request, const CreateDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateDBInstanceOutcomeCallable createDBInstanceCallable(const Model::CreateDBInstanceRequest& request) const;
+			CreateDBProxyEndpointAddressOutcome createDBProxyEndpointAddress(const Model::CreateDBProxyEndpointAddressRequest &request)const;
+			void createDBProxyEndpointAddressAsync(const Model::CreateDBProxyEndpointAddressRequest& request, const CreateDBProxyEndpointAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateDBProxyEndpointAddressOutcomeCallable createDBProxyEndpointAddressCallable(const Model::CreateDBProxyEndpointAddressRequest& request) const;
 			CreateDatabaseOutcome createDatabase(const Model::CreateDatabaseRequest &request)const;
 			void createDatabaseAsync(const Model::CreateDatabaseRequest& request, const CreateDatabaseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateDatabaseOutcomeCallable createDatabaseCallable(const Model::CreateDatabaseRequest& request) const;
@@ -1214,6 +1245,9 @@ namespace AlibabaCloud
 			DeleteDBInstanceOutcome deleteDBInstance(const Model::DeleteDBInstanceRequest &request)const;
 			void deleteDBInstanceAsync(const Model::DeleteDBInstanceRequest& request, const DeleteDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteDBInstanceOutcomeCallable deleteDBInstanceCallable(const Model::DeleteDBInstanceRequest& request) const;
+			DeleteDBProxyEndpointAddressOutcome deleteDBProxyEndpointAddress(const Model::DeleteDBProxyEndpointAddressRequest &request)const;
+			void deleteDBProxyEndpointAddressAsync(const Model::DeleteDBProxyEndpointAddressRequest& request, const DeleteDBProxyEndpointAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteDBProxyEndpointAddressOutcomeCallable deleteDBProxyEndpointAddressCallable(const Model::DeleteDBProxyEndpointAddressRequest& request) const;
 			DeleteDatabaseOutcome deleteDatabase(const Model::DeleteDatabaseRequest &request)const;
 			void deleteDatabaseAsync(const Model::DeleteDatabaseRequest& request, const DeleteDatabaseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteDatabaseOutcomeCallable deleteDatabaseCallable(const Model::DeleteDatabaseRequest& request) const;
@@ -1355,6 +1389,9 @@ namespace AlibabaCloud
 			DescribeDTCSecurityIpHostsForSQLServerOutcome describeDTCSecurityIpHostsForSQLServer(const Model::DescribeDTCSecurityIpHostsForSQLServerRequest &request)const;
 			void describeDTCSecurityIpHostsForSQLServerAsync(const Model::DescribeDTCSecurityIpHostsForSQLServerRequest& request, const DescribeDTCSecurityIpHostsForSQLServerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDTCSecurityIpHostsForSQLServerOutcomeCallable describeDTCSecurityIpHostsForSQLServerCallable(const Model::DescribeDTCSecurityIpHostsForSQLServerRequest& request) const;
+			DescribeDasInstanceConfigOutcome describeDasInstanceConfig(const Model::DescribeDasInstanceConfigRequest &request)const;
+			void describeDasInstanceConfigAsync(const Model::DescribeDasInstanceConfigRequest& request, const DescribeDasInstanceConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDasInstanceConfigOutcomeCallable describeDasInstanceConfigCallable(const Model::DescribeDasInstanceConfigRequest& request) const;
 			DescribeDatabasesOutcome describeDatabases(const Model::DescribeDatabasesRequest &request)const;
 			void describeDatabasesAsync(const Model::DescribeDatabasesRequest& request, const DescribeDatabasesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDatabasesOutcomeCallable describeDatabasesCallable(const Model::DescribeDatabasesRequest& request) const;
@@ -1601,6 +1638,9 @@ namespace AlibabaCloud
 			ModifyDTCSecurityIpHostsForSQLServerOutcome modifyDTCSecurityIpHostsForSQLServer(const Model::ModifyDTCSecurityIpHostsForSQLServerRequest &request)const;
 			void modifyDTCSecurityIpHostsForSQLServerAsync(const Model::ModifyDTCSecurityIpHostsForSQLServerRequest& request, const ModifyDTCSecurityIpHostsForSQLServerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyDTCSecurityIpHostsForSQLServerOutcomeCallable modifyDTCSecurityIpHostsForSQLServerCallable(const Model::ModifyDTCSecurityIpHostsForSQLServerRequest& request) const;
+			ModifyDasInstanceConfigOutcome modifyDasInstanceConfig(const Model::ModifyDasInstanceConfigRequest &request)const;
+			void modifyDasInstanceConfigAsync(const Model::ModifyDasInstanceConfigRequest& request, const ModifyDasInstanceConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyDasInstanceConfigOutcomeCallable modifyDasInstanceConfigCallable(const Model::ModifyDasInstanceConfigRequest& request) const;
 			ModifyDedicatedHostAccountOutcome modifyDedicatedHostAccount(const Model::ModifyDedicatedHostAccountRequest &request)const;
 			void modifyDedicatedHostAccountAsync(const Model::ModifyDedicatedHostAccountRequest& request, const ModifyDedicatedHostAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyDedicatedHostAccountOutcomeCallable modifyDedicatedHostAccountCallable(const Model::ModifyDedicatedHostAccountRequest& request) const;

rds/include/alibabacloud/rds/model/CheckCloudResourceAuthorizedRequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RDS_MODEL_CHECKCLOUDRESOURCEAUTHORIZEDREQUEST_H_
+#define ALIBABACLOUD_RDS_MODEL_CHECKCLOUDRESOURCEAUTHORIZEDREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rds/RdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RDS_EXPORT CheckCloudResourceAuthorizedRequest : public RpcServiceRequest
+			{
+
+			public:
+				CheckCloudResourceAuthorizedRequest();
+				~CheckCloudResourceAuthorizedRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string 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);
+				std::string getTargetRegionId()const;
+				void setTargetRegionId(const std::string& targetRegionId);
+
+            private:
+				long resourceOwnerId_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string regionId_;
+				std::string dBInstanceId_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string targetRegionId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RDS_MODEL_CHECKCLOUDRESOURCEAUTHORIZEDREQUEST_H_

rds/include/alibabacloud/rds/model/CheckCloudResourceAuthorizedResult.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_RDS_MODEL_CHECKCLOUDRESOURCEAUTHORIZEDRESULT_H_
+#define ALIBABACLOUD_RDS_MODEL_CHECKCLOUDRESOURCEAUTHORIZEDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rds/RdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RDS_EXPORT CheckCloudResourceAuthorizedResult : public ServiceResult
+			{
+			public:
+
+
+				CheckCloudResourceAuthorizedResult();
+				explicit CheckCloudResourceAuthorizedResult(const std::string &payload);
+				~CheckCloudResourceAuthorizedResult();
+				int getAuthorizationState()const;
+				std::string getRoleArn()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int authorizationState_;
+				std::string roleArn_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RDS_MODEL_CHECKCLOUDRESOURCEAUTHORIZEDRESULT_H_

rds/include/alibabacloud/rds/model/CheckCreateDdrDBInstanceRequest.h

@@ -43,6 +43,8 @@ namespace AlibabaCloud
 				void setSourceDBInstanceName(const std::string& sourceDBInstanceName);
 				std::string getHostType()const;
 				void setHostType(const std::string& hostType);
+				std::string getBinlogRole()const;
+				void setBinlogRole(const std::string& binlogRole);
 				std::string getEngineVersion()const;
 				void setEngineVersion(const std::string& engineVersion);
 				std::string getUserBakSetURL()const;
@@ -67,10 +69,14 @@ namespace AlibabaCloud
 				void setBackupSetId(const std::string& backupSetId);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
+				std::string getBinlogPosition()const;
+				void setBinlogPosition(const std::string& binlogPosition);
 				std::string getDBInstanceClass()const;
 				void setDBInstanceClass(const std::string& dBInstanceClass);
 				std::string getRestoreType()const;
 				void setRestoreType(const std::string& restoreType);
+				std::string getBinlogName()const;
+				void setBinlogName(const std::string& binlogName);
 				std::string getSourceRegion()const;
 				void setSourceRegion(const std::string& sourceRegion);
 
@@ -79,6 +85,7 @@ namespace AlibabaCloud
 				int dBInstanceStorage_;
 				std::string sourceDBInstanceName_;
 				std::string hostType_;
+				std::string binlogRole_;
 				std::string engineVersion_;
 				std::string userBakSetURL_;
 				std::string accessKeyId_;
@@ -91,8 +98,10 @@ namespace AlibabaCloud
 				std::string resourceOwnerAccount_;
 				std::string backupSetId_;
 				long ownerId_;
+				std::string binlogPosition_;
 				std::string dBInstanceClass_;
 				std::string restoreType_;
+				std::string binlogName_;
 				std::string sourceRegion_;
 
 			};

rds/include/alibabacloud/rds/model/CreateDBInstanceRequest.h

@@ -113,6 +113,8 @@ namespace AlibabaCloud
 				void setOwnerAccount(const std::string& ownerAccount);
 				std::string getUsedTime()const;
 				void setUsedTime(const std::string& usedTime);
+				std::string getTargetMinorVersion()const;
+				void setTargetMinorVersion(const std::string& targetMinorVersion);
 				int getStorageUpperBound()const;
 				void setStorageUpperBound(int storageUpperBound);
 				int getStorageThreshold()const;
@@ -164,6 +166,7 @@ namespace AlibabaCloud
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
 				std::string usedTime_;
+				std::string targetMinorVersion_;
 				int storageUpperBound_;
 				int storageThreshold_;
 				std::string vPCId_;

rds/include/alibabacloud/rds/model/CreateDBProxyEndpointAddressRequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RDS_MODEL_CREATEDBPROXYENDPOINTADDRESSREQUEST_H_
+#define ALIBABACLOUD_RDS_MODEL_CREATEDBPROXYENDPOINTADDRESSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rds/RdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RDS_EXPORT CreateDBProxyEndpointAddressRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateDBProxyEndpointAddressRequest();
+				~CreateDBProxyEndpointAddressRequest();
+
+				std::string getConnectionStringPrefix()const;
+				void setConnectionStringPrefix(const std::string& connectionStringPrefix);
+				std::string getDBProxyConnectStringNetType()const;
+				void setDBProxyConnectStringNetType(const std::string& dBProxyConnectStringNetType);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getDBInstanceId()const;
+				void setDBInstanceId(const std::string& dBInstanceId);
+				std::string getDBProxyNewConnectStringPort()const;
+				void setDBProxyNewConnectStringPort(const std::string& dBProxyNewConnectStringPort);
+				std::string getVSwitchId()const;
+				void setVSwitchId(const std::string& vSwitchId);
+				std::string getDBProxyEndpointId()const;
+				void setDBProxyEndpointId(const std::string& dBProxyEndpointId);
+				std::string getVPCId()const;
+				void setVPCId(const std::string& vPCId);
+
+            private:
+				std::string connectionStringPrefix_;
+				std::string dBProxyConnectStringNetType_;
+				std::string accessKeyId_;
+				std::string regionId_;
+				std::string dBInstanceId_;
+				std::string dBProxyNewConnectStringPort_;
+				std::string vSwitchId_;
+				std::string dBProxyEndpointId_;
+				std::string vPCId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RDS_MODEL_CREATEDBPROXYENDPOINTADDRESSREQUEST_H_

rds/include/alibabacloud/rds/model/CreateDBProxyEndpointAddressResult.h

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

rds/include/alibabacloud/rds/model/CreateDiagnosticReportRequest.h

@@ -43,12 +43,15 @@ namespace AlibabaCloud
 				void setAccessKeyId(const std::string& accessKeyId);
 				std::string getDBInstanceId()const;
 				void setDBInstanceId(const std::string& dBInstanceId);
+				std::string getCategory()const;
+				void setCategory(const std::string& category);
 
             private:
 				std::string endTime_;
 				std::string startTime_;
 				std::string accessKeyId_;
 				std::string dBInstanceId_;
+				std::string category_;
 
 			};
 		}

rds/include/alibabacloud/rds/model/CreateReadOnlyDBInstanceRequest.h

@@ -41,6 +41,8 @@ namespace AlibabaCloud
 				void setDBInstanceStorage(int dBInstanceStorage);
 				std::string getClientToken()const;
 				void setClientToken(const std::string& clientToken);
+				std::string getInstructionSetArch()const;
+				void setInstructionSetArch(const std::string& instructionSetArch);
 				std::string getEngineVersion()const;
 				void setEngineVersion(const std::string& engineVersion);
 				std::string getAccessKeyId()const;
@@ -92,6 +94,7 @@ namespace AlibabaCloud
 				long resourceOwnerId_;
 				int dBInstanceStorage_;
 				std::string clientToken_;
+				std::string instructionSetArch_;
 				std::string engineVersion_;
 				std::string accessKeyId_;
 				std::string resourceGroupId_;

rds/include/alibabacloud/rds/model/DeleteDBInstanceResult.h

@@ -37,10 +37,12 @@ namespace AlibabaCloud
 				DeleteDBInstanceResult();
 				explicit DeleteDBInstanceResult(const std::string &payload);
 				~DeleteDBInstanceResult();
+				std::string getRegionId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string regionId_;
 
 			};
 		}

rds/include/alibabacloud/rds/model/DeleteDBProxyEndpointAddressRequest.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_RDS_MODEL_DELETEDBPROXYENDPOINTADDRESSREQUEST_H_
+#define ALIBABACLOUD_RDS_MODEL_DELETEDBPROXYENDPOINTADDRESSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rds/RdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RDS_EXPORT DeleteDBProxyEndpointAddressRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteDBProxyEndpointAddressRequest();
+				~DeleteDBProxyEndpointAddressRequest();
+
+				std::string getDBProxyConnectStringNetType()const;
+				void setDBProxyConnectStringNetType(const std::string& dBProxyConnectStringNetType);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getDBProxyEndpointId()const;
+				void setDBProxyEndpointId(const std::string& dBProxyEndpointId);
+				std::string getDBInstanceId()const;
+				void setDBInstanceId(const std::string& dBInstanceId);
+
+            private:
+				std::string dBProxyConnectStringNetType_;
+				std::string accessKeyId_;
+				std::string regionId_;
+				std::string dBProxyEndpointId_;
+				std::string dBInstanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RDS_MODEL_DELETEDBPROXYENDPOINTADDRESSREQUEST_H_

rds/include/alibabacloud/rds/model/DeleteDBProxyEndpointAddressResult.h

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

rds/include/alibabacloud/rds/model/DescribeCrossRegionBackupsRequest.h

@@ -51,6 +51,8 @@ namespace AlibabaCloud
 				void setDBInstanceId(const std::string& dBInstanceId);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				int getBackupId()const;
+				void setBackupId(int backupId);
 				std::string getEndTime()const;
 				void setEndTime(const std::string& endTime);
 				long getOwnerId()const;
@@ -69,6 +71,7 @@ namespace AlibabaCloud
 				int pageSize_;
 				std::string dBInstanceId_;
 				std::string resourceOwnerAccount_;
+				int backupId_;
 				std::string endTime_;
 				long ownerId_;
 				std::string crossBackupRegion_;

rds/include/alibabacloud/rds/model/DescribeDasInstanceConfigRequest.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_RDS_MODEL_DESCRIBEDASINSTANCECONFIGREQUEST_H_
+#define ALIBABACLOUD_RDS_MODEL_DESCRIBEDASINSTANCECONFIGREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rds/RdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RDS_EXPORT DescribeDasInstanceConfigRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDasInstanceConfigRequest();
+				~DescribeDasInstanceConfigRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getDBInstanceId()const;
+				void setDBInstanceId(const std::string& dBInstanceId);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string clientToken_;
+				long ownerId_;
+				std::string accessKeyId_;
+				std::string dBInstanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RDS_MODEL_DESCRIBEDASINSTANCECONFIGREQUEST_H_

rds/include/alibabacloud/rds/model/DescribeDasInstanceConfigResult.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_RDS_MODEL_DESCRIBEDASINSTANCECONFIGRESULT_H_
+#define ALIBABACLOUD_RDS_MODEL_DESCRIBEDASINSTANCECONFIGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rds/RdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RDS_EXPORT DescribeDasInstanceConfigResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeDasInstanceConfigResult();
+				explicit DescribeDasInstanceConfigResult(const std::string &payload);
+				~DescribeDasInstanceConfigResult();
+				int getStorageUpperBound()const;
+				std::string getDBInstanceId()const;
+				int getMaxStorageUpperBound()const;
+				std::string getData()const;
+				int getStorageThreshold()const;
+				std::string getDBType()const;
+				bool getStorageAutoScale()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int storageUpperBound_;
+				std::string dBInstanceId_;
+				int maxStorageUpperBound_;
+				std::string data_;
+				int storageThreshold_;
+				std::string dBType_;
+				bool storageAutoScale_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RDS_MODEL_DESCRIBEDASINSTANCECONFIGRESULT_H_

rds/include/alibabacloud/rds/model/DescribeRdsResourceSettingsResult.h

@@ -36,6 +36,7 @@ namespace AlibabaCloud
 				{
 					std::string startDate;
 					std::string poppedUpButtonUrl;
+					std::string isTop;
 					std::string poppedUpButtonType;
 					std::string resourceNiche;
 					std::string noticeBarContent;

rds/include/alibabacloud/rds/model/ModifyDasInstanceConfigRequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RDS_MODEL_MODIFYDASINSTANCECONFIGREQUEST_H_
+#define ALIBABACLOUD_RDS_MODEL_MODIFYDASINSTANCECONFIGREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rds/RdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RDS_EXPORT ModifyDasInstanceConfigRequest : public RpcServiceRequest
+			{
+
+			public:
+				ModifyDasInstanceConfigRequest();
+				~ModifyDasInstanceConfigRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getDBInstanceId()const;
+				void setDBInstanceId(const std::string& dBInstanceId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				int getStorageUpperBound()const;
+				void setStorageUpperBound(int storageUpperBound);
+				int getStorageThreshold()const;
+				void setStorageThreshold(int storageThreshold);
+				std::string getStorageAutoScale()const;
+				void setStorageAutoScale(const std::string& storageAutoScale);
+
+            private:
+				long resourceOwnerId_;
+				std::string clientToken_;
+				std::string accessKeyId_;
+				std::string dBInstanceId_;
+				std::string resourceOwnerAccount_;
+				long ownerId_;
+				int storageUpperBound_;
+				int storageThreshold_;
+				std::string storageAutoScale_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RDS_MODEL_MODIFYDASINSTANCECONFIGREQUEST_H_

rds/include/alibabacloud/rds/model/ModifyDasInstanceConfigResult.h

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

rds/include/alibabacloud/rds/model/RestartDBInstanceRequest.h

@@ -37,27 +37,36 @@ namespace AlibabaCloud
 
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
-				std::string getResourceOwnerAccount()const;
-				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getClientToken()const;
 				void setClientToken(const std::string& clientToken);
-				std::string getOwnerAccount()const;
-				void setOwnerAccount(const std::string& ownerAccount);
-				long getOwnerId()const;
-				void setOwnerId(long ownerId);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getRestartMethod()const;
+				void setRestartMethod(const std::string& restartMethod);
+				std::string getEffectiveTime()const;
+				void setEffectiveTime(const std::string& effectiveTime);
 				std::string getDBInstanceId()const;
 				void setDBInstanceId(const std::string& dBInstanceId);
+				std::string getSwitchTime()const;
+				void setSwitchTime(const std::string& switchTime);
+				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 resourceOwnerAccount_;
 				std::string clientToken_;
-				std::string ownerAccount_;
-				long ownerId_;
 				std::string accessKeyId_;
+				std::string restartMethod_;
+				std::string effectiveTime_;
 				std::string dBInstanceId_;
+				std::string switchTime_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
 
 			};
 		}

rds/src/RdsClient.cc

@@ -267,6 +267,42 @@ RdsClient::CheckAccountNameAvailableOutcomeCallable RdsClient::checkAccountNameA
 	return task->get_future();
 }
 
+RdsClient::CheckCloudResourceAuthorizedOutcome RdsClient::checkCloudResourceAuthorized(const CheckCloudResourceAuthorizedRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CheckCloudResourceAuthorizedOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CheckCloudResourceAuthorizedOutcome(CheckCloudResourceAuthorizedResult(outcome.result()));
+	else
+		return CheckCloudResourceAuthorizedOutcome(outcome.error());
+}
+
+void RdsClient::checkCloudResourceAuthorizedAsync(const CheckCloudResourceAuthorizedRequest& request, const CheckCloudResourceAuthorizedAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, checkCloudResourceAuthorized(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RdsClient::CheckCloudResourceAuthorizedOutcomeCallable RdsClient::checkCloudResourceAuthorizedCallable(const CheckCloudResourceAuthorizedRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CheckCloudResourceAuthorizedOutcome()>>(
+			[this, request]()
+			{
+			return this->checkCloudResourceAuthorized(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 RdsClient::CheckCreateDdrDBInstanceOutcome RdsClient::checkCreateDdrDBInstance(const CheckCreateDdrDBInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -699,6 +735,42 @@ RdsClient::CreateDBInstanceOutcomeCallable RdsClient::createDBInstanceCallable(c
 	return task->get_future();
 }
 
+RdsClient::CreateDBProxyEndpointAddressOutcome RdsClient::createDBProxyEndpointAddress(const CreateDBProxyEndpointAddressRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateDBProxyEndpointAddressOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateDBProxyEndpointAddressOutcome(CreateDBProxyEndpointAddressResult(outcome.result()));
+	else
+		return CreateDBProxyEndpointAddressOutcome(outcome.error());
+}
+
+void RdsClient::createDBProxyEndpointAddressAsync(const CreateDBProxyEndpointAddressRequest& request, const CreateDBProxyEndpointAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createDBProxyEndpointAddress(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RdsClient::CreateDBProxyEndpointAddressOutcomeCallable RdsClient::createDBProxyEndpointAddressCallable(const CreateDBProxyEndpointAddressRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateDBProxyEndpointAddressOutcome()>>(
+			[this, request]()
+			{
+			return this->createDBProxyEndpointAddress(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 RdsClient::CreateDatabaseOutcome RdsClient::createDatabase(const CreateDatabaseRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1347,6 +1419,42 @@ RdsClient::DeleteDBInstanceOutcomeCallable RdsClient::deleteDBInstanceCallable(c
 	return task->get_future();
 }
 
+RdsClient::DeleteDBProxyEndpointAddressOutcome RdsClient::deleteDBProxyEndpointAddress(const DeleteDBProxyEndpointAddressRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteDBProxyEndpointAddressOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteDBProxyEndpointAddressOutcome(DeleteDBProxyEndpointAddressResult(outcome.result()));
+	else
+		return DeleteDBProxyEndpointAddressOutcome(outcome.error());
+}
+
+void RdsClient::deleteDBProxyEndpointAddressAsync(const DeleteDBProxyEndpointAddressRequest& request, const DeleteDBProxyEndpointAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteDBProxyEndpointAddress(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RdsClient::DeleteDBProxyEndpointAddressOutcomeCallable RdsClient::deleteDBProxyEndpointAddressCallable(const DeleteDBProxyEndpointAddressRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteDBProxyEndpointAddressOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteDBProxyEndpointAddress(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 RdsClient::DeleteDatabaseOutcome RdsClient::deleteDatabase(const DeleteDatabaseRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3039,6 +3147,42 @@ RdsClient::DescribeDTCSecurityIpHostsForSQLServerOutcomeCallable RdsClient::desc
 	return task->get_future();
 }
 
+RdsClient::DescribeDasInstanceConfigOutcome RdsClient::describeDasInstanceConfig(const DescribeDasInstanceConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDasInstanceConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDasInstanceConfigOutcome(DescribeDasInstanceConfigResult(outcome.result()));
+	else
+		return DescribeDasInstanceConfigOutcome(outcome.error());
+}
+
+void RdsClient::describeDasInstanceConfigAsync(const DescribeDasInstanceConfigRequest& request, const DescribeDasInstanceConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDasInstanceConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RdsClient::DescribeDasInstanceConfigOutcomeCallable RdsClient::describeDasInstanceConfigCallable(const DescribeDasInstanceConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDasInstanceConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDasInstanceConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 RdsClient::DescribeDatabasesOutcome RdsClient::describeDatabases(const DescribeDatabasesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -5991,6 +6135,42 @@ RdsClient::ModifyDTCSecurityIpHostsForSQLServerOutcomeCallable RdsClient::modify
 	return task->get_future();
 }
 
+RdsClient::ModifyDasInstanceConfigOutcome RdsClient::modifyDasInstanceConfig(const ModifyDasInstanceConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyDasInstanceConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyDasInstanceConfigOutcome(ModifyDasInstanceConfigResult(outcome.result()));
+	else
+		return ModifyDasInstanceConfigOutcome(outcome.error());
+}
+
+void RdsClient::modifyDasInstanceConfigAsync(const ModifyDasInstanceConfigRequest& request, const ModifyDasInstanceConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyDasInstanceConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RdsClient::ModifyDasInstanceConfigOutcomeCallable RdsClient::modifyDasInstanceConfigCallable(const ModifyDasInstanceConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyDasInstanceConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyDasInstanceConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 RdsClient::ModifyDedicatedHostAccountOutcome RdsClient::modifyDedicatedHostAccount(const ModifyDedicatedHostAccountRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

rds/src/model/CheckCloudResourceAuthorizedRequest.cc

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

rds/src/model/CheckCloudResourceAuthorizedResult.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/rds/model/CheckCloudResourceAuthorizedResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rds;
+using namespace AlibabaCloud::Rds::Model;
+
+CheckCloudResourceAuthorizedResult::CheckCloudResourceAuthorizedResult() :
+	ServiceResult()
+{}
+
+CheckCloudResourceAuthorizedResult::CheckCloudResourceAuthorizedResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CheckCloudResourceAuthorizedResult::~CheckCloudResourceAuthorizedResult()
+{}
+
+void CheckCloudResourceAuthorizedResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["AuthorizationState"].isNull())
+		authorizationState_ = std::stoi(value["AuthorizationState"].asString());
+	if(!value["RoleArn"].isNull())
+		roleArn_ = value["RoleArn"].asString();
+
+}
+
+int CheckCloudResourceAuthorizedResult::getAuthorizationState()const
+{
+	return authorizationState_;
+}
+
+std::string CheckCloudResourceAuthorizedResult::getRoleArn()const
+{
+	return roleArn_;
+}
+

rds/src/model/CheckCreateDdrDBInstanceRequest.cc

@@ -71,6 +71,17 @@ void CheckCreateDdrDBInstanceRequest::setHostType(const std::string& hostType)
 	setParameter("HostType", hostType);
 }
 
+std::string CheckCreateDdrDBInstanceRequest::getBinlogRole()const
+{
+	return binlogRole_;
+}
+
+void CheckCreateDdrDBInstanceRequest::setBinlogRole(const std::string& binlogRole)
+{
+	binlogRole_ = binlogRole;
+	setParameter("BinlogRole", binlogRole);
+}
+
 std::string CheckCreateDdrDBInstanceRequest::getEngineVersion()const
 {
 	return engineVersion_;
@@ -203,6 +214,17 @@ void CheckCreateDdrDBInstanceRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
+std::string CheckCreateDdrDBInstanceRequest::getBinlogPosition()const
+{
+	return binlogPosition_;
+}
+
+void CheckCreateDdrDBInstanceRequest::setBinlogPosition(const std::string& binlogPosition)
+{
+	binlogPosition_ = binlogPosition;
+	setParameter("BinlogPosition", binlogPosition);
+}
+
 std::string CheckCreateDdrDBInstanceRequest::getDBInstanceClass()const
 {
 	return dBInstanceClass_;
@@ -225,6 +247,17 @@ void CheckCreateDdrDBInstanceRequest::setRestoreType(const std::string& restoreT
 	setParameter("RestoreType", restoreType);
 }
 
+std::string CheckCreateDdrDBInstanceRequest::getBinlogName()const
+{
+	return binlogName_;
+}
+
+void CheckCreateDdrDBInstanceRequest::setBinlogName(const std::string& binlogName)
+{
+	binlogName_ = binlogName;
+	setParameter("BinlogName", binlogName);
+}
+
 std::string CheckCreateDdrDBInstanceRequest::getSourceRegion()const
 {
 	return sourceRegion_;

rds/src/model/CreateDBInstanceRequest.cc

@@ -456,6 +456,17 @@ void CreateDBInstanceRequest::setUsedTime(const std::string& usedTime)
 	setParameter("UsedTime", usedTime);
 }
 
+std::string CreateDBInstanceRequest::getTargetMinorVersion()const
+{
+	return targetMinorVersion_;
+}
+
+void CreateDBInstanceRequest::setTargetMinorVersion(const std::string& targetMinorVersion)
+{
+	targetMinorVersion_ = targetMinorVersion;
+	setParameter("TargetMinorVersion", targetMinorVersion);
+}
+
 int CreateDBInstanceRequest::getStorageUpperBound()const
 {
 	return storageUpperBound_;

rds/src/model/CreateDBProxyEndpointAddressRequest.cc

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rds/model/CreateDBProxyEndpointAddressRequest.h>
+
+using AlibabaCloud::Rds::Model::CreateDBProxyEndpointAddressRequest;
+
+CreateDBProxyEndpointAddressRequest::CreateDBProxyEndpointAddressRequest() :
+	RpcServiceRequest("rds", "2014-08-15", "CreateDBProxyEndpointAddress")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateDBProxyEndpointAddressRequest::~CreateDBProxyEndpointAddressRequest()
+{}
+
+std::string CreateDBProxyEndpointAddressRequest::getConnectionStringPrefix()const
+{
+	return connectionStringPrefix_;
+}
+
+void CreateDBProxyEndpointAddressRequest::setConnectionStringPrefix(const std::string& connectionStringPrefix)
+{
+	connectionStringPrefix_ = connectionStringPrefix;
+	setParameter("ConnectionStringPrefix", connectionStringPrefix);
+}
+
+std::string CreateDBProxyEndpointAddressRequest::getDBProxyConnectStringNetType()const
+{
+	return dBProxyConnectStringNetType_;
+}
+
+void CreateDBProxyEndpointAddressRequest::setDBProxyConnectStringNetType(const std::string& dBProxyConnectStringNetType)
+{
+	dBProxyConnectStringNetType_ = dBProxyConnectStringNetType;
+	setParameter("DBProxyConnectStringNetType", dBProxyConnectStringNetType);
+}
+
+std::string CreateDBProxyEndpointAddressRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void CreateDBProxyEndpointAddressRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string CreateDBProxyEndpointAddressRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateDBProxyEndpointAddressRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CreateDBProxyEndpointAddressRequest::getDBInstanceId()const
+{
+	return dBInstanceId_;
+}
+
+void CreateDBProxyEndpointAddressRequest::setDBInstanceId(const std::string& dBInstanceId)
+{
+	dBInstanceId_ = dBInstanceId;
+	setParameter("DBInstanceId", dBInstanceId);
+}
+
+std::string CreateDBProxyEndpointAddressRequest::getDBProxyNewConnectStringPort()const
+{
+	return dBProxyNewConnectStringPort_;
+}
+
+void CreateDBProxyEndpointAddressRequest::setDBProxyNewConnectStringPort(const std::string& dBProxyNewConnectStringPort)
+{
+	dBProxyNewConnectStringPort_ = dBProxyNewConnectStringPort;
+	setParameter("DBProxyNewConnectStringPort", dBProxyNewConnectStringPort);
+}
+
+std::string CreateDBProxyEndpointAddressRequest::getVSwitchId()const
+{
+	return vSwitchId_;
+}
+
+void CreateDBProxyEndpointAddressRequest::setVSwitchId(const std::string& vSwitchId)
+{
+	vSwitchId_ = vSwitchId;
+	setParameter("VSwitchId", vSwitchId);
+}
+
+std::string CreateDBProxyEndpointAddressRequest::getDBProxyEndpointId()const
+{
+	return dBProxyEndpointId_;
+}
+
+void CreateDBProxyEndpointAddressRequest::setDBProxyEndpointId(const std::string& dBProxyEndpointId)
+{
+	dBProxyEndpointId_ = dBProxyEndpointId;
+	setParameter("DBProxyEndpointId", dBProxyEndpointId);
+}
+
+std::string CreateDBProxyEndpointAddressRequest::getVPCId()const
+{
+	return vPCId_;
+}
+
+void CreateDBProxyEndpointAddressRequest::setVPCId(const std::string& vPCId)
+{
+	vPCId_ = vPCId;
+	setParameter("VPCId", vPCId);
+}
+

rds/src/model/CreateDBProxyEndpointAddressResult.cc

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

rds/src/model/CreateDiagnosticReportRequest.cc

@@ -71,3 +71,14 @@ void CreateDiagnosticReportRequest::setDBInstanceId(const std::string& dBInstanc
 	setParameter("DBInstanceId", dBInstanceId);
 }
 
+std::string CreateDiagnosticReportRequest::getCategory()const
+{
+	return category_;
+}
+
+void CreateDiagnosticReportRequest::setCategory(const std::string& category)
+{
+	category_ = category;
+	setParameter("Category", category);
+}
+

rds/src/model/CreateReadOnlyDBInstanceRequest.cc

@@ -60,6 +60,17 @@ void CreateReadOnlyDBInstanceRequest::setClientToken(const std::string& clientTo
 	setParameter("ClientToken", clientToken);
 }
 
+std::string CreateReadOnlyDBInstanceRequest::getInstructionSetArch()const
+{
+	return instructionSetArch_;
+}
+
+void CreateReadOnlyDBInstanceRequest::setInstructionSetArch(const std::string& instructionSetArch)
+{
+	instructionSetArch_ = instructionSetArch;
+	setParameter("InstructionSetArch", instructionSetArch);
+}
+
 std::string CreateReadOnlyDBInstanceRequest::getEngineVersion()const
 {
 	return engineVersion_;

rds/src/model/DeleteDBInstanceResult.cc

@@ -39,6 +39,13 @@ void DeleteDBInstanceResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	if(!value["RegionId"].isNull())
+		regionId_ = value["RegionId"].asString();
 
 }
 
+std::string DeleteDBInstanceResult::getRegionId()const
+{
+	return regionId_;
+}
+

rds/src/model/DeleteDBProxyEndpointAddressRequest.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/rds/model/DeleteDBProxyEndpointAddressRequest.h>
+
+using AlibabaCloud::Rds::Model::DeleteDBProxyEndpointAddressRequest;
+
+DeleteDBProxyEndpointAddressRequest::DeleteDBProxyEndpointAddressRequest() :
+	RpcServiceRequest("rds", "2014-08-15", "DeleteDBProxyEndpointAddress")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteDBProxyEndpointAddressRequest::~DeleteDBProxyEndpointAddressRequest()
+{}
+
+std::string DeleteDBProxyEndpointAddressRequest::getDBProxyConnectStringNetType()const
+{
+	return dBProxyConnectStringNetType_;
+}
+
+void DeleteDBProxyEndpointAddressRequest::setDBProxyConnectStringNetType(const std::string& dBProxyConnectStringNetType)
+{
+	dBProxyConnectStringNetType_ = dBProxyConnectStringNetType;
+	setParameter("DBProxyConnectStringNetType", dBProxyConnectStringNetType);
+}
+
+std::string DeleteDBProxyEndpointAddressRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DeleteDBProxyEndpointAddressRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DeleteDBProxyEndpointAddressRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteDBProxyEndpointAddressRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DeleteDBProxyEndpointAddressRequest::getDBProxyEndpointId()const
+{
+	return dBProxyEndpointId_;
+}
+
+void DeleteDBProxyEndpointAddressRequest::setDBProxyEndpointId(const std::string& dBProxyEndpointId)
+{
+	dBProxyEndpointId_ = dBProxyEndpointId;
+	setParameter("DBProxyEndpointId", dBProxyEndpointId);
+}
+
+std::string DeleteDBProxyEndpointAddressRequest::getDBInstanceId()const
+{
+	return dBInstanceId_;
+}
+
+void DeleteDBProxyEndpointAddressRequest::setDBInstanceId(const std::string& dBInstanceId)
+{
+	dBInstanceId_ = dBInstanceId;
+	setParameter("DBInstanceId", dBInstanceId);
+}
+

rds/src/model/DeleteDBProxyEndpointAddressResult.cc

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

rds/src/model/DescribeCrossRegionBackupsRequest.cc

@@ -115,6 +115,17 @@ void DescribeCrossRegionBackupsRequest::setResourceOwnerAccount(const std::strin
 	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
+int DescribeCrossRegionBackupsRequest::getBackupId()const
+{
+	return backupId_;
+}
+
+void DescribeCrossRegionBackupsRequest::setBackupId(int backupId)
+{
+	backupId_ = backupId;
+	setParameter("BackupId", std::to_string(backupId));
+}
+
 std::string DescribeCrossRegionBackupsRequest::getEndTime()const
 {
 	return endTime_;

rds/src/model/DescribeDasInstanceConfigRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rds/model/DescribeDasInstanceConfigRequest.h>
+
+using AlibabaCloud::Rds::Model::DescribeDasInstanceConfigRequest;
+
+DescribeDasInstanceConfigRequest::DescribeDasInstanceConfigRequest() :
+	RpcServiceRequest("rds", "2014-08-15", "DescribeDasInstanceConfig")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDasInstanceConfigRequest::~DescribeDasInstanceConfigRequest()
+{}
+
+long DescribeDasInstanceConfigRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeDasInstanceConfigRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeDasInstanceConfigRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeDasInstanceConfigRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeDasInstanceConfigRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void DescribeDasInstanceConfigRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+long DescribeDasInstanceConfigRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDasInstanceConfigRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeDasInstanceConfigRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeDasInstanceConfigRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeDasInstanceConfigRequest::getDBInstanceId()const
+{
+	return dBInstanceId_;
+}
+
+void DescribeDasInstanceConfigRequest::setDBInstanceId(const std::string& dBInstanceId)
+{
+	dBInstanceId_ = dBInstanceId;
+	setParameter("DBInstanceId", dBInstanceId);
+}
+

rds/src/model/DescribeDasInstanceConfigResult.cc

@@ -0,0 +1,93 @@
+/*
+ * 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/rds/model/DescribeDasInstanceConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rds;
+using namespace AlibabaCloud::Rds::Model;
+
+DescribeDasInstanceConfigResult::DescribeDasInstanceConfigResult() :
+	ServiceResult()
+{}
+
+DescribeDasInstanceConfigResult::DescribeDasInstanceConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDasInstanceConfigResult::~DescribeDasInstanceConfigResult()
+{}
+
+void DescribeDasInstanceConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString();
+	if(!value["StorageUpperBound"].isNull())
+		storageUpperBound_ = std::stoi(value["StorageUpperBound"].asString());
+	if(!value["MaxStorageUpperBound"].isNull())
+		maxStorageUpperBound_ = std::stoi(value["MaxStorageUpperBound"].asString());
+	if(!value["DBInstanceId"].isNull())
+		dBInstanceId_ = value["DBInstanceId"].asString();
+	if(!value["StorageThreshold"].isNull())
+		storageThreshold_ = std::stoi(value["StorageThreshold"].asString());
+	if(!value["StorageAutoScale"].isNull())
+		storageAutoScale_ = value["StorageAutoScale"].asString() == "true";
+	if(!value["DBType"].isNull())
+		dBType_ = value["DBType"].asString();
+
+}
+
+int DescribeDasInstanceConfigResult::getStorageUpperBound()const
+{
+	return storageUpperBound_;
+}
+
+std::string DescribeDasInstanceConfigResult::getDBInstanceId()const
+{
+	return dBInstanceId_;
+}
+
+int DescribeDasInstanceConfigResult::getMaxStorageUpperBound()const
+{
+	return maxStorageUpperBound_;
+}
+
+std::string DescribeDasInstanceConfigResult::getData()const
+{
+	return data_;
+}
+
+int DescribeDasInstanceConfigResult::getStorageThreshold()const
+{
+	return storageThreshold_;
+}
+
+std::string DescribeDasInstanceConfigResult::getDBType()const
+{
+	return dBType_;
+}
+
+bool DescribeDasInstanceConfigResult::getStorageAutoScale()const
+{
+	return storageAutoScale_;
+}
+

rds/src/model/DescribeRdsResourceSettingsResult.cc

@@ -59,6 +59,8 @@ void DescribeRdsResourceSettingsResult::parse(const std::string &payload)
 			rdsInstanceResourceSettingsObject.poppedUpButtonUrl = valueRdsInstanceResourceSettingsRdsInstanceResourceSetting["PoppedUpButtonUrl"].asString();
 		if(!valueRdsInstanceResourceSettingsRdsInstanceResourceSetting["PoppedUpContent"].isNull())
 			rdsInstanceResourceSettingsObject.poppedUpContent = valueRdsInstanceResourceSettingsRdsInstanceResourceSetting["PoppedUpContent"].asString();
+		if(!valueRdsInstanceResourceSettingsRdsInstanceResourceSetting["IsTop"].isNull())
+			rdsInstanceResourceSettingsObject.isTop = valueRdsInstanceResourceSettingsRdsInstanceResourceSetting["IsTop"].asString();
 		rdsInstanceResourceSettings_.push_back(rdsInstanceResourceSettingsObject);
 	}
 

rds/src/model/ModifyDasInstanceConfigRequest.cc

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rds/model/ModifyDasInstanceConfigRequest.h>
+
+using AlibabaCloud::Rds::Model::ModifyDasInstanceConfigRequest;
+
+ModifyDasInstanceConfigRequest::ModifyDasInstanceConfigRequest() :
+	RpcServiceRequest("rds", "2014-08-15", "ModifyDasInstanceConfig")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ModifyDasInstanceConfigRequest::~ModifyDasInstanceConfigRequest()
+{}
+
+long ModifyDasInstanceConfigRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void ModifyDasInstanceConfigRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string ModifyDasInstanceConfigRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void ModifyDasInstanceConfigRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string ModifyDasInstanceConfigRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void ModifyDasInstanceConfigRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string ModifyDasInstanceConfigRequest::getDBInstanceId()const
+{
+	return dBInstanceId_;
+}
+
+void ModifyDasInstanceConfigRequest::setDBInstanceId(const std::string& dBInstanceId)
+{
+	dBInstanceId_ = dBInstanceId;
+	setParameter("DBInstanceId", dBInstanceId);
+}
+
+std::string ModifyDasInstanceConfigRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void ModifyDasInstanceConfigRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+long ModifyDasInstanceConfigRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void ModifyDasInstanceConfigRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+int ModifyDasInstanceConfigRequest::getStorageUpperBound()const
+{
+	return storageUpperBound_;
+}
+
+void ModifyDasInstanceConfigRequest::setStorageUpperBound(int storageUpperBound)
+{
+	storageUpperBound_ = storageUpperBound;
+	setParameter("StorageUpperBound", std::to_string(storageUpperBound));
+}
+
+int ModifyDasInstanceConfigRequest::getStorageThreshold()const
+{
+	return storageThreshold_;
+}
+
+void ModifyDasInstanceConfigRequest::setStorageThreshold(int storageThreshold)
+{
+	storageThreshold_ = storageThreshold;
+	setParameter("StorageThreshold", std::to_string(storageThreshold));
+}
+
+std::string ModifyDasInstanceConfigRequest::getStorageAutoScale()const
+{
+	return storageAutoScale_;
+}
+
+void ModifyDasInstanceConfigRequest::setStorageAutoScale(const std::string& storageAutoScale)
+{
+	storageAutoScale_ = storageAutoScale;
+	setParameter("StorageAutoScale", storageAutoScale);
+}
+

rds/src/model/ModifyDasInstanceConfigResult.cc

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

rds/src/model/RestartDBInstanceRequest.cc

@@ -38,17 +38,6 @@ void RestartDBInstanceRequest::setResourceOwnerId(long resourceOwnerId)
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
-std::string RestartDBInstanceRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
-}
-
-void RestartDBInstanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
-}
-
 std::string RestartDBInstanceRequest::getClientToken()const
 {
 	return clientToken_;
@@ -60,37 +49,37 @@ void RestartDBInstanceRequest::setClientToken(const std::string& clientToken)
 	setParameter("ClientToken", clientToken);
 }
 
-std::string RestartDBInstanceRequest::getOwnerAccount()const
+std::string RestartDBInstanceRequest::getAccessKeyId()const
 {
-	return ownerAccount_;
+	return accessKeyId_;
 }
 
-void RestartDBInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
+void RestartDBInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
 {
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
 }
 
-long RestartDBInstanceRequest::getOwnerId()const
+std::string RestartDBInstanceRequest::getRestartMethod()const
 {
-	return ownerId_;
+	return restartMethod_;
 }
 
-void RestartDBInstanceRequest::setOwnerId(long ownerId)
+void RestartDBInstanceRequest::setRestartMethod(const std::string& restartMethod)
 {
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	restartMethod_ = restartMethod;
+	setParameter("RestartMethod", restartMethod);
 }
 
-std::string RestartDBInstanceRequest::getAccessKeyId()const
+std::string RestartDBInstanceRequest::getEffectiveTime()const
 {
-	return accessKeyId_;
+	return effectiveTime_;
 }
 
-void RestartDBInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
+void RestartDBInstanceRequest::setEffectiveTime(const std::string& effectiveTime)
 {
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	effectiveTime_ = effectiveTime;
+	setParameter("EffectiveTime", effectiveTime);
 }
 
 std::string RestartDBInstanceRequest::getDBInstanceId()const
@@ -104,3 +93,47 @@ void RestartDBInstanceRequest::setDBInstanceId(const std::string& dBInstanceId)
 	setParameter("DBInstanceId", dBInstanceId);
 }
 
+std::string RestartDBInstanceRequest::getSwitchTime()const
+{
+	return switchTime_;
+}
+
+void RestartDBInstanceRequest::setSwitchTime(const std::string& switchTime)
+{
+	switchTime_ = switchTime;
+	setParameter("SwitchTime", switchTime);
+}
+
+std::string RestartDBInstanceRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void RestartDBInstanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string RestartDBInstanceRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void RestartDBInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long RestartDBInstanceRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void RestartDBInstanceRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+