Support upgrade.

CHANGELOG

@@ -1,3 +1,6 @@
+2021-05-31 Version: 1.36.761
+- Support upgrade.
+
 2021-05-28 Version: 1.36.760
 - Add TriggerRemoteSync api.
 

VERSION

@@ -1 +1 @@
-1.36.760
+1.36.761

dbfs/CMakeLists.txt

@@ -21,37 +21,137 @@ set(dbfs_public_header
 	include/alibabacloud/dbfs/DBFSExport.h )
 
 set(dbfs_public_header_model 
+	include/alibabacloud/dbfs/model/AddTagsBatchRequest.h
+	include/alibabacloud/dbfs/model/AddTagsBatchResult.h
 	include/alibabacloud/dbfs/model/AttachDbfsRequest.h
 	include/alibabacloud/dbfs/model/AttachDbfsResult.h
+	include/alibabacloud/dbfs/model/CreateConstantsRequest.h
+	include/alibabacloud/dbfs/model/CreateConstantsResult.h
 	include/alibabacloud/dbfs/model/CreateDbfsRequest.h
 	include/alibabacloud/dbfs/model/CreateDbfsResult.h
+	include/alibabacloud/dbfs/model/CreateServiceLinkedRoleRequest.h
+	include/alibabacloud/dbfs/model/CreateServiceLinkedRoleResult.h
+	include/alibabacloud/dbfs/model/CreateSnapshotRequest.h
+	include/alibabacloud/dbfs/model/CreateSnapshotResult.h
+	include/alibabacloud/dbfs/model/DbfsRecordRequest.h
+	include/alibabacloud/dbfs/model/DbfsRecordResult.h
+	include/alibabacloud/dbfs/model/DeleteConstantsRequest.h
+	include/alibabacloud/dbfs/model/DeleteConstantsResult.h
 	include/alibabacloud/dbfs/model/DeleteDbfsRequest.h
 	include/alibabacloud/dbfs/model/DeleteDbfsResult.h
+	include/alibabacloud/dbfs/model/DeleteSnapshotRequest.h
+	include/alibabacloud/dbfs/model/DeleteSnapshotResult.h
+	include/alibabacloud/dbfs/model/DeleteTagsBatchRequest.h
+	include/alibabacloud/dbfs/model/DeleteTagsBatchResult.h
 	include/alibabacloud/dbfs/model/DetachDbfsRequest.h
 	include/alibabacloud/dbfs/model/DetachDbfsResult.h
+	include/alibabacloud/dbfs/model/GenerateUpgradeRecordRequest.h
+	include/alibabacloud/dbfs/model/GenerateUpgradeRecordResult.h
 	include/alibabacloud/dbfs/model/GetDbfsRequest.h
 	include/alibabacloud/dbfs/model/GetDbfsResult.h
+	include/alibabacloud/dbfs/model/GetServiceLinkedRoleRequest.h
+	include/alibabacloud/dbfs/model/GetServiceLinkedRoleResult.h
+	include/alibabacloud/dbfs/model/GetSynchronizConstantsRequest.h
+	include/alibabacloud/dbfs/model/GetSynchronizConstantsResult.h
+	include/alibabacloud/dbfs/model/InsertSynchronizConstantsRequest.h
+	include/alibabacloud/dbfs/model/InsertSynchronizConstantsResult.h
+	include/alibabacloud/dbfs/model/ListConstantsRequest.h
+	include/alibabacloud/dbfs/model/ListConstantsResult.h
 	include/alibabacloud/dbfs/model/ListDbfsRequest.h
 	include/alibabacloud/dbfs/model/ListDbfsResult.h
+	include/alibabacloud/dbfs/model/ListSnapshotRequest.h
+	include/alibabacloud/dbfs/model/ListSnapshotResult.h
+	include/alibabacloud/dbfs/model/ListTagKeysRequest.h
+	include/alibabacloud/dbfs/model/ListTagKeysResult.h
+	include/alibabacloud/dbfs/model/ListTagValuesRequest.h
+	include/alibabacloud/dbfs/model/ListTagValuesResult.h
+	include/alibabacloud/dbfs/model/ListTaskRequest.h
+	include/alibabacloud/dbfs/model/ListTaskResult.h
+	include/alibabacloud/dbfs/model/OpreateConstantsRequest.h
+	include/alibabacloud/dbfs/model/OpreateConstantsResult.h
+	include/alibabacloud/dbfs/model/PublishUpgradeTaskRequest.h
+	include/alibabacloud/dbfs/model/PublishUpgradeTaskResult.h
+	include/alibabacloud/dbfs/model/RenameDbfsRequest.h
+	include/alibabacloud/dbfs/model/RenameDbfsResult.h
+	include/alibabacloud/dbfs/model/ResetDbfsRequest.h
+	include/alibabacloud/dbfs/model/ResetDbfsResult.h
 	include/alibabacloud/dbfs/model/ResizeDbfsRequest.h
-	include/alibabacloud/dbfs/model/ResizeDbfsResult.h )
+	include/alibabacloud/dbfs/model/ResizeDbfsResult.h
+	include/alibabacloud/dbfs/model/StopUpgradeTaskRequest.h
+	include/alibabacloud/dbfs/model/StopUpgradeTaskResult.h
+	include/alibabacloud/dbfs/model/TagDbfsRequest.h
+	include/alibabacloud/dbfs/model/TagDbfsResult.h
+	include/alibabacloud/dbfs/model/UpdateConstantsRequest.h
+	include/alibabacloud/dbfs/model/UpdateConstantsResult.h
+	include/alibabacloud/dbfs/model/UpdateTaskRequest.h
+	include/alibabacloud/dbfs/model/UpdateTaskResult.h )
 
 set(dbfs_src 
 	src/DBFSClient.cc
+	src/model/AddTagsBatchRequest.cc
+	src/model/AddTagsBatchResult.cc
 	src/model/AttachDbfsRequest.cc
 	src/model/AttachDbfsResult.cc
+	src/model/CreateConstantsRequest.cc
+	src/model/CreateConstantsResult.cc
 	src/model/CreateDbfsRequest.cc
 	src/model/CreateDbfsResult.cc
+	src/model/CreateServiceLinkedRoleRequest.cc
+	src/model/CreateServiceLinkedRoleResult.cc
+	src/model/CreateSnapshotRequest.cc
+	src/model/CreateSnapshotResult.cc
+	src/model/DbfsRecordRequest.cc
+	src/model/DbfsRecordResult.cc
+	src/model/DeleteConstantsRequest.cc
+	src/model/DeleteConstantsResult.cc
 	src/model/DeleteDbfsRequest.cc
 	src/model/DeleteDbfsResult.cc
+	src/model/DeleteSnapshotRequest.cc
+	src/model/DeleteSnapshotResult.cc
+	src/model/DeleteTagsBatchRequest.cc
+	src/model/DeleteTagsBatchResult.cc
 	src/model/DetachDbfsRequest.cc
 	src/model/DetachDbfsResult.cc
+	src/model/GenerateUpgradeRecordRequest.cc
+	src/model/GenerateUpgradeRecordResult.cc
 	src/model/GetDbfsRequest.cc
 	src/model/GetDbfsResult.cc
+	src/model/GetServiceLinkedRoleRequest.cc
+	src/model/GetServiceLinkedRoleResult.cc
+	src/model/GetSynchronizConstantsRequest.cc
+	src/model/GetSynchronizConstantsResult.cc
+	src/model/InsertSynchronizConstantsRequest.cc
+	src/model/InsertSynchronizConstantsResult.cc
+	src/model/ListConstantsRequest.cc
+	src/model/ListConstantsResult.cc
 	src/model/ListDbfsRequest.cc
 	src/model/ListDbfsResult.cc
+	src/model/ListSnapshotRequest.cc
+	src/model/ListSnapshotResult.cc
+	src/model/ListTagKeysRequest.cc
+	src/model/ListTagKeysResult.cc
+	src/model/ListTagValuesRequest.cc
+	src/model/ListTagValuesResult.cc
+	src/model/ListTaskRequest.cc
+	src/model/ListTaskResult.cc
+	src/model/OpreateConstantsRequest.cc
+	src/model/OpreateConstantsResult.cc
+	src/model/PublishUpgradeTaskRequest.cc
+	src/model/PublishUpgradeTaskResult.cc
+	src/model/RenameDbfsRequest.cc
+	src/model/RenameDbfsResult.cc
+	src/model/ResetDbfsRequest.cc
+	src/model/ResetDbfsResult.cc
 	src/model/ResizeDbfsRequest.cc
-	src/model/ResizeDbfsResult.cc )
+	src/model/ResizeDbfsResult.cc
+	src/model/StopUpgradeTaskRequest.cc
+	src/model/StopUpgradeTaskResult.cc
+	src/model/TagDbfsRequest.cc
+	src/model/TagDbfsResult.cc
+	src/model/UpdateConstantsRequest.cc
+	src/model/UpdateConstantsResult.cc
+	src/model/UpdateTaskRequest.cc
+	src/model/UpdateTaskResult.cc )
 
 add_library(dbfs ${LIB_TYPE}
 	${dbfs_public_header}

dbfs/include/alibabacloud/dbfs/DBFSClient.h

@@ -22,20 +22,70 @@
 #include <alibabacloud/core/EndpointProvider.h>
 #include <alibabacloud/core/RpcServiceClient.h>
 #include "DBFSExport.h"
+#include "model/AddTagsBatchRequest.h"
+#include "model/AddTagsBatchResult.h"
 #include "model/AttachDbfsRequest.h"
 #include "model/AttachDbfsResult.h"
+#include "model/CreateConstantsRequest.h"
+#include "model/CreateConstantsResult.h"
 #include "model/CreateDbfsRequest.h"
 #include "model/CreateDbfsResult.h"
+#include "model/CreateServiceLinkedRoleRequest.h"
+#include "model/CreateServiceLinkedRoleResult.h"
+#include "model/CreateSnapshotRequest.h"
+#include "model/CreateSnapshotResult.h"
+#include "model/DbfsRecordRequest.h"
+#include "model/DbfsRecordResult.h"
+#include "model/DeleteConstantsRequest.h"
+#include "model/DeleteConstantsResult.h"
 #include "model/DeleteDbfsRequest.h"
 #include "model/DeleteDbfsResult.h"
+#include "model/DeleteSnapshotRequest.h"
+#include "model/DeleteSnapshotResult.h"
+#include "model/DeleteTagsBatchRequest.h"
+#include "model/DeleteTagsBatchResult.h"
 #include "model/DetachDbfsRequest.h"
 #include "model/DetachDbfsResult.h"
+#include "model/GenerateUpgradeRecordRequest.h"
+#include "model/GenerateUpgradeRecordResult.h"
 #include "model/GetDbfsRequest.h"
 #include "model/GetDbfsResult.h"
+#include "model/GetServiceLinkedRoleRequest.h"
+#include "model/GetServiceLinkedRoleResult.h"
+#include "model/GetSynchronizConstantsRequest.h"
+#include "model/GetSynchronizConstantsResult.h"
+#include "model/InsertSynchronizConstantsRequest.h"
+#include "model/InsertSynchronizConstantsResult.h"
+#include "model/ListConstantsRequest.h"
+#include "model/ListConstantsResult.h"
 #include "model/ListDbfsRequest.h"
 #include "model/ListDbfsResult.h"
+#include "model/ListSnapshotRequest.h"
+#include "model/ListSnapshotResult.h"
+#include "model/ListTagKeysRequest.h"
+#include "model/ListTagKeysResult.h"
+#include "model/ListTagValuesRequest.h"
+#include "model/ListTagValuesResult.h"
+#include "model/ListTaskRequest.h"
+#include "model/ListTaskResult.h"
+#include "model/OpreateConstantsRequest.h"
+#include "model/OpreateConstantsResult.h"
+#include "model/PublishUpgradeTaskRequest.h"
+#include "model/PublishUpgradeTaskResult.h"
+#include "model/RenameDbfsRequest.h"
+#include "model/RenameDbfsResult.h"
+#include "model/ResetDbfsRequest.h"
+#include "model/ResetDbfsResult.h"
 #include "model/ResizeDbfsRequest.h"
 #include "model/ResizeDbfsResult.h"
+#include "model/StopUpgradeTaskRequest.h"
+#include "model/StopUpgradeTaskResult.h"
+#include "model/TagDbfsRequest.h"
+#include "model/TagDbfsResult.h"
+#include "model/UpdateConstantsRequest.h"
+#include "model/UpdateConstantsResult.h"
+#include "model/UpdateTaskRequest.h"
+#include "model/UpdateTaskResult.h"
 
 
 namespace AlibabaCloud
@@ -45,53 +95,203 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_DBFS_EXPORT DBFSClient : public RpcServiceClient
 		{
 		public:
+			typedef Outcome<Error, Model::AddTagsBatchResult> AddTagsBatchOutcome;
+			typedef std::future<AddTagsBatchOutcome> AddTagsBatchOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::AddTagsBatchRequest&, const AddTagsBatchOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddTagsBatchAsyncHandler;
 			typedef Outcome<Error, Model::AttachDbfsResult> AttachDbfsOutcome;
 			typedef std::future<AttachDbfsOutcome> AttachDbfsOutcomeCallable;
 			typedef std::function<void(const DBFSClient*, const Model::AttachDbfsRequest&, const AttachDbfsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachDbfsAsyncHandler;
+			typedef Outcome<Error, Model::CreateConstantsResult> CreateConstantsOutcome;
+			typedef std::future<CreateConstantsOutcome> CreateConstantsOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::CreateConstantsRequest&, const CreateConstantsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateConstantsAsyncHandler;
 			typedef Outcome<Error, Model::CreateDbfsResult> CreateDbfsOutcome;
 			typedef std::future<CreateDbfsOutcome> CreateDbfsOutcomeCallable;
 			typedef std::function<void(const DBFSClient*, const Model::CreateDbfsRequest&, const CreateDbfsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDbfsAsyncHandler;
+			typedef Outcome<Error, Model::CreateServiceLinkedRoleResult> CreateServiceLinkedRoleOutcome;
+			typedef std::future<CreateServiceLinkedRoleOutcome> CreateServiceLinkedRoleOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::CreateServiceLinkedRoleRequest&, const CreateServiceLinkedRoleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateServiceLinkedRoleAsyncHandler;
+			typedef Outcome<Error, Model::CreateSnapshotResult> CreateSnapshotOutcome;
+			typedef std::future<CreateSnapshotOutcome> CreateSnapshotOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::CreateSnapshotRequest&, const CreateSnapshotOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateSnapshotAsyncHandler;
+			typedef Outcome<Error, Model::DbfsRecordResult> DbfsRecordOutcome;
+			typedef std::future<DbfsRecordOutcome> DbfsRecordOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::DbfsRecordRequest&, const DbfsRecordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DbfsRecordAsyncHandler;
+			typedef Outcome<Error, Model::DeleteConstantsResult> DeleteConstantsOutcome;
+			typedef std::future<DeleteConstantsOutcome> DeleteConstantsOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::DeleteConstantsRequest&, const DeleteConstantsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteConstantsAsyncHandler;
 			typedef Outcome<Error, Model::DeleteDbfsResult> DeleteDbfsOutcome;
 			typedef std::future<DeleteDbfsOutcome> DeleteDbfsOutcomeCallable;
 			typedef std::function<void(const DBFSClient*, const Model::DeleteDbfsRequest&, const DeleteDbfsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDbfsAsyncHandler;
+			typedef Outcome<Error, Model::DeleteSnapshotResult> DeleteSnapshotOutcome;
+			typedef std::future<DeleteSnapshotOutcome> DeleteSnapshotOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::DeleteSnapshotRequest&, const DeleteSnapshotOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSnapshotAsyncHandler;
+			typedef Outcome<Error, Model::DeleteTagsBatchResult> DeleteTagsBatchOutcome;
+			typedef std::future<DeleteTagsBatchOutcome> DeleteTagsBatchOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::DeleteTagsBatchRequest&, const DeleteTagsBatchOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTagsBatchAsyncHandler;
 			typedef Outcome<Error, Model::DetachDbfsResult> DetachDbfsOutcome;
 			typedef std::future<DetachDbfsOutcome> DetachDbfsOutcomeCallable;
 			typedef std::function<void(const DBFSClient*, const Model::DetachDbfsRequest&, const DetachDbfsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachDbfsAsyncHandler;
+			typedef Outcome<Error, Model::GenerateUpgradeRecordResult> GenerateUpgradeRecordOutcome;
+			typedef std::future<GenerateUpgradeRecordOutcome> GenerateUpgradeRecordOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::GenerateUpgradeRecordRequest&, const GenerateUpgradeRecordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateUpgradeRecordAsyncHandler;
 			typedef Outcome<Error, Model::GetDbfsResult> GetDbfsOutcome;
 			typedef std::future<GetDbfsOutcome> GetDbfsOutcomeCallable;
 			typedef std::function<void(const DBFSClient*, const Model::GetDbfsRequest&, const GetDbfsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDbfsAsyncHandler;
+			typedef Outcome<Error, Model::GetServiceLinkedRoleResult> GetServiceLinkedRoleOutcome;
+			typedef std::future<GetServiceLinkedRoleOutcome> GetServiceLinkedRoleOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::GetServiceLinkedRoleRequest&, const GetServiceLinkedRoleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetServiceLinkedRoleAsyncHandler;
+			typedef Outcome<Error, Model::GetSynchronizConstantsResult> GetSynchronizConstantsOutcome;
+			typedef std::future<GetSynchronizConstantsOutcome> GetSynchronizConstantsOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::GetSynchronizConstantsRequest&, const GetSynchronizConstantsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetSynchronizConstantsAsyncHandler;
+			typedef Outcome<Error, Model::InsertSynchronizConstantsResult> InsertSynchronizConstantsOutcome;
+			typedef std::future<InsertSynchronizConstantsOutcome> InsertSynchronizConstantsOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::InsertSynchronizConstantsRequest&, const InsertSynchronizConstantsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> InsertSynchronizConstantsAsyncHandler;
+			typedef Outcome<Error, Model::ListConstantsResult> ListConstantsOutcome;
+			typedef std::future<ListConstantsOutcome> ListConstantsOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::ListConstantsRequest&, const ListConstantsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListConstantsAsyncHandler;
 			typedef Outcome<Error, Model::ListDbfsResult> ListDbfsOutcome;
 			typedef std::future<ListDbfsOutcome> ListDbfsOutcomeCallable;
 			typedef std::function<void(const DBFSClient*, const Model::ListDbfsRequest&, const ListDbfsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDbfsAsyncHandler;
+			typedef Outcome<Error, Model::ListSnapshotResult> ListSnapshotOutcome;
+			typedef std::future<ListSnapshotOutcome> ListSnapshotOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::ListSnapshotRequest&, const ListSnapshotOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSnapshotAsyncHandler;
+			typedef Outcome<Error, Model::ListTagKeysResult> ListTagKeysOutcome;
+			typedef std::future<ListTagKeysOutcome> ListTagKeysOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::ListTagKeysRequest&, const ListTagKeysOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagKeysAsyncHandler;
+			typedef Outcome<Error, Model::ListTagValuesResult> ListTagValuesOutcome;
+			typedef std::future<ListTagValuesOutcome> ListTagValuesOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::ListTagValuesRequest&, const ListTagValuesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagValuesAsyncHandler;
+			typedef Outcome<Error, Model::ListTaskResult> ListTaskOutcome;
+			typedef std::future<ListTaskOutcome> ListTaskOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::ListTaskRequest&, const ListTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTaskAsyncHandler;
+			typedef Outcome<Error, Model::OpreateConstantsResult> OpreateConstantsOutcome;
+			typedef std::future<OpreateConstantsOutcome> OpreateConstantsOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::OpreateConstantsRequest&, const OpreateConstantsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> OpreateConstantsAsyncHandler;
+			typedef Outcome<Error, Model::PublishUpgradeTaskResult> PublishUpgradeTaskOutcome;
+			typedef std::future<PublishUpgradeTaskOutcome> PublishUpgradeTaskOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::PublishUpgradeTaskRequest&, const PublishUpgradeTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PublishUpgradeTaskAsyncHandler;
+			typedef Outcome<Error, Model::RenameDbfsResult> RenameDbfsOutcome;
+			typedef std::future<RenameDbfsOutcome> RenameDbfsOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::RenameDbfsRequest&, const RenameDbfsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RenameDbfsAsyncHandler;
+			typedef Outcome<Error, Model::ResetDbfsResult> ResetDbfsOutcome;
+			typedef std::future<ResetDbfsOutcome> ResetDbfsOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::ResetDbfsRequest&, const ResetDbfsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResetDbfsAsyncHandler;
 			typedef Outcome<Error, Model::ResizeDbfsResult> ResizeDbfsOutcome;
 			typedef std::future<ResizeDbfsOutcome> ResizeDbfsOutcomeCallable;
 			typedef std::function<void(const DBFSClient*, const Model::ResizeDbfsRequest&, const ResizeDbfsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResizeDbfsAsyncHandler;
+			typedef Outcome<Error, Model::StopUpgradeTaskResult> StopUpgradeTaskOutcome;
+			typedef std::future<StopUpgradeTaskOutcome> StopUpgradeTaskOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::StopUpgradeTaskRequest&, const StopUpgradeTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopUpgradeTaskAsyncHandler;
+			typedef Outcome<Error, Model::TagDbfsResult> TagDbfsOutcome;
+			typedef std::future<TagDbfsOutcome> TagDbfsOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::TagDbfsRequest&, const TagDbfsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TagDbfsAsyncHandler;
+			typedef Outcome<Error, Model::UpdateConstantsResult> UpdateConstantsOutcome;
+			typedef std::future<UpdateConstantsOutcome> UpdateConstantsOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::UpdateConstantsRequest&, const UpdateConstantsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateConstantsAsyncHandler;
+			typedef Outcome<Error, Model::UpdateTaskResult> UpdateTaskOutcome;
+			typedef std::future<UpdateTaskOutcome> UpdateTaskOutcomeCallable;
+			typedef std::function<void(const DBFSClient*, const Model::UpdateTaskRequest&, const UpdateTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateTaskAsyncHandler;
 
 			DBFSClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			DBFSClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
 			DBFSClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
 			~DBFSClient();
+			AddTagsBatchOutcome addTagsBatch(const Model::AddTagsBatchRequest &request)const;
+			void addTagsBatchAsync(const Model::AddTagsBatchRequest& request, const AddTagsBatchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddTagsBatchOutcomeCallable addTagsBatchCallable(const Model::AddTagsBatchRequest& request) const;
 			AttachDbfsOutcome attachDbfs(const Model::AttachDbfsRequest &request)const;
 			void attachDbfsAsync(const Model::AttachDbfsRequest& request, const AttachDbfsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AttachDbfsOutcomeCallable attachDbfsCallable(const Model::AttachDbfsRequest& request) const;
+			CreateConstantsOutcome createConstants(const Model::CreateConstantsRequest &request)const;
+			void createConstantsAsync(const Model::CreateConstantsRequest& request, const CreateConstantsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateConstantsOutcomeCallable createConstantsCallable(const Model::CreateConstantsRequest& request) const;
 			CreateDbfsOutcome createDbfs(const Model::CreateDbfsRequest &request)const;
 			void createDbfsAsync(const Model::CreateDbfsRequest& request, const CreateDbfsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateDbfsOutcomeCallable createDbfsCallable(const Model::CreateDbfsRequest& request) const;
+			CreateServiceLinkedRoleOutcome createServiceLinkedRole(const Model::CreateServiceLinkedRoleRequest &request)const;
+			void createServiceLinkedRoleAsync(const Model::CreateServiceLinkedRoleRequest& request, const CreateServiceLinkedRoleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateServiceLinkedRoleOutcomeCallable createServiceLinkedRoleCallable(const Model::CreateServiceLinkedRoleRequest& request) const;
+			CreateSnapshotOutcome createSnapshot(const Model::CreateSnapshotRequest &request)const;
+			void createSnapshotAsync(const Model::CreateSnapshotRequest& request, const CreateSnapshotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateSnapshotOutcomeCallable createSnapshotCallable(const Model::CreateSnapshotRequest& request) const;
+			DbfsRecordOutcome dbfsRecord(const Model::DbfsRecordRequest &request)const;
+			void dbfsRecordAsync(const Model::DbfsRecordRequest& request, const DbfsRecordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DbfsRecordOutcomeCallable dbfsRecordCallable(const Model::DbfsRecordRequest& request) const;
+			DeleteConstantsOutcome deleteConstants(const Model::DeleteConstantsRequest &request)const;
+			void deleteConstantsAsync(const Model::DeleteConstantsRequest& request, const DeleteConstantsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteConstantsOutcomeCallable deleteConstantsCallable(const Model::DeleteConstantsRequest& request) const;
 			DeleteDbfsOutcome deleteDbfs(const Model::DeleteDbfsRequest &request)const;
 			void deleteDbfsAsync(const Model::DeleteDbfsRequest& request, const DeleteDbfsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteDbfsOutcomeCallable deleteDbfsCallable(const Model::DeleteDbfsRequest& request) const;
+			DeleteSnapshotOutcome deleteSnapshot(const Model::DeleteSnapshotRequest &request)const;
+			void deleteSnapshotAsync(const Model::DeleteSnapshotRequest& request, const DeleteSnapshotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteSnapshotOutcomeCallable deleteSnapshotCallable(const Model::DeleteSnapshotRequest& request) const;
+			DeleteTagsBatchOutcome deleteTagsBatch(const Model::DeleteTagsBatchRequest &request)const;
+			void deleteTagsBatchAsync(const Model::DeleteTagsBatchRequest& request, const DeleteTagsBatchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteTagsBatchOutcomeCallable deleteTagsBatchCallable(const Model::DeleteTagsBatchRequest& request) const;
 			DetachDbfsOutcome detachDbfs(const Model::DetachDbfsRequest &request)const;
 			void detachDbfsAsync(const Model::DetachDbfsRequest& request, const DetachDbfsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DetachDbfsOutcomeCallable detachDbfsCallable(const Model::DetachDbfsRequest& request) const;
+			GenerateUpgradeRecordOutcome generateUpgradeRecord(const Model::GenerateUpgradeRecordRequest &request)const;
+			void generateUpgradeRecordAsync(const Model::GenerateUpgradeRecordRequest& request, const GenerateUpgradeRecordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GenerateUpgradeRecordOutcomeCallable generateUpgradeRecordCallable(const Model::GenerateUpgradeRecordRequest& request) const;
 			GetDbfsOutcome getDbfs(const Model::GetDbfsRequest &request)const;
 			void getDbfsAsync(const Model::GetDbfsRequest& request, const GetDbfsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetDbfsOutcomeCallable getDbfsCallable(const Model::GetDbfsRequest& request) const;
+			GetServiceLinkedRoleOutcome getServiceLinkedRole(const Model::GetServiceLinkedRoleRequest &request)const;
+			void getServiceLinkedRoleAsync(const Model::GetServiceLinkedRoleRequest& request, const GetServiceLinkedRoleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetServiceLinkedRoleOutcomeCallable getServiceLinkedRoleCallable(const Model::GetServiceLinkedRoleRequest& request) const;
+			GetSynchronizConstantsOutcome getSynchronizConstants(const Model::GetSynchronizConstantsRequest &request)const;
+			void getSynchronizConstantsAsync(const Model::GetSynchronizConstantsRequest& request, const GetSynchronizConstantsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetSynchronizConstantsOutcomeCallable getSynchronizConstantsCallable(const Model::GetSynchronizConstantsRequest& request) const;
+			InsertSynchronizConstantsOutcome insertSynchronizConstants(const Model::InsertSynchronizConstantsRequest &request)const;
+			void insertSynchronizConstantsAsync(const Model::InsertSynchronizConstantsRequest& request, const InsertSynchronizConstantsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			InsertSynchronizConstantsOutcomeCallable insertSynchronizConstantsCallable(const Model::InsertSynchronizConstantsRequest& request) const;
+			ListConstantsOutcome listConstants(const Model::ListConstantsRequest &request)const;
+			void listConstantsAsync(const Model::ListConstantsRequest& request, const ListConstantsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListConstantsOutcomeCallable listConstantsCallable(const Model::ListConstantsRequest& request) const;
 			ListDbfsOutcome listDbfs(const Model::ListDbfsRequest &request)const;
 			void listDbfsAsync(const Model::ListDbfsRequest& request, const ListDbfsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListDbfsOutcomeCallable listDbfsCallable(const Model::ListDbfsRequest& request) const;
+			ListSnapshotOutcome listSnapshot(const Model::ListSnapshotRequest &request)const;
+			void listSnapshotAsync(const Model::ListSnapshotRequest& request, const ListSnapshotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListSnapshotOutcomeCallable listSnapshotCallable(const Model::ListSnapshotRequest& request) const;
+			ListTagKeysOutcome listTagKeys(const Model::ListTagKeysRequest &request)const;
+			void listTagKeysAsync(const Model::ListTagKeysRequest& request, const ListTagKeysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListTagKeysOutcomeCallable listTagKeysCallable(const Model::ListTagKeysRequest& request) const;
+			ListTagValuesOutcome listTagValues(const Model::ListTagValuesRequest &request)const;
+			void listTagValuesAsync(const Model::ListTagValuesRequest& request, const ListTagValuesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListTagValuesOutcomeCallable listTagValuesCallable(const Model::ListTagValuesRequest& request) const;
+			ListTaskOutcome listTask(const Model::ListTaskRequest &request)const;
+			void listTaskAsync(const Model::ListTaskRequest& request, const ListTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListTaskOutcomeCallable listTaskCallable(const Model::ListTaskRequest& request) const;
+			OpreateConstantsOutcome opreateConstants(const Model::OpreateConstantsRequest &request)const;
+			void opreateConstantsAsync(const Model::OpreateConstantsRequest& request, const OpreateConstantsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			OpreateConstantsOutcomeCallable opreateConstantsCallable(const Model::OpreateConstantsRequest& request) const;
+			PublishUpgradeTaskOutcome publishUpgradeTask(const Model::PublishUpgradeTaskRequest &request)const;
+			void publishUpgradeTaskAsync(const Model::PublishUpgradeTaskRequest& request, const PublishUpgradeTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PublishUpgradeTaskOutcomeCallable publishUpgradeTaskCallable(const Model::PublishUpgradeTaskRequest& request) const;
+			RenameDbfsOutcome renameDbfs(const Model::RenameDbfsRequest &request)const;
+			void renameDbfsAsync(const Model::RenameDbfsRequest& request, const RenameDbfsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RenameDbfsOutcomeCallable renameDbfsCallable(const Model::RenameDbfsRequest& request) const;
+			ResetDbfsOutcome resetDbfs(const Model::ResetDbfsRequest &request)const;
+			void resetDbfsAsync(const Model::ResetDbfsRequest& request, const ResetDbfsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ResetDbfsOutcomeCallable resetDbfsCallable(const Model::ResetDbfsRequest& request) const;
 			ResizeDbfsOutcome resizeDbfs(const Model::ResizeDbfsRequest &request)const;
 			void resizeDbfsAsync(const Model::ResizeDbfsRequest& request, const ResizeDbfsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ResizeDbfsOutcomeCallable resizeDbfsCallable(const Model::ResizeDbfsRequest& request) const;
+			StopUpgradeTaskOutcome stopUpgradeTask(const Model::StopUpgradeTaskRequest &request)const;
+			void stopUpgradeTaskAsync(const Model::StopUpgradeTaskRequest& request, const StopUpgradeTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopUpgradeTaskOutcomeCallable stopUpgradeTaskCallable(const Model::StopUpgradeTaskRequest& request) const;
+			TagDbfsOutcome tagDbfs(const Model::TagDbfsRequest &request)const;
+			void tagDbfsAsync(const Model::TagDbfsRequest& request, const TagDbfsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			TagDbfsOutcomeCallable tagDbfsCallable(const Model::TagDbfsRequest& request) const;
+			UpdateConstantsOutcome updateConstants(const Model::UpdateConstantsRequest &request)const;
+			void updateConstantsAsync(const Model::UpdateConstantsRequest& request, const UpdateConstantsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateConstantsOutcomeCallable updateConstantsCallable(const Model::UpdateConstantsRequest& request) const;
+			UpdateTaskOutcome updateTask(const Model::UpdateTaskRequest &request)const;
+			void updateTaskAsync(const Model::UpdateTaskRequest& request, const UpdateTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateTaskOutcomeCallable updateTaskCallable(const Model::UpdateTaskRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

dbfs/include/alibabacloud/dbfs/model/AddTagsBatchRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DBFS_MODEL_ADDTAGSBATCHREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_ADDTAGSBATCHREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT AddTagsBatchRequest : public RpcServiceRequest
+			{
+
+			public:
+				AddTagsBatchRequest();
+				~AddTagsBatchRequest();
+
+				std::string getDbfsList()const;
+				void setDbfsList(const std::string& dbfsList);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getTags()const;
+				void setTags(const std::string& tags);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+
+            private:
+				std::string dbfsList_;
+				std::string clientToken_;
+				std::string tags_;
+				std::string regionId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_ADDTAGSBATCHREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/AddTagsBatchResult.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_DBFS_MODEL_ADDTAGSBATCHRESULT_H_
+#define ALIBABACLOUD_DBFS_MODEL_ADDTAGSBATCHRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT AddTagsBatchResult : public ServiceResult
+			{
+			public:
+
+
+				AddTagsBatchResult();
+				explicit AddTagsBatchResult(const std::string &payload);
+				~AddTagsBatchResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_ADDTAGSBATCHRESULT_H_

dbfs/include/alibabacloud/dbfs/model/AttachDbfsRequest.h

@@ -39,12 +39,15 @@ namespace AlibabaCloud
 				void setECSInstanceId(const std::string& eCSInstanceId);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
+				std::string getServerUrl()const;
+				void setServerUrl(const std::string& serverUrl);
 				std::string getFsId()const;
 				void setFsId(const std::string& fsId);
 
             private:
 				std::string eCSInstanceId_;
 				std::string regionId_;
+				std::string serverUrl_;
 				std::string fsId_;
 
 			};

dbfs/include/alibabacloud/dbfs/model/CreateConstantsRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DBFS_MODEL_CREATECONSTANTSREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_CREATECONSTANTSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT CreateConstantsRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateConstantsRequest();
+				~CreateConstantsRequest();
+
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getConstantsData()const;
+				void setConstantsData(const std::string& constantsData);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+
+            private:
+				int pageNumber_;
+				std::string regionId_;
+				std::string constantsData_;
+				int pageSize_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_CREATECONSTANTSREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/CreateConstantsResult.h

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

dbfs/include/alibabacloud/dbfs/model/CreateDbfsRequest.h

@@ -37,24 +37,48 @@ namespace AlibabaCloud
 
 				int getSizeG()const;
 				void setSizeG(int sizeG);
+				std::string getSnapshotId()const;
+				void setSnapshotId(const std::string& snapshotId);
 				std::string getClientToken()const;
 				void setClientToken(const std::string& clientToken);
+				std::string getUsedScene()const;
+				void setUsedScene(const std::string& usedScene);
 				std::string getFsName()const;
 				void setFsName(const std::string& fsName);
+				int getRaidStripeUnitNumber()const;
+				void setRaidStripeUnitNumber(int raidStripeUnitNumber);
+				bool getEncryption()const;
+				void setEncryption(bool encryption);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
+				std::string getPerformanceLevel()const;
+				void setPerformanceLevel(const std::string& performanceLevel);
+				bool getEnableRaid()const;
+				void setEnableRaid(bool enableRaid);
+				bool getDeleteSnapshot()const;
+				void setDeleteSnapshot(bool deleteSnapshot);
 				std::string getZoneId()const;
 				void setZoneId(const std::string& zoneId);
 				std::string getCategory()const;
 				void setCategory(const std::string& category);
+				std::string getKMSKeyId()const;
+				void setKMSKeyId(const std::string& kMSKeyId);
 
             private:
 				int sizeG_;
+				std::string snapshotId_;
 				std::string clientToken_;
+				std::string usedScene_;
 				std::string fsName_;
+				int raidStripeUnitNumber_;
+				bool encryption_;
 				std::string regionId_;
+				std::string performanceLevel_;
+				bool enableRaid_;
+				bool deleteSnapshot_;
 				std::string zoneId_;
 				std::string category_;
+				std::string kMSKeyId_;
 
 			};
 		}

dbfs/include/alibabacloud/dbfs/model/CreateServiceLinkedRoleRequest.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_DBFS_MODEL_CREATESERVICELINKEDROLEREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_CREATESERVICELINKEDROLEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT CreateServiceLinkedRoleRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateServiceLinkedRoleRequest();
+				~CreateServiceLinkedRoleRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+
+            private:
+				std::string clientToken_;
+				std::string regionId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_CREATESERVICELINKEDROLEREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/CreateServiceLinkedRoleResult.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_DBFS_MODEL_CREATESERVICELINKEDROLERESULT_H_
+#define ALIBABACLOUD_DBFS_MODEL_CREATESERVICELINKEDROLERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT CreateServiceLinkedRoleResult : public ServiceResult
+			{
+			public:
+
+
+				CreateServiceLinkedRoleResult();
+				explicit CreateServiceLinkedRoleResult(const std::string &payload);
+				~CreateServiceLinkedRoleResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_CREATESERVICELINKEDROLERESULT_H_

dbfs/include/alibabacloud/dbfs/model/CreateSnapshotRequest.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_DBFS_MODEL_CREATESNAPSHOTREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_CREATESNAPSHOTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT CreateSnapshotRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateSnapshotRequest();
+				~CreateSnapshotRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				std::string getSnapshotName()const;
+				void setSnapshotName(const std::string& snapshotName);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getFsId()const;
+				void setFsId(const std::string& fsId);
+				int getRetentionDays()const;
+				void setRetentionDays(int retentionDays);
+
+            private:
+				std::string clientToken_;
+				std::string description_;
+				std::string snapshotName_;
+				std::string regionId_;
+				std::string fsId_;
+				int retentionDays_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_CREATESNAPSHOTREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/CreateSnapshotResult.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_DBFS_MODEL_CREATESNAPSHOTRESULT_H_
+#define ALIBABACLOUD_DBFS_MODEL_CREATESNAPSHOTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT CreateSnapshotResult : public ServiceResult
+			{
+			public:
+
+
+				CreateSnapshotResult();
+				explicit CreateSnapshotResult(const std::string &payload);
+				~CreateSnapshotResult();
+				std::string getSnapshotId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string snapshotId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_CREATESNAPSHOTRESULT_H_

dbfs/include/alibabacloud/dbfs/model/DbfsRecordRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DBFS_MODEL_DBFSRECORDREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_DBFSRECORDREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT DbfsRecordRequest : public RpcServiceRequest
+			{
+
+			public:
+				DbfsRecordRequest();
+				~DbfsRecordRequest();
+
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getBatchStrategyNo()const;
+				void setBatchStrategyNo(const std::string& batchStrategyNo);
+
+            private:
+				int pageNumber_;
+				std::string regionId_;
+				int pageSize_;
+				std::string batchStrategyNo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_DBFSRECORDREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/DbfsRecordResult.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_DBFS_MODEL_DBFSRECORDRESULT_H_
+#define ALIBABACLOUD_DBFS_MODEL_DBFSRECORDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT DbfsRecordResult : public ServiceResult
+			{
+			public:
+				struct RecordsItem
+				{
+					std::string targetVersion;
+					std::string accountId;
+					std::string taskId;
+					std::string zoneId;
+					std::string currentVersion;
+					long createTime;
+					std::string ecsId;
+					std::string taskErrorReason;
+					std::string batchStrategyNo;
+					long upgradeEndTime;
+					std::string state;
+					std::string dbfsId;
+					long updateTime;
+					long id;
+					std::string regionId;
+					long upgradeStartTime;
+					std::string isDel;
+					int taskExecutionCounts;
+				};
+
+
+				DbfsRecordResult();
+				explicit DbfsRecordResult(const std::string &payload);
+				~DbfsRecordResult();
+				std::vector<RecordsItem> getRecords()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<RecordsItem> records_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_DBFSRECORDRESULT_H_

dbfs/include/alibabacloud/dbfs/model/DeleteConstantsRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DBFS_MODEL_DELETECONSTANTSREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_DELETECONSTANTSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT DeleteConstantsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteConstantsRequest();
+				~DeleteConstantsRequest();
+
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getConstantsData()const;
+				void setConstantsData(const std::string& constantsData);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+
+            private:
+				int pageNumber_;
+				std::string regionId_;
+				std::string constantsData_;
+				int pageSize_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_DELETECONSTANTSREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/DeleteConstantsResult.h

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

dbfs/include/alibabacloud/dbfs/model/DeleteSnapshotRequest.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_DBFS_MODEL_DELETESNAPSHOTREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_DELETESNAPSHOTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT DeleteSnapshotRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteSnapshotRequest();
+				~DeleteSnapshotRequest();
+
+				std::string getSnapshotId()const;
+				void setSnapshotId(const std::string& snapshotId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				bool getForce()const;
+				void setForce(bool force);
+
+            private:
+				std::string snapshotId_;
+				std::string regionId_;
+				bool force_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_DELETESNAPSHOTREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/DeleteSnapshotResult.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_DBFS_MODEL_DELETESNAPSHOTRESULT_H_
+#define ALIBABACLOUD_DBFS_MODEL_DELETESNAPSHOTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT DeleteSnapshotResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteSnapshotResult();
+				explicit DeleteSnapshotResult(const std::string &payload);
+				~DeleteSnapshotResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_DELETESNAPSHOTRESULT_H_

dbfs/include/alibabacloud/dbfs/model/DeleteTagsBatchRequest.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_DBFS_MODEL_DELETETAGSBATCHREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_DELETETAGSBATCHREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT DeleteTagsBatchRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteTagsBatchRequest();
+				~DeleteTagsBatchRequest();
+
+				std::string getDbfsList()const;
+				void setDbfsList(const std::string& dbfsList);
+				std::string getTags()const;
+				void setTags(const std::string& tags);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+
+            private:
+				std::string dbfsList_;
+				std::string tags_;
+				std::string regionId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_DELETETAGSBATCHREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/DeleteTagsBatchResult.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_DBFS_MODEL_DELETETAGSBATCHRESULT_H_
+#define ALIBABACLOUD_DBFS_MODEL_DELETETAGSBATCHRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT DeleteTagsBatchResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteTagsBatchResult();
+				explicit DeleteTagsBatchResult(const std::string &payload);
+				~DeleteTagsBatchResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_DELETETAGSBATCHRESULT_H_

dbfs/include/alibabacloud/dbfs/model/GenerateUpgradeRecordRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DBFS_MODEL_GENERATEUPGRADERECORDREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_GENERATEUPGRADERECORDREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT GenerateUpgradeRecordRequest : public RpcServiceRequest
+			{
+
+			public:
+				GenerateUpgradeRecordRequest();
+				~GenerateUpgradeRecordRequest();
+
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getBatchStrategyList()const;
+				void setBatchStrategyList(const std::string& batchStrategyList);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+
+            private:
+				int pageNumber_;
+				std::string batchStrategyList_;
+				std::string regionId_;
+				int pageSize_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_GENERATEUPGRADERECORDREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/GenerateUpgradeRecordResult.h

@@ -0,0 +1,71 @@
+/*
+ * 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_DBFS_MODEL_GENERATEUPGRADERECORDRESULT_H_
+#define ALIBABACLOUD_DBFS_MODEL_GENERATEUPGRADERECORDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT GenerateUpgradeRecordResult : public ServiceResult
+			{
+			public:
+				struct RecordsItem
+				{
+					std::string targetVersion;
+					std::string accountId;
+					std::string taskId;
+					std::string zoneId;
+					std::string currentVersion;
+					long createTime;
+					std::string ecsId;
+					std::string taskErrorReason;
+					std::string batchStrategyNo;
+					long upgradeEndTime;
+					std::string state;
+					std::string dbfsId;
+					long updateTime;
+					long id;
+					std::string regionId;
+					long upgradeStartTime;
+					int taskExecutionCounts;
+				};
+
+
+				GenerateUpgradeRecordResult();
+				explicit GenerateUpgradeRecordResult(const std::string &payload);
+				~GenerateUpgradeRecordResult();
+				std::vector<RecordsItem> getRecords()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<RecordsItem> records_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_GENERATEUPGRADERECORDRESULT_H_

dbfs/include/alibabacloud/dbfs/model/GetDbfsResult.h

@@ -32,30 +32,58 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_DBFS_EXPORT GetDbfsResult : public ServiceResult
 			{
 			public:
-				struct Info
+				struct DBFSInfo
 				{
+					struct TagList
+					{
+						std::string tagKey;
+						int id;
+						std::string tagValue;
+					};
+					struct EcsListItem
+					{
+						std::string ecsId;
+					};
+					struct EbsListItem
+					{
+						int sizeG;
+						std::string ebsId;
+					};
 					std::string status;
+					std::string description;
 					std::string category;
-					std::string fsName;
+					std::string createdTime;
+					std::string kMSKeyId;
 					std::string zoneId;
+					bool enableRaid;
+					std::vector<EcsListItem> ecsList;
 					int sizeG;
-					std::string dBFSClusterId;
+					std::string performanceLevel;
 					std::string fsId;
+					std::string dBFSClusterId;
+					std::string payType;
+					bool encryption;
+					std::string lastUmountTime;
+					std::string fsName;
+					std::vector<EbsListItem> ebsList;
+					std::string usedScene;
+					int raidStrip;
+					std::string lastMountTime;
 					std::string regionId;
 					int attachNodeNumber;
-					std::string payType;
+					std::vector<TagList> tags;
 				};
 
 
 				GetDbfsResult();
 				explicit GetDbfsResult(const std::string &payload);
 				~GetDbfsResult();
-				std::vector<Info> getDBFSInfo()const;
+				DBFSInfo getDBFSInfo()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::vector<Info> dBFSInfo_;
+				DBFSInfo dBFSInfo_;
 
 			};
 		}

dbfs/include/alibabacloud/dbfs/model/GetServiceLinkedRoleRequest.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_DBFS_MODEL_GETSERVICELINKEDROLEREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_GETSERVICELINKEDROLEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT GetServiceLinkedRoleRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetServiceLinkedRoleRequest();
+				~GetServiceLinkedRoleRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+
+            private:
+				std::string regionId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_GETSERVICELINKEDROLEREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/GetServiceLinkedRoleResult.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_DBFS_MODEL_GETSERVICELINKEDROLERESULT_H_
+#define ALIBABACLOUD_DBFS_MODEL_GETSERVICELINKEDROLERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT GetServiceLinkedRoleResult : public ServiceResult
+			{
+			public:
+
+
+				GetServiceLinkedRoleResult();
+				explicit GetServiceLinkedRoleResult(const std::string &payload);
+				~GetServiceLinkedRoleResult();
+				std::string getAccountId()const;
+				bool getDbfsLinkedRole()const;
+				std::string getRegionId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string accountId_;
+				bool dbfsLinkedRole_;
+				std::string regionId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_GETSERVICELINKEDROLERESULT_H_

dbfs/include/alibabacloud/dbfs/model/GetSynchronizConstantsRequest.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_DBFS_MODEL_GETSYNCHRONIZCONSTANTSREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_GETSYNCHRONIZCONSTANTSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT GetSynchronizConstantsRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetSynchronizConstantsRequest();
+				~GetSynchronizConstantsRequest();
+
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+
+            private:
+				int pageNumber_;
+				std::string regionId_;
+				int pageSize_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_GETSYNCHRONIZCONSTANTSREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/GetSynchronizConstantsResult.h

@@ -0,0 +1,71 @@
+/*
+ * 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_DBFS_MODEL_GETSYNCHRONIZCONSTANTSRESULT_H_
+#define ALIBABACLOUD_DBFS_MODEL_GETSYNCHRONIZCONSTANTSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT GetSynchronizConstantsResult : public ServiceResult
+			{
+			public:
+
+
+				GetSynchronizConstantsResult();
+				explicit GetSynchronizConstantsResult(const std::string &payload);
+				~GetSynchronizConstantsResult();
+				long getTotalCount()const;
+				std::string getMasterData()const;
+				long getPageSize()const;
+				std::string getZoneData()const;
+				long getPageNumber()const;
+				std::string getAccessData()const;
+				std::string getProductCodeData()const;
+				std::string getOsversionData()const;
+				std::string getData()const;
+				std::string getRegionData()const;
+				std::string getEndpointData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				std::string masterData_;
+				long pageSize_;
+				std::string zoneData_;
+				long pageNumber_;
+				std::string accessData_;
+				std::string productCodeData_;
+				std::string osversionData_;
+				std::string data_;
+				std::string regionData_;
+				std::string endpointData_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_GETSYNCHRONIZCONSTANTSRESULT_H_

dbfs/include/alibabacloud/dbfs/model/InsertSynchronizConstantsRequest.h

@@ -0,0 +1,75 @@
+/*
+ * 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_DBFS_MODEL_INSERTSYNCHRONIZCONSTANTSREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_INSERTSYNCHRONIZCONSTANTSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT InsertSynchronizConstantsRequest : public RpcServiceRequest
+			{
+
+			public:
+				InsertSynchronizConstantsRequest();
+				~InsertSynchronizConstantsRequest();
+
+				std::string getZoneData()const;
+				void setZoneData(const std::string& zoneData);
+				std::string getOsversionData()const;
+				void setOsversionData(const std::string& osversionData);
+				std::string getEndpointData()const;
+				void setEndpointData(const std::string& endpointData);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getMasterData()const;
+				void setMasterData(const std::string& masterData);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getProductCodeData()const;
+				void setProductCodeData(const std::string& productCodeData);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getAccessData()const;
+				void setAccessData(const std::string& accessData);
+				std::string getRegionData()const;
+				void setRegionData(const std::string& regionData);
+
+            private:
+				std::string zoneData_;
+				std::string osversionData_;
+				std::string endpointData_;
+				int pageNumber_;
+				std::string masterData_;
+				std::string regionId_;
+				std::string productCodeData_;
+				int pageSize_;
+				std::string accessData_;
+				std::string regionData_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_INSERTSYNCHRONIZCONSTANTSREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/InsertSynchronizConstantsResult.h

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

dbfs/include/alibabacloud/dbfs/model/ListConstantsRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DBFS_MODEL_LISTCONSTANTSREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_LISTCONSTANTSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT ListConstantsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListConstantsRequest();
+				~ListConstantsRequest();
+
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getConstantsData()const;
+				void setConstantsData(const std::string& constantsData);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+
+            private:
+				int pageNumber_;
+				std::string regionId_;
+				std::string constantsData_;
+				int pageSize_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_LISTCONSTANTSREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/ListConstantsResult.h

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

dbfs/include/alibabacloud/dbfs/model/ListDbfsRequest.h

@@ -35,11 +35,32 @@ namespace AlibabaCloud
 				ListDbfsRequest();
 				~ListDbfsRequest();
 
+				std::string getSortType()const;
+				void setSortType(const std::string& sortType);
+				std::string getFilterValue()const;
+				void setFilterValue(const std::string& filterValue);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getTags()const;
+				void setTags(const std::string& tags);
+				std::string getFilterKey()const;
+				void setFilterKey(const std::string& filterKey);
+				std::string getSortKey()const;
+				void setSortKey(const std::string& sortKey);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
 
             private:
+				std::string sortType_;
+				std::string filterValue_;
+				int pageNumber_;
+				std::string tags_;
+				std::string filterKey_;
+				std::string sortKey_;
 				std::string regionId_;
+				int pageSize_;
 
 			};
 		}

dbfs/include/alibabacloud/dbfs/model/ListDbfsResult.h

@@ -34,16 +34,43 @@ namespace AlibabaCloud
 			public:
 				struct Info
 				{
+					struct TagList
+					{
+						std::string tagKey;
+						long id;
+						std::string tagValue;
+					};
+					struct EcsListItem
+					{
+						std::string ecsId;
+					};
+					struct EbsListItem
+					{
+						int sizeG;
+						std::string ebsId;
+					};
 					std::string status;
 					std::string category;
-					std::string fsName;
+					std::string createdTime;
+					std::string kMSKeyId;
 					std::string zoneId;
+					bool enableRaid;
+					std::vector<Info::EcsListItem> ecsList;
 					int sizeG;
-					std::string dBFSClusterId;
+					std::string performanceLevel;
 					std::string fsId;
+					std::string dBFSClusterId;
+					bool encryption;
+					std::string payType;
+					std::string lastUmountTime;
+					std::string fsName;
+					std::vector<Info::EbsListItem> ebsList;
+					std::string usedScene;
+					int raidStrip;
+					std::string lastMountTime;
 					std::string regionId;
 					int attachNodeNumber;
-					std::string payType;
+					std::vector<Info::TagList> tags;
 				};
 
 

dbfs/include/alibabacloud/dbfs/model/ListSnapshotRequest.h

@@ -0,0 +1,81 @@
+/*
+ * 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_DBFS_MODEL_LISTSNAPSHOTREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_LISTSNAPSHOTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT ListSnapshotRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListSnapshotRequest();
+				~ListSnapshotRequest();
+
+				std::string getSortType()const;
+				void setSortType(const std::string& sortType);
+				std::string getSnapshotIds()const;
+				void setSnapshotIds(const std::string& snapshotIds);
+				std::string getFilterValue()const;
+				void setFilterValue(const std::string& filterValue);
+				std::string getSnapshotName()const;
+				void setSnapshotName(const std::string& snapshotName);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getFilterKey()const;
+				void setFilterKey(const std::string& filterKey);
+				std::string getSortKey()const;
+				void setSortKey(const std::string& sortKey);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getFsId()const;
+				void setFsId(const std::string& fsId);
+				std::string getSnapshotType()const;
+				void setSnapshotType(const std::string& snapshotType);
+				std::string getStatus()const;
+				void setStatus(const std::string& status);
+
+            private:
+				std::string sortType_;
+				std::string snapshotIds_;
+				std::string filterValue_;
+				std::string snapshotName_;
+				int pageNumber_;
+				std::string filterKey_;
+				std::string sortKey_;
+				std::string regionId_;
+				int pageSize_;
+				std::string fsId_;
+				std::string snapshotType_;
+				std::string status_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_LISTSNAPSHOTREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/ListSnapshotResult.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DBFS_MODEL_LISTSNAPSHOTRESULT_H_
+#define ALIBABACLOUD_DBFS_MODEL_LISTSNAPSHOTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT ListSnapshotResult : public ServiceResult
+			{
+			public:
+				struct SnapshotsItem
+				{
+					std::string status;
+					std::string progress;
+					std::string category;
+					std::string description;
+					int retentionDays;
+					int sourceFsSize;
+					std::string snapshotName;
+					std::string sourceFsId;
+					std::string snapshotId;
+					std::string creationTime;
+					std::string lastModifiedTime;
+					std::string snapshotType;
+					int remainTime;
+				};
+
+
+				ListSnapshotResult();
+				explicit ListSnapshotResult(const std::string &payload);
+				~ListSnapshotResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<SnapshotsItem> getSnapshots()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<SnapshotsItem> snapshots_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_LISTSNAPSHOTRESULT_H_

dbfs/include/alibabacloud/dbfs/model/ListTagKeysRequest.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_DBFS_MODEL_LISTTAGKEYSREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_LISTTAGKEYSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT ListTagKeysRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListTagKeysRequest();
+				~ListTagKeysRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+
+            private:
+				std::string regionId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_LISTTAGKEYSREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/ListTagKeysResult.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_DBFS_MODEL_LISTTAGKEYSRESULT_H_
+#define ALIBABACLOUD_DBFS_MODEL_LISTTAGKEYSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT ListTagKeysResult : public ServiceResult
+			{
+			public:
+
+
+				ListTagKeysResult();
+				explicit ListTagKeysResult(const std::string &payload);
+				~ListTagKeysResult();
+				std::vector<std::string> getTagKeys()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<std::string> tagKeys_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_LISTTAGKEYSRESULT_H_

dbfs/include/alibabacloud/dbfs/model/ListTagValuesRequest.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_DBFS_MODEL_LISTTAGVALUESREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_LISTTAGVALUESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT ListTagValuesRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListTagValuesRequest();
+				~ListTagValuesRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getTagKey()const;
+				void setTagKey(const std::string& tagKey);
+
+            private:
+				std::string regionId_;
+				std::string tagKey_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_LISTTAGVALUESREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/ListTagValuesResult.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_DBFS_MODEL_LISTTAGVALUESRESULT_H_
+#define ALIBABACLOUD_DBFS_MODEL_LISTTAGVALUESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT ListTagValuesResult : public ServiceResult
+			{
+			public:
+
+
+				ListTagValuesResult();
+				explicit ListTagValuesResult(const std::string &payload);
+				~ListTagValuesResult();
+				std::vector<std::string> getTagValues()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<std::string> tagValues_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_LISTTAGVALUESRESULT_H_

dbfs/include/alibabacloud/dbfs/model/ListTaskRequest.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_DBFS_MODEL_LISTTASKREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_LISTTASKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT ListTaskRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListTaskRequest();
+				~ListTaskRequest();
+
+				std::string getSortType()const;
+				void setSortType(const std::string& sortType);
+				std::string getFilterValue()const;
+				void setFilterValue(const std::string& filterValue);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getFilterKey()const;
+				void setFilterKey(const std::string& filterKey);
+				std::string getSortKey()const;
+				void setSortKey(const std::string& sortKey);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+
+            private:
+				std::string sortType_;
+				std::string filterValue_;
+				int pageNumber_;
+				std::string filterKey_;
+				std::string sortKey_;
+				std::string regionId_;
+				int pageSize_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_LISTTASKREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/ListTaskResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_DBFS_MODEL_LISTTASKRESULT_H_
+#define ALIBABACLOUD_DBFS_MODEL_LISTTASKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT ListTaskResult : public ServiceResult
+			{
+			public:
+				struct TasksItem
+				{
+					std::string createdTime;
+					std::string taskAdder;
+					std::string priority;
+					int taskStatusCode;
+					int taskProgress;
+					int maxRetry;
+					std::string taskStatus;
+					std::string nextExecutionTime;
+					std::string taskErrorReason;
+					std::string taskRunner;
+					std::string taskOwner;
+					std::string taskName;
+					std::string completionTime;
+					std::string taskType;
+					int id;
+					std::string clientToken;
+					std::string taskProgressDescription;
+					int taskExecutionCounts;
+				};
+
+
+				ListTaskResult();
+				explicit ListTaskResult(const std::string &payload);
+				~ListTaskResult();
+				int getTotalCount()const;
+				std::vector<TasksItem> getTasks()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::vector<TasksItem> tasks_;
+				int pageSize_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_LISTTASKRESULT_H_

dbfs/include/alibabacloud/dbfs/model/OpreateConstantsRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DBFS_MODEL_OPREATECONSTANTSREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_OPREATECONSTANTSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT OpreateConstantsRequest : public RpcServiceRequest
+			{
+
+			public:
+				OpreateConstantsRequest();
+				~OpreateConstantsRequest();
+
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getConstantsData()const;
+				void setConstantsData(const std::string& constantsData);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+
+            private:
+				int pageNumber_;
+				std::string regionId_;
+				std::string constantsData_;
+				int pageSize_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_OPREATECONSTANTSREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/OpreateConstantsResult.h

@@ -0,0 +1,71 @@
+/*
+ * 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_DBFS_MODEL_OPREATECONSTANTSRESULT_H_
+#define ALIBABACLOUD_DBFS_MODEL_OPREATECONSTANTSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT OpreateConstantsResult : public ServiceResult
+			{
+			public:
+
+
+				OpreateConstantsResult();
+				explicit OpreateConstantsResult(const std::string &payload);
+				~OpreateConstantsResult();
+				long getTotalCount()const;
+				std::string getMasterData()const;
+				long getPageSize()const;
+				std::string getZoneData()const;
+				long getPageNumber()const;
+				std::string getAccessData()const;
+				std::string getProductCodeData()const;
+				std::string getOsversionData()const;
+				std::string getData()const;
+				std::string getRegionData()const;
+				std::string getEndpointData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				std::string masterData_;
+				long pageSize_;
+				std::string zoneData_;
+				long pageNumber_;
+				std::string accessData_;
+				std::string productCodeData_;
+				std::string osversionData_;
+				std::string data_;
+				std::string regionData_;
+				std::string endpointData_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_OPREATECONSTANTSRESULT_H_

dbfs/include/alibabacloud/dbfs/model/PublishUpgradeTaskRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DBFS_MODEL_PUBLISHUPGRADETASKREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_PUBLISHUPGRADETASKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT PublishUpgradeTaskRequest : public RpcServiceRequest
+			{
+
+			public:
+				PublishUpgradeTaskRequest();
+				~PublishUpgradeTaskRequest();
+
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getBatchStrategyList()const;
+				void setBatchStrategyList(const std::string& batchStrategyList);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+
+            private:
+				int pageNumber_;
+				std::string batchStrategyList_;
+				std::string regionId_;
+				int pageSize_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_PUBLISHUPGRADETASKREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/PublishUpgradeTaskResult.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_DBFS_MODEL_PUBLISHUPGRADETASKRESULT_H_
+#define ALIBABACLOUD_DBFS_MODEL_PUBLISHUPGRADETASKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT PublishUpgradeTaskResult : public ServiceResult
+			{
+			public:
+
+
+				PublishUpgradeTaskResult();
+				explicit PublishUpgradeTaskResult(const std::string &payload);
+				~PublishUpgradeTaskResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_PUBLISHUPGRADETASKRESULT_H_

dbfs/include/alibabacloud/dbfs/model/RenameDbfsRequest.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_DBFS_MODEL_RENAMEDBFSREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_RENAMEDBFSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT RenameDbfsRequest : public RpcServiceRequest
+			{
+
+			public:
+				RenameDbfsRequest();
+				~RenameDbfsRequest();
+
+				std::string getFsName()const;
+				void setFsName(const std::string& fsName);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getFsId()const;
+				void setFsId(const std::string& fsId);
+
+            private:
+				std::string fsName_;
+				std::string regionId_;
+				std::string fsId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_RENAMEDBFSREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/RenameDbfsResult.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_DBFS_MODEL_RENAMEDBFSRESULT_H_
+#define ALIBABACLOUD_DBFS_MODEL_RENAMEDBFSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT RenameDbfsResult : public ServiceResult
+			{
+			public:
+
+
+				RenameDbfsResult();
+				explicit RenameDbfsResult(const std::string &payload);
+				~RenameDbfsResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_RENAMEDBFSRESULT_H_

dbfs/include/alibabacloud/dbfs/model/ResetDbfsRequest.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_DBFS_MODEL_RESETDBFSREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_RESETDBFSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT ResetDbfsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ResetDbfsRequest();
+				~ResetDbfsRequest();
+
+				std::string getSnapshotId()const;
+				void setSnapshotId(const std::string& snapshotId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getFsId()const;
+				void setFsId(const std::string& fsId);
+
+            private:
+				std::string snapshotId_;
+				std::string regionId_;
+				std::string fsId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_RESETDBFSREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/ResetDbfsResult.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_DBFS_MODEL_RESETDBFSRESULT_H_
+#define ALIBABACLOUD_DBFS_MODEL_RESETDBFSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT ResetDbfsResult : public ServiceResult
+			{
+			public:
+
+
+				ResetDbfsResult();
+				explicit ResetDbfsResult(const std::string &payload);
+				~ResetDbfsResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_RESETDBFSRESULT_H_

dbfs/include/alibabacloud/dbfs/model/ResizeDbfsRequest.h

@@ -35,8 +35,6 @@ namespace AlibabaCloud
 				ResizeDbfsRequest();
 				~ResizeDbfsRequest();
 
-				std::string getClientToken()const;
-				void setClientToken(const std::string& clientToken);
 				int getNewSizeG()const;
 				void setNewSizeG(int newSizeG);
 				std::string getRegionId()const;
@@ -45,7 +43,6 @@ namespace AlibabaCloud
 				void setFsId(const std::string& fsId);
 
             private:
-				std::string clientToken_;
 				int newSizeG_;
 				std::string regionId_;
 				std::string fsId_;

dbfs/include/alibabacloud/dbfs/model/StopUpgradeTaskRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DBFS_MODEL_STOPUPGRADETASKREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_STOPUPGRADETASKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT StopUpgradeTaskRequest : public RpcServiceRequest
+			{
+
+			public:
+				StopUpgradeTaskRequest();
+				~StopUpgradeTaskRequest();
+
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getBatchStrategyList()const;
+				void setBatchStrategyList(const std::string& batchStrategyList);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+
+            private:
+				int pageNumber_;
+				std::string batchStrategyList_;
+				std::string regionId_;
+				int pageSize_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_STOPUPGRADETASKREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/StopUpgradeTaskResult.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_DBFS_MODEL_STOPUPGRADETASKRESULT_H_
+#define ALIBABACLOUD_DBFS_MODEL_STOPUPGRADETASKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT StopUpgradeTaskResult : public ServiceResult
+			{
+			public:
+
+
+				StopUpgradeTaskResult();
+				explicit StopUpgradeTaskResult(const std::string &payload);
+				~StopUpgradeTaskResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_STOPUPGRADETASKRESULT_H_

dbfs/include/alibabacloud/dbfs/model/TagDbfsRequest.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_DBFS_MODEL_TAGDBFSREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_TAGDBFSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT TagDbfsRequest : public RpcServiceRequest
+			{
+
+			public:
+				TagDbfsRequest();
+				~TagDbfsRequest();
+
+				std::string getTags()const;
+				void setTags(const std::string& tags);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getDbfsId()const;
+				void setDbfsId(const std::string& dbfsId);
+
+            private:
+				std::string tags_;
+				std::string regionId_;
+				std::string dbfsId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_TAGDBFSREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/TagDbfsResult.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_DBFS_MODEL_TAGDBFSRESULT_H_
+#define ALIBABACLOUD_DBFS_MODEL_TAGDBFSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT TagDbfsResult : public ServiceResult
+			{
+			public:
+
+
+				TagDbfsResult();
+				explicit TagDbfsResult(const std::string &payload);
+				~TagDbfsResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_TAGDBFSRESULT_H_

dbfs/include/alibabacloud/dbfs/model/UpdateConstantsRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DBFS_MODEL_UPDATECONSTANTSREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_UPDATECONSTANTSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT UpdateConstantsRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdateConstantsRequest();
+				~UpdateConstantsRequest();
+
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getConstantsData()const;
+				void setConstantsData(const std::string& constantsData);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+
+            private:
+				int pageNumber_;
+				std::string regionId_;
+				std::string constantsData_;
+				int pageSize_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_UPDATECONSTANTSREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/UpdateConstantsResult.h

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

dbfs/include/alibabacloud/dbfs/model/UpdateTaskRequest.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_DBFS_MODEL_UPDATETASKREQUEST_H_
+#define ALIBABACLOUD_DBFS_MODEL_UPDATETASKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT UpdateTaskRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdateTaskRequest();
+				~UpdateTaskRequest();
+
+				int getTaskProgress()const;
+				void setTaskProgress(int taskProgress);
+				std::string getTaskIds()const;
+				void setTaskIds(const std::string& taskIds);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+
+            private:
+				int taskProgress_;
+				std::string taskIds_;
+				std::string regionId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_UPDATETASKREQUEST_H_

dbfs/include/alibabacloud/dbfs/model/UpdateTaskResult.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_DBFS_MODEL_UPDATETASKRESULT_H_
+#define ALIBABACLOUD_DBFS_MODEL_UPDATETASKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dbfs/DBFSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace DBFS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DBFS_EXPORT UpdateTaskResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateTaskResult();
+				explicit UpdateTaskResult(const std::string &payload);
+				~UpdateTaskResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DBFS_MODEL_UPDATETASKRESULT_H_

dbfs/src/DBFSClient.cc

@@ -51,6 +51,42 @@ DBFSClient::DBFSClient(const std::string & accessKeyId, const std::string & acce
 DBFSClient::~DBFSClient()
 {}
 
+DBFSClient::AddTagsBatchOutcome DBFSClient::addTagsBatch(const AddTagsBatchRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddTagsBatchOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddTagsBatchOutcome(AddTagsBatchResult(outcome.result()));
+	else
+		return AddTagsBatchOutcome(outcome.error());
+}
+
+void DBFSClient::addTagsBatchAsync(const AddTagsBatchRequest& request, const AddTagsBatchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addTagsBatch(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::AddTagsBatchOutcomeCallable DBFSClient::addTagsBatchCallable(const AddTagsBatchRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddTagsBatchOutcome()>>(
+			[this, request]()
+			{
+			return this->addTagsBatch(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DBFSClient::AttachDbfsOutcome DBFSClient::attachDbfs(const AttachDbfsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -87,6 +123,42 @@ DBFSClient::AttachDbfsOutcomeCallable DBFSClient::attachDbfsCallable(const Attac
 	return task->get_future();
 }
 
+DBFSClient::CreateConstantsOutcome DBFSClient::createConstants(const CreateConstantsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateConstantsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateConstantsOutcome(CreateConstantsResult(outcome.result()));
+	else
+		return CreateConstantsOutcome(outcome.error());
+}
+
+void DBFSClient::createConstantsAsync(const CreateConstantsRequest& request, const CreateConstantsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createConstants(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::CreateConstantsOutcomeCallable DBFSClient::createConstantsCallable(const CreateConstantsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateConstantsOutcome()>>(
+			[this, request]()
+			{
+			return this->createConstants(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DBFSClient::CreateDbfsOutcome DBFSClient::createDbfs(const CreateDbfsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -123,6 +195,150 @@ DBFSClient::CreateDbfsOutcomeCallable DBFSClient::createDbfsCallable(const Creat
 	return task->get_future();
 }
 
+DBFSClient::CreateServiceLinkedRoleOutcome DBFSClient::createServiceLinkedRole(const CreateServiceLinkedRoleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateServiceLinkedRoleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateServiceLinkedRoleOutcome(CreateServiceLinkedRoleResult(outcome.result()));
+	else
+		return CreateServiceLinkedRoleOutcome(outcome.error());
+}
+
+void DBFSClient::createServiceLinkedRoleAsync(const CreateServiceLinkedRoleRequest& request, const CreateServiceLinkedRoleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createServiceLinkedRole(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::CreateServiceLinkedRoleOutcomeCallable DBFSClient::createServiceLinkedRoleCallable(const CreateServiceLinkedRoleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateServiceLinkedRoleOutcome()>>(
+			[this, request]()
+			{
+			return this->createServiceLinkedRole(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DBFSClient::CreateSnapshotOutcome DBFSClient::createSnapshot(const CreateSnapshotRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateSnapshotOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateSnapshotOutcome(CreateSnapshotResult(outcome.result()));
+	else
+		return CreateSnapshotOutcome(outcome.error());
+}
+
+void DBFSClient::createSnapshotAsync(const CreateSnapshotRequest& request, const CreateSnapshotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createSnapshot(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::CreateSnapshotOutcomeCallable DBFSClient::createSnapshotCallable(const CreateSnapshotRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateSnapshotOutcome()>>(
+			[this, request]()
+			{
+			return this->createSnapshot(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DBFSClient::DbfsRecordOutcome DBFSClient::dbfsRecord(const DbfsRecordRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DbfsRecordOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DbfsRecordOutcome(DbfsRecordResult(outcome.result()));
+	else
+		return DbfsRecordOutcome(outcome.error());
+}
+
+void DBFSClient::dbfsRecordAsync(const DbfsRecordRequest& request, const DbfsRecordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, dbfsRecord(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::DbfsRecordOutcomeCallable DBFSClient::dbfsRecordCallable(const DbfsRecordRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DbfsRecordOutcome()>>(
+			[this, request]()
+			{
+			return this->dbfsRecord(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DBFSClient::DeleteConstantsOutcome DBFSClient::deleteConstants(const DeleteConstantsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteConstantsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteConstantsOutcome(DeleteConstantsResult(outcome.result()));
+	else
+		return DeleteConstantsOutcome(outcome.error());
+}
+
+void DBFSClient::deleteConstantsAsync(const DeleteConstantsRequest& request, const DeleteConstantsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteConstants(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::DeleteConstantsOutcomeCallable DBFSClient::deleteConstantsCallable(const DeleteConstantsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteConstantsOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteConstants(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DBFSClient::DeleteDbfsOutcome DBFSClient::deleteDbfs(const DeleteDbfsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -159,6 +375,78 @@ DBFSClient::DeleteDbfsOutcomeCallable DBFSClient::deleteDbfsCallable(const Delet
 	return task->get_future();
 }
 
+DBFSClient::DeleteSnapshotOutcome DBFSClient::deleteSnapshot(const DeleteSnapshotRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteSnapshotOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteSnapshotOutcome(DeleteSnapshotResult(outcome.result()));
+	else
+		return DeleteSnapshotOutcome(outcome.error());
+}
+
+void DBFSClient::deleteSnapshotAsync(const DeleteSnapshotRequest& request, const DeleteSnapshotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteSnapshot(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::DeleteSnapshotOutcomeCallable DBFSClient::deleteSnapshotCallable(const DeleteSnapshotRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteSnapshotOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteSnapshot(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DBFSClient::DeleteTagsBatchOutcome DBFSClient::deleteTagsBatch(const DeleteTagsBatchRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteTagsBatchOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteTagsBatchOutcome(DeleteTagsBatchResult(outcome.result()));
+	else
+		return DeleteTagsBatchOutcome(outcome.error());
+}
+
+void DBFSClient::deleteTagsBatchAsync(const DeleteTagsBatchRequest& request, const DeleteTagsBatchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteTagsBatch(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::DeleteTagsBatchOutcomeCallable DBFSClient::deleteTagsBatchCallable(const DeleteTagsBatchRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteTagsBatchOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteTagsBatch(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DBFSClient::DetachDbfsOutcome DBFSClient::detachDbfs(const DetachDbfsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -195,108 +483,720 @@ DBFSClient::DetachDbfsOutcomeCallable DBFSClient::detachDbfsCallable(const Detac
 	return task->get_future();
 }
 
-DBFSClient::GetDbfsOutcome DBFSClient::getDbfs(const GetDbfsRequest &request) const
+DBFSClient::GenerateUpgradeRecordOutcome DBFSClient::generateUpgradeRecord(const GenerateUpgradeRecordRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return GetDbfsOutcome(endpointOutcome.error());
+		return GenerateUpgradeRecordOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return GetDbfsOutcome(GetDbfsResult(outcome.result()));
+		return GenerateUpgradeRecordOutcome(GenerateUpgradeRecordResult(outcome.result()));
 	else
-		return GetDbfsOutcome(outcome.error());
+		return GenerateUpgradeRecordOutcome(outcome.error());
 }
 
-void DBFSClient::getDbfsAsync(const GetDbfsRequest& request, const GetDbfsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void DBFSClient::generateUpgradeRecordAsync(const GenerateUpgradeRecordRequest& request, const GenerateUpgradeRecordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, getDbfs(request), context);
+		handler(this, request, generateUpgradeRecord(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-DBFSClient::GetDbfsOutcomeCallable DBFSClient::getDbfsCallable(const GetDbfsRequest &request) const
+DBFSClient::GenerateUpgradeRecordOutcomeCallable DBFSClient::generateUpgradeRecordCallable(const GenerateUpgradeRecordRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<GetDbfsOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<GenerateUpgradeRecordOutcome()>>(
 			[this, request]()
 			{
-			return this->getDbfs(request);
+			return this->generateUpgradeRecord(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-DBFSClient::ListDbfsOutcome DBFSClient::listDbfs(const ListDbfsRequest &request) const
+DBFSClient::GetDbfsOutcome DBFSClient::getDbfs(const GetDbfsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return ListDbfsOutcome(endpointOutcome.error());
+		return GetDbfsOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return ListDbfsOutcome(ListDbfsResult(outcome.result()));
+		return GetDbfsOutcome(GetDbfsResult(outcome.result()));
 	else
-		return ListDbfsOutcome(outcome.error());
+		return GetDbfsOutcome(outcome.error());
 }
 
-void DBFSClient::listDbfsAsync(const ListDbfsRequest& request, const ListDbfsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void DBFSClient::getDbfsAsync(const GetDbfsRequest& request, const GetDbfsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, listDbfs(request), context);
+		handler(this, request, getDbfs(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-DBFSClient::ListDbfsOutcomeCallable DBFSClient::listDbfsCallable(const ListDbfsRequest &request) const
+DBFSClient::GetDbfsOutcomeCallable DBFSClient::getDbfsCallable(const GetDbfsRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<ListDbfsOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<GetDbfsOutcome()>>(
 			[this, request]()
 			{
-			return this->listDbfs(request);
+			return this->getDbfs(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-DBFSClient::ResizeDbfsOutcome DBFSClient::resizeDbfs(const ResizeDbfsRequest &request) const
+DBFSClient::GetServiceLinkedRoleOutcome DBFSClient::getServiceLinkedRole(const GetServiceLinkedRoleRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return ResizeDbfsOutcome(endpointOutcome.error());
+		return GetServiceLinkedRoleOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return ResizeDbfsOutcome(ResizeDbfsResult(outcome.result()));
+		return GetServiceLinkedRoleOutcome(GetServiceLinkedRoleResult(outcome.result()));
 	else
-		return ResizeDbfsOutcome(outcome.error());
+		return GetServiceLinkedRoleOutcome(outcome.error());
 }
 
-void DBFSClient::resizeDbfsAsync(const ResizeDbfsRequest& request, const ResizeDbfsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void DBFSClient::getServiceLinkedRoleAsync(const GetServiceLinkedRoleRequest& request, const GetServiceLinkedRoleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, resizeDbfs(request), context);
+		handler(this, request, getServiceLinkedRole(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-DBFSClient::ResizeDbfsOutcomeCallable DBFSClient::resizeDbfsCallable(const ResizeDbfsRequest &request) const
+DBFSClient::GetServiceLinkedRoleOutcomeCallable DBFSClient::getServiceLinkedRoleCallable(const GetServiceLinkedRoleRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<ResizeDbfsOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<GetServiceLinkedRoleOutcome()>>(
 			[this, request]()
 			{
-			return this->resizeDbfs(request);
+			return this->getServiceLinkedRole(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DBFSClient::GetSynchronizConstantsOutcome DBFSClient::getSynchronizConstants(const GetSynchronizConstantsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetSynchronizConstantsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetSynchronizConstantsOutcome(GetSynchronizConstantsResult(outcome.result()));
+	else
+		return GetSynchronizConstantsOutcome(outcome.error());
+}
+
+void DBFSClient::getSynchronizConstantsAsync(const GetSynchronizConstantsRequest& request, const GetSynchronizConstantsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getSynchronizConstants(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::GetSynchronizConstantsOutcomeCallable DBFSClient::getSynchronizConstantsCallable(const GetSynchronizConstantsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetSynchronizConstantsOutcome()>>(
+			[this, request]()
+			{
+			return this->getSynchronizConstants(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DBFSClient::InsertSynchronizConstantsOutcome DBFSClient::insertSynchronizConstants(const InsertSynchronizConstantsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return InsertSynchronizConstantsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return InsertSynchronizConstantsOutcome(InsertSynchronizConstantsResult(outcome.result()));
+	else
+		return InsertSynchronizConstantsOutcome(outcome.error());
+}
+
+void DBFSClient::insertSynchronizConstantsAsync(const InsertSynchronizConstantsRequest& request, const InsertSynchronizConstantsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, insertSynchronizConstants(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::InsertSynchronizConstantsOutcomeCallable DBFSClient::insertSynchronizConstantsCallable(const InsertSynchronizConstantsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<InsertSynchronizConstantsOutcome()>>(
+			[this, request]()
+			{
+			return this->insertSynchronizConstants(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DBFSClient::ListConstantsOutcome DBFSClient::listConstants(const ListConstantsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListConstantsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListConstantsOutcome(ListConstantsResult(outcome.result()));
+	else
+		return ListConstantsOutcome(outcome.error());
+}
+
+void DBFSClient::listConstantsAsync(const ListConstantsRequest& request, const ListConstantsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listConstants(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::ListConstantsOutcomeCallable DBFSClient::listConstantsCallable(const ListConstantsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListConstantsOutcome()>>(
+			[this, request]()
+			{
+			return this->listConstants(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DBFSClient::ListDbfsOutcome DBFSClient::listDbfs(const ListDbfsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListDbfsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListDbfsOutcome(ListDbfsResult(outcome.result()));
+	else
+		return ListDbfsOutcome(outcome.error());
+}
+
+void DBFSClient::listDbfsAsync(const ListDbfsRequest& request, const ListDbfsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listDbfs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::ListDbfsOutcomeCallable DBFSClient::listDbfsCallable(const ListDbfsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListDbfsOutcome()>>(
+			[this, request]()
+			{
+			return this->listDbfs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DBFSClient::ListSnapshotOutcome DBFSClient::listSnapshot(const ListSnapshotRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListSnapshotOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListSnapshotOutcome(ListSnapshotResult(outcome.result()));
+	else
+		return ListSnapshotOutcome(outcome.error());
+}
+
+void DBFSClient::listSnapshotAsync(const ListSnapshotRequest& request, const ListSnapshotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listSnapshot(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::ListSnapshotOutcomeCallable DBFSClient::listSnapshotCallable(const ListSnapshotRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListSnapshotOutcome()>>(
+			[this, request]()
+			{
+			return this->listSnapshot(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DBFSClient::ListTagKeysOutcome DBFSClient::listTagKeys(const ListTagKeysRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListTagKeysOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListTagKeysOutcome(ListTagKeysResult(outcome.result()));
+	else
+		return ListTagKeysOutcome(outcome.error());
+}
+
+void DBFSClient::listTagKeysAsync(const ListTagKeysRequest& request, const ListTagKeysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listTagKeys(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::ListTagKeysOutcomeCallable DBFSClient::listTagKeysCallable(const ListTagKeysRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListTagKeysOutcome()>>(
+			[this, request]()
+			{
+			return this->listTagKeys(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DBFSClient::ListTagValuesOutcome DBFSClient::listTagValues(const ListTagValuesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListTagValuesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListTagValuesOutcome(ListTagValuesResult(outcome.result()));
+	else
+		return ListTagValuesOutcome(outcome.error());
+}
+
+void DBFSClient::listTagValuesAsync(const ListTagValuesRequest& request, const ListTagValuesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listTagValues(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::ListTagValuesOutcomeCallable DBFSClient::listTagValuesCallable(const ListTagValuesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListTagValuesOutcome()>>(
+			[this, request]()
+			{
+			return this->listTagValues(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DBFSClient::ListTaskOutcome DBFSClient::listTask(const ListTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListTaskOutcome(ListTaskResult(outcome.result()));
+	else
+		return ListTaskOutcome(outcome.error());
+}
+
+void DBFSClient::listTaskAsync(const ListTaskRequest& request, const ListTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::ListTaskOutcomeCallable DBFSClient::listTaskCallable(const ListTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->listTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DBFSClient::OpreateConstantsOutcome DBFSClient::opreateConstants(const OpreateConstantsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return OpreateConstantsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return OpreateConstantsOutcome(OpreateConstantsResult(outcome.result()));
+	else
+		return OpreateConstantsOutcome(outcome.error());
+}
+
+void DBFSClient::opreateConstantsAsync(const OpreateConstantsRequest& request, const OpreateConstantsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, opreateConstants(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::OpreateConstantsOutcomeCallable DBFSClient::opreateConstantsCallable(const OpreateConstantsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<OpreateConstantsOutcome()>>(
+			[this, request]()
+			{
+			return this->opreateConstants(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DBFSClient::PublishUpgradeTaskOutcome DBFSClient::publishUpgradeTask(const PublishUpgradeTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PublishUpgradeTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PublishUpgradeTaskOutcome(PublishUpgradeTaskResult(outcome.result()));
+	else
+		return PublishUpgradeTaskOutcome(outcome.error());
+}
+
+void DBFSClient::publishUpgradeTaskAsync(const PublishUpgradeTaskRequest& request, const PublishUpgradeTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, publishUpgradeTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::PublishUpgradeTaskOutcomeCallable DBFSClient::publishUpgradeTaskCallable(const PublishUpgradeTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PublishUpgradeTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->publishUpgradeTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DBFSClient::RenameDbfsOutcome DBFSClient::renameDbfs(const RenameDbfsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RenameDbfsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RenameDbfsOutcome(RenameDbfsResult(outcome.result()));
+	else
+		return RenameDbfsOutcome(outcome.error());
+}
+
+void DBFSClient::renameDbfsAsync(const RenameDbfsRequest& request, const RenameDbfsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, renameDbfs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::RenameDbfsOutcomeCallable DBFSClient::renameDbfsCallable(const RenameDbfsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RenameDbfsOutcome()>>(
+			[this, request]()
+			{
+			return this->renameDbfs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DBFSClient::ResetDbfsOutcome DBFSClient::resetDbfs(const ResetDbfsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ResetDbfsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ResetDbfsOutcome(ResetDbfsResult(outcome.result()));
+	else
+		return ResetDbfsOutcome(outcome.error());
+}
+
+void DBFSClient::resetDbfsAsync(const ResetDbfsRequest& request, const ResetDbfsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, resetDbfs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::ResetDbfsOutcomeCallable DBFSClient::resetDbfsCallable(const ResetDbfsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ResetDbfsOutcome()>>(
+			[this, request]()
+			{
+			return this->resetDbfs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DBFSClient::ResizeDbfsOutcome DBFSClient::resizeDbfs(const ResizeDbfsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ResizeDbfsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ResizeDbfsOutcome(ResizeDbfsResult(outcome.result()));
+	else
+		return ResizeDbfsOutcome(outcome.error());
+}
+
+void DBFSClient::resizeDbfsAsync(const ResizeDbfsRequest& request, const ResizeDbfsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, resizeDbfs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::ResizeDbfsOutcomeCallable DBFSClient::resizeDbfsCallable(const ResizeDbfsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ResizeDbfsOutcome()>>(
+			[this, request]()
+			{
+			return this->resizeDbfs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DBFSClient::StopUpgradeTaskOutcome DBFSClient::stopUpgradeTask(const StopUpgradeTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StopUpgradeTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StopUpgradeTaskOutcome(StopUpgradeTaskResult(outcome.result()));
+	else
+		return StopUpgradeTaskOutcome(outcome.error());
+}
+
+void DBFSClient::stopUpgradeTaskAsync(const StopUpgradeTaskRequest& request, const StopUpgradeTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, stopUpgradeTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::StopUpgradeTaskOutcomeCallable DBFSClient::stopUpgradeTaskCallable(const StopUpgradeTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StopUpgradeTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->stopUpgradeTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DBFSClient::TagDbfsOutcome DBFSClient::tagDbfs(const TagDbfsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return TagDbfsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return TagDbfsOutcome(TagDbfsResult(outcome.result()));
+	else
+		return TagDbfsOutcome(outcome.error());
+}
+
+void DBFSClient::tagDbfsAsync(const TagDbfsRequest& request, const TagDbfsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, tagDbfs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::TagDbfsOutcomeCallable DBFSClient::tagDbfsCallable(const TagDbfsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<TagDbfsOutcome()>>(
+			[this, request]()
+			{
+			return this->tagDbfs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DBFSClient::UpdateConstantsOutcome DBFSClient::updateConstants(const UpdateConstantsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateConstantsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateConstantsOutcome(UpdateConstantsResult(outcome.result()));
+	else
+		return UpdateConstantsOutcome(outcome.error());
+}
+
+void DBFSClient::updateConstantsAsync(const UpdateConstantsRequest& request, const UpdateConstantsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateConstants(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::UpdateConstantsOutcomeCallable DBFSClient::updateConstantsCallable(const UpdateConstantsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateConstantsOutcome()>>(
+			[this, request]()
+			{
+			return this->updateConstants(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DBFSClient::UpdateTaskOutcome DBFSClient::updateTask(const UpdateTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateTaskOutcome(UpdateTaskResult(outcome.result()));
+	else
+		return UpdateTaskOutcome(outcome.error());
+}
+
+void DBFSClient::updateTaskAsync(const UpdateTaskRequest& request, const UpdateTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DBFSClient::UpdateTaskOutcomeCallable DBFSClient::updateTaskCallable(const UpdateTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->updateTask(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));

dbfs/src/model/AddTagsBatchRequest.cc

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dbfs/model/AddTagsBatchRequest.h>
+
+using AlibabaCloud::DBFS::Model::AddTagsBatchRequest;
+
+AddTagsBatchRequest::AddTagsBatchRequest() :
+	RpcServiceRequest("dbfs", "2020-04-18", "AddTagsBatch")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AddTagsBatchRequest::~AddTagsBatchRequest()
+{}
+
+std::string AddTagsBatchRequest::getDbfsList()const
+{
+	return dbfsList_;
+}
+
+void AddTagsBatchRequest::setDbfsList(const std::string& dbfsList)
+{
+	dbfsList_ = dbfsList;
+	setParameter("DbfsList", dbfsList);
+}
+
+std::string AddTagsBatchRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void AddTagsBatchRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string AddTagsBatchRequest::getTags()const
+{
+	return tags_;
+}
+
+void AddTagsBatchRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+
+std::string AddTagsBatchRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void AddTagsBatchRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+

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

dbfs/src/model/AttachDbfsRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::DBFS::Model::AttachDbfsRequest;
 
 AttachDbfsRequest::AttachDbfsRequest() :
-	RpcServiceRequest("dbfs", "2020-02-19", "AttachDbfs")
+	RpcServiceRequest("dbfs", "2020-04-18", "AttachDbfs")
 {
 	setMethod(HttpRequest::Method::Post);
 }
@@ -49,6 +49,17 @@ void AttachDbfsRequest::setRegionId(const std::string& regionId)
 	setParameter("RegionId", regionId);
 }
 
+std::string AttachDbfsRequest::getServerUrl()const
+{
+	return serverUrl_;
+}
+
+void AttachDbfsRequest::setServerUrl(const std::string& serverUrl)
+{
+	serverUrl_ = serverUrl;
+	setParameter("ServerUrl", serverUrl);
+}
+
 std::string AttachDbfsRequest::getFsId()const
 {
 	return fsId_;

dbfs/src/model/CreateConstantsRequest.cc

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dbfs/model/CreateConstantsRequest.h>
+
+using AlibabaCloud::DBFS::Model::CreateConstantsRequest;
+
+CreateConstantsRequest::CreateConstantsRequest() :
+	RpcServiceRequest("dbfs", "2020-04-18", "CreateConstants")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateConstantsRequest::~CreateConstantsRequest()
+{}
+
+int CreateConstantsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void CreateConstantsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string CreateConstantsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateConstantsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CreateConstantsRequest::getConstantsData()const
+{
+	return constantsData_;
+}
+
+void CreateConstantsRequest::setConstantsData(const std::string& constantsData)
+{
+	constantsData_ = constantsData;
+	setParameter("ConstantsData", constantsData);
+}
+
+int CreateConstantsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void CreateConstantsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+

dbfs/src/model/CreateConstantsResult.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dbfs/model/CreateConstantsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::DBFS;
+using namespace AlibabaCloud::DBFS::Model;
+
+CreateConstantsResult::CreateConstantsResult() :
+	ServiceResult()
+{}
+
+CreateConstantsResult::CreateConstantsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateConstantsResult::~CreateConstantsResult()
+{}
+
+void CreateConstantsResult::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["PageSize"].isNull())
+		pageSize_ = std::stol(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stol(value["TotalCount"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stol(value["PageNumber"].asString());
+
+}
+
+long CreateConstantsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+long CreateConstantsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+long CreateConstantsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::string CreateConstantsResult::getData()const
+{
+	return data_;
+}
+

dbfs/src/model/CreateDbfsRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::DBFS::Model::CreateDbfsRequest;
 
 CreateDbfsRequest::CreateDbfsRequest() :
-	RpcServiceRequest("dbfs", "2020-02-19", "CreateDbfs")
+	RpcServiceRequest("dbfs", "2020-04-18", "CreateDbfs")
 {
 	setMethod(HttpRequest::Method::Post);
 }
@@ -38,6 +38,17 @@ void CreateDbfsRequest::setSizeG(int sizeG)
 	setParameter("SizeG", std::to_string(sizeG));
 }
 
+std::string CreateDbfsRequest::getSnapshotId()const
+{
+	return snapshotId_;
+}
+
+void CreateDbfsRequest::setSnapshotId(const std::string& snapshotId)
+{
+	snapshotId_ = snapshotId;
+	setParameter("SnapshotId", snapshotId);
+}
+
 std::string CreateDbfsRequest::getClientToken()const
 {
 	return clientToken_;
@@ -49,6 +60,17 @@ void CreateDbfsRequest::setClientToken(const std::string& clientToken)
 	setParameter("ClientToken", clientToken);
 }
 
+std::string CreateDbfsRequest::getUsedScene()const
+{
+	return usedScene_;
+}
+
+void CreateDbfsRequest::setUsedScene(const std::string& usedScene)
+{
+	usedScene_ = usedScene;
+	setParameter("UsedScene", usedScene);
+}
+
 std::string CreateDbfsRequest::getFsName()const
 {
 	return fsName_;
@@ -60,6 +82,28 @@ void CreateDbfsRequest::setFsName(const std::string& fsName)
 	setParameter("FsName", fsName);
 }
 
+int CreateDbfsRequest::getRaidStripeUnitNumber()const
+{
+	return raidStripeUnitNumber_;
+}
+
+void CreateDbfsRequest::setRaidStripeUnitNumber(int raidStripeUnitNumber)
+{
+	raidStripeUnitNumber_ = raidStripeUnitNumber;
+	setParameter("RaidStripeUnitNumber", std::to_string(raidStripeUnitNumber));
+}
+
+bool CreateDbfsRequest::getEncryption()const
+{
+	return encryption_;
+}
+
+void CreateDbfsRequest::setEncryption(bool encryption)
+{
+	encryption_ = encryption;
+	setParameter("Encryption", encryption ? "true" : "false");
+}
+
 std::string CreateDbfsRequest::getRegionId()const
 {
 	return regionId_;
@@ -71,6 +115,39 @@ void CreateDbfsRequest::setRegionId(const std::string& regionId)
 	setParameter("RegionId", regionId);
 }
 
+std::string CreateDbfsRequest::getPerformanceLevel()const
+{
+	return performanceLevel_;
+}
+
+void CreateDbfsRequest::setPerformanceLevel(const std::string& performanceLevel)
+{
+	performanceLevel_ = performanceLevel;
+	setParameter("PerformanceLevel", performanceLevel);
+}
+
+bool CreateDbfsRequest::getEnableRaid()const
+{
+	return enableRaid_;
+}
+
+void CreateDbfsRequest::setEnableRaid(bool enableRaid)
+{
+	enableRaid_ = enableRaid;
+	setParameter("EnableRaid", enableRaid ? "true" : "false");
+}
+
+bool CreateDbfsRequest::getDeleteSnapshot()const
+{
+	return deleteSnapshot_;
+}
+
+void CreateDbfsRequest::setDeleteSnapshot(bool deleteSnapshot)
+{
+	deleteSnapshot_ = deleteSnapshot;
+	setParameter("DeleteSnapshot", deleteSnapshot ? "true" : "false");
+}
+
 std::string CreateDbfsRequest::getZoneId()const
 {
 	return zoneId_;
@@ -93,3 +170,14 @@ void CreateDbfsRequest::setCategory(const std::string& category)
 	setParameter("Category", category);
 }
 
+std::string CreateDbfsRequest::getKMSKeyId()const
+{
+	return kMSKeyId_;
+}
+
+void CreateDbfsRequest::setKMSKeyId(const std::string& kMSKeyId)
+{
+	kMSKeyId_ = kMSKeyId;
+	setParameter("KMSKeyId", kMSKeyId);
+}
+

dbfs/src/model/CreateServiceLinkedRoleRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dbfs/model/CreateServiceLinkedRoleRequest.h>
+
+using AlibabaCloud::DBFS::Model::CreateServiceLinkedRoleRequest;
+
+CreateServiceLinkedRoleRequest::CreateServiceLinkedRoleRequest() :
+	RpcServiceRequest("dbfs", "2020-04-18", "CreateServiceLinkedRole")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateServiceLinkedRoleRequest::~CreateServiceLinkedRoleRequest()
+{}
+
+std::string CreateServiceLinkedRoleRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void CreateServiceLinkedRoleRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string CreateServiceLinkedRoleRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateServiceLinkedRoleRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+

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

dbfs/src/model/CreateSnapshotRequest.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/dbfs/model/CreateSnapshotRequest.h>
+
+using AlibabaCloud::DBFS::Model::CreateSnapshotRequest;
+
+CreateSnapshotRequest::CreateSnapshotRequest() :
+	RpcServiceRequest("dbfs", "2020-04-18", "CreateSnapshot")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateSnapshotRequest::~CreateSnapshotRequest()
+{}
+
+std::string CreateSnapshotRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void CreateSnapshotRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string CreateSnapshotRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateSnapshotRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
+std::string CreateSnapshotRequest::getSnapshotName()const
+{
+	return snapshotName_;
+}
+
+void CreateSnapshotRequest::setSnapshotName(const std::string& snapshotName)
+{
+	snapshotName_ = snapshotName;
+	setParameter("SnapshotName", snapshotName);
+}
+
+std::string CreateSnapshotRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateSnapshotRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CreateSnapshotRequest::getFsId()const
+{
+	return fsId_;
+}
+
+void CreateSnapshotRequest::setFsId(const std::string& fsId)
+{
+	fsId_ = fsId;
+	setParameter("FsId", fsId);
+}
+
+int CreateSnapshotRequest::getRetentionDays()const
+{
+	return retentionDays_;
+}
+
+void CreateSnapshotRequest::setRetentionDays(int retentionDays)
+{
+	retentionDays_ = retentionDays;
+	setParameter("RetentionDays", std::to_string(retentionDays));
+}
+

dbfs/src/model/CreateSnapshotResult.cc

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

dbfs/src/model/DbfsRecordRequest.cc

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dbfs/model/DbfsRecordRequest.h>
+
+using AlibabaCloud::DBFS::Model::DbfsRecordRequest;
+
+DbfsRecordRequest::DbfsRecordRequest() :
+	RpcServiceRequest("dbfs", "2020-04-18", "DbfsRecord")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DbfsRecordRequest::~DbfsRecordRequest()
+{}
+
+int DbfsRecordRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DbfsRecordRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DbfsRecordRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DbfsRecordRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+int DbfsRecordRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DbfsRecordRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string DbfsRecordRequest::getBatchStrategyNo()const
+{
+	return batchStrategyNo_;
+}
+
+void DbfsRecordRequest::setBatchStrategyNo(const std::string& batchStrategyNo)
+{
+	batchStrategyNo_ = batchStrategyNo;
+	setParameter("BatchStrategyNo", batchStrategyNo);
+}
+

dbfs/src/model/DbfsRecordResult.cc

@@ -0,0 +1,91 @@
+/*
+ * 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/dbfs/model/DbfsRecordResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::DBFS;
+using namespace AlibabaCloud::DBFS::Model;
+
+DbfsRecordResult::DbfsRecordResult() :
+	ServiceResult()
+{}
+
+DbfsRecordResult::DbfsRecordResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DbfsRecordResult::~DbfsRecordResult()
+{}
+
+void DbfsRecordResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allRecordsNode = value["Records"]["RecordsItem"];
+	for (auto valueRecordsRecordsItem : allRecordsNode)
+	{
+		RecordsItem recordsObject;
+		if(!valueRecordsRecordsItem["Id"].isNull())
+			recordsObject.id = std::stol(valueRecordsRecordsItem["Id"].asString());
+		if(!valueRecordsRecordsItem["BatchStrategyNo"].isNull())
+			recordsObject.batchStrategyNo = valueRecordsRecordsItem["BatchStrategyNo"].asString();
+		if(!valueRecordsRecordsItem["AccountId"].isNull())
+			recordsObject.accountId = valueRecordsRecordsItem["AccountId"].asString();
+		if(!valueRecordsRecordsItem["DbfsId"].isNull())
+			recordsObject.dbfsId = valueRecordsRecordsItem["DbfsId"].asString();
+		if(!valueRecordsRecordsItem["EcsId"].isNull())
+			recordsObject.ecsId = valueRecordsRecordsItem["EcsId"].asString();
+		if(!valueRecordsRecordsItem["TaskId"].isNull())
+			recordsObject.taskId = valueRecordsRecordsItem["TaskId"].asString();
+		if(!valueRecordsRecordsItem["RegionId"].isNull())
+			recordsObject.regionId = valueRecordsRecordsItem["RegionId"].asString();
+		if(!valueRecordsRecordsItem["ZoneId"].isNull())
+			recordsObject.zoneId = valueRecordsRecordsItem["ZoneId"].asString();
+		if(!valueRecordsRecordsItem["State"].isNull())
+			recordsObject.state = valueRecordsRecordsItem["State"].asString();
+		if(!valueRecordsRecordsItem["CurrentVersion"].isNull())
+			recordsObject.currentVersion = valueRecordsRecordsItem["CurrentVersion"].asString();
+		if(!valueRecordsRecordsItem["TargetVersion"].isNull())
+			recordsObject.targetVersion = valueRecordsRecordsItem["TargetVersion"].asString();
+		if(!valueRecordsRecordsItem["UpgradeStartTime"].isNull())
+			recordsObject.upgradeStartTime = std::stol(valueRecordsRecordsItem["UpgradeStartTime"].asString());
+		if(!valueRecordsRecordsItem["UpgradeEndTime"].isNull())
+			recordsObject.upgradeEndTime = std::stol(valueRecordsRecordsItem["UpgradeEndTime"].asString());
+		if(!valueRecordsRecordsItem["TaskExecutionCounts"].isNull())
+			recordsObject.taskExecutionCounts = std::stoi(valueRecordsRecordsItem["TaskExecutionCounts"].asString());
+		if(!valueRecordsRecordsItem["TaskErrorReason"].isNull())
+			recordsObject.taskErrorReason = valueRecordsRecordsItem["TaskErrorReason"].asString();
+		if(!valueRecordsRecordsItem["CreateTime"].isNull())
+			recordsObject.createTime = std::stol(valueRecordsRecordsItem["CreateTime"].asString());
+		if(!valueRecordsRecordsItem["UpdateTime"].isNull())
+			recordsObject.updateTime = std::stol(valueRecordsRecordsItem["UpdateTime"].asString());
+		if(!valueRecordsRecordsItem["IsDel"].isNull())
+			recordsObject.isDel = valueRecordsRecordsItem["IsDel"].asString();
+		records_.push_back(recordsObject);
+	}
+
+}
+
+std::vector<DbfsRecordResult::RecordsItem> DbfsRecordResult::getRecords()const
+{
+	return records_;
+}
+

dbfs/src/model/DeleteConstantsRequest.cc

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dbfs/model/DeleteConstantsRequest.h>
+
+using AlibabaCloud::DBFS::Model::DeleteConstantsRequest;
+
+DeleteConstantsRequest::DeleteConstantsRequest() :
+	RpcServiceRequest("dbfs", "2020-04-18", "DeleteConstants")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteConstantsRequest::~DeleteConstantsRequest()
+{}
+
+int DeleteConstantsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DeleteConstantsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DeleteConstantsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteConstantsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DeleteConstantsRequest::getConstantsData()const
+{
+	return constantsData_;
+}
+
+void DeleteConstantsRequest::setConstantsData(const std::string& constantsData)
+{
+	constantsData_ = constantsData;
+	setParameter("ConstantsData", constantsData);
+}
+
+int DeleteConstantsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DeleteConstantsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+

dbfs/src/model/DeleteConstantsResult.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dbfs/model/DeleteConstantsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::DBFS;
+using namespace AlibabaCloud::DBFS::Model;
+
+DeleteConstantsResult::DeleteConstantsResult() :
+	ServiceResult()
+{}
+
+DeleteConstantsResult::DeleteConstantsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteConstantsResult::~DeleteConstantsResult()
+{}
+
+void DeleteConstantsResult::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["PageSize"].isNull())
+		pageSize_ = std::stol(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stol(value["TotalCount"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stol(value["PageNumber"].asString());
+
+}
+
+long DeleteConstantsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+long DeleteConstantsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+long DeleteConstantsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::string DeleteConstantsResult::getData()const
+{
+	return data_;
+}
+

dbfs/src/model/DeleteDbfsRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::DBFS::Model::DeleteDbfsRequest;
 
 DeleteDbfsRequest::DeleteDbfsRequest() :
-	RpcServiceRequest("dbfs", "2020-02-19", "DeleteDbfs")
+	RpcServiceRequest("dbfs", "2020-04-18", "DeleteDbfs")
 {
 	setMethod(HttpRequest::Method::Post);
 }

dbfs/src/model/DeleteSnapshotRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dbfs/model/DeleteSnapshotRequest.h>
+
+using AlibabaCloud::DBFS::Model::DeleteSnapshotRequest;
+
+DeleteSnapshotRequest::DeleteSnapshotRequest() :
+	RpcServiceRequest("dbfs", "2020-04-18", "DeleteSnapshot")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteSnapshotRequest::~DeleteSnapshotRequest()
+{}
+
+std::string DeleteSnapshotRequest::getSnapshotId()const
+{
+	return snapshotId_;
+}
+
+void DeleteSnapshotRequest::setSnapshotId(const std::string& snapshotId)
+{
+	snapshotId_ = snapshotId;
+	setParameter("SnapshotId", snapshotId);
+}
+
+std::string DeleteSnapshotRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteSnapshotRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+bool DeleteSnapshotRequest::getForce()const
+{
+	return force_;
+}
+
+void DeleteSnapshotRequest::setForce(bool force)
+{
+	force_ = force;
+	setParameter("Force", force ? "true" : "false");
+}
+

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

dbfs/src/model/DeleteTagsBatchRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dbfs/model/DeleteTagsBatchRequest.h>
+
+using AlibabaCloud::DBFS::Model::DeleteTagsBatchRequest;
+
+DeleteTagsBatchRequest::DeleteTagsBatchRequest() :
+	RpcServiceRequest("dbfs", "2020-04-18", "DeleteTagsBatch")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteTagsBatchRequest::~DeleteTagsBatchRequest()
+{}
+
+std::string DeleteTagsBatchRequest::getDbfsList()const
+{
+	return dbfsList_;
+}
+
+void DeleteTagsBatchRequest::setDbfsList(const std::string& dbfsList)
+{
+	dbfsList_ = dbfsList;
+	setParameter("DbfsList", dbfsList);
+}
+
+std::string DeleteTagsBatchRequest::getTags()const
+{
+	return tags_;
+}
+
+void DeleteTagsBatchRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+
+std::string DeleteTagsBatchRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteTagsBatchRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+

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

dbfs/src/model/DetachDbfsRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::DBFS::Model::DetachDbfsRequest;
 
 DetachDbfsRequest::DetachDbfsRequest() :
-	RpcServiceRequest("dbfs", "2020-02-19", "DetachDbfs")
+	RpcServiceRequest("dbfs", "2020-04-18", "DetachDbfs")
 {
 	setMethod(HttpRequest::Method::Post);
 }

dbfs/src/model/GenerateUpgradeRecordRequest.cc

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dbfs/model/GenerateUpgradeRecordRequest.h>
+
+using AlibabaCloud::DBFS::Model::GenerateUpgradeRecordRequest;
+
+GenerateUpgradeRecordRequest::GenerateUpgradeRecordRequest() :
+	RpcServiceRequest("dbfs", "2020-04-18", "GenerateUpgradeRecord")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GenerateUpgradeRecordRequest::~GenerateUpgradeRecordRequest()
+{}
+
+int GenerateUpgradeRecordRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void GenerateUpgradeRecordRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string GenerateUpgradeRecordRequest::getBatchStrategyList()const
+{
+	return batchStrategyList_;
+}
+
+void GenerateUpgradeRecordRequest::setBatchStrategyList(const std::string& batchStrategyList)
+{
+	batchStrategyList_ = batchStrategyList;
+	setParameter("BatchStrategyList", batchStrategyList);
+}
+
+std::string GenerateUpgradeRecordRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GenerateUpgradeRecordRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+int GenerateUpgradeRecordRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void GenerateUpgradeRecordRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+

dbfs/src/model/GenerateUpgradeRecordResult.cc

@@ -0,0 +1,89 @@
+/*
+ * 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/dbfs/model/GenerateUpgradeRecordResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::DBFS;
+using namespace AlibabaCloud::DBFS::Model;
+
+GenerateUpgradeRecordResult::GenerateUpgradeRecordResult() :
+	ServiceResult()
+{}
+
+GenerateUpgradeRecordResult::GenerateUpgradeRecordResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GenerateUpgradeRecordResult::~GenerateUpgradeRecordResult()
+{}
+
+void GenerateUpgradeRecordResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allRecordsNode = value["Records"]["RecordsItem"];
+	for (auto valueRecordsRecordsItem : allRecordsNode)
+	{
+		RecordsItem recordsObject;
+		if(!valueRecordsRecordsItem["Id"].isNull())
+			recordsObject.id = std::stol(valueRecordsRecordsItem["Id"].asString());
+		if(!valueRecordsRecordsItem["BatchStrategyNo"].isNull())
+			recordsObject.batchStrategyNo = valueRecordsRecordsItem["BatchStrategyNo"].asString();
+		if(!valueRecordsRecordsItem["AccountId"].isNull())
+			recordsObject.accountId = valueRecordsRecordsItem["AccountId"].asString();
+		if(!valueRecordsRecordsItem["DbfsId"].isNull())
+			recordsObject.dbfsId = valueRecordsRecordsItem["DbfsId"].asString();
+		if(!valueRecordsRecordsItem["EcsId"].isNull())
+			recordsObject.ecsId = valueRecordsRecordsItem["EcsId"].asString();
+		if(!valueRecordsRecordsItem["TaskId"].isNull())
+			recordsObject.taskId = valueRecordsRecordsItem["TaskId"].asString();
+		if(!valueRecordsRecordsItem["RegionId"].isNull())
+			recordsObject.regionId = valueRecordsRecordsItem["RegionId"].asString();
+		if(!valueRecordsRecordsItem["ZoneId"].isNull())
+			recordsObject.zoneId = valueRecordsRecordsItem["ZoneId"].asString();
+		if(!valueRecordsRecordsItem["State"].isNull())
+			recordsObject.state = valueRecordsRecordsItem["State"].asString();
+		if(!valueRecordsRecordsItem["CurrentVersion"].isNull())
+			recordsObject.currentVersion = valueRecordsRecordsItem["CurrentVersion"].asString();
+		if(!valueRecordsRecordsItem["TargetVersion"].isNull())
+			recordsObject.targetVersion = valueRecordsRecordsItem["TargetVersion"].asString();
+		if(!valueRecordsRecordsItem["UpgradeStartTime"].isNull())
+			recordsObject.upgradeStartTime = std::stol(valueRecordsRecordsItem["UpgradeStartTime"].asString());
+		if(!valueRecordsRecordsItem["UpgradeEndTime"].isNull())
+			recordsObject.upgradeEndTime = std::stol(valueRecordsRecordsItem["UpgradeEndTime"].asString());
+		if(!valueRecordsRecordsItem["TaskExecutionCounts"].isNull())
+			recordsObject.taskExecutionCounts = std::stoi(valueRecordsRecordsItem["TaskExecutionCounts"].asString());
+		if(!valueRecordsRecordsItem["TaskErrorReason"].isNull())
+			recordsObject.taskErrorReason = valueRecordsRecordsItem["TaskErrorReason"].asString();
+		if(!valueRecordsRecordsItem["CreateTime"].isNull())
+			recordsObject.createTime = std::stol(valueRecordsRecordsItem["CreateTime"].asString());
+		if(!valueRecordsRecordsItem["UpdateTime"].isNull())
+			recordsObject.updateTime = std::stol(valueRecordsRecordsItem["UpdateTime"].asString());
+		records_.push_back(recordsObject);
+	}
+
+}
+
+std::vector<GenerateUpgradeRecordResult::RecordsItem> GenerateUpgradeRecordResult::getRecords()const
+{
+	return records_;
+}
+

dbfs/src/model/GetDbfsRequest.cc

@@ -19,9 +19,9 @@
 using AlibabaCloud::DBFS::Model::GetDbfsRequest;
 
 GetDbfsRequest::GetDbfsRequest() :
-	RpcServiceRequest("dbfs", "2020-02-19", "GetDbfs")
+	RpcServiceRequest("dbfs", "2020-04-18", "GetDbfs")
 {
-	setMethod(HttpRequest::Method::Get);
+	setMethod(HttpRequest::Method::Post);
 }
 
 GetDbfsRequest::~GetDbfsRequest()

dbfs/src/model/GetDbfsResult.cc

@@ -39,36 +39,81 @@ void GetDbfsResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	auto allDBFSInfoNode = value["DBFSInfo"]["Info"];
-	for (auto valueDBFSInfoInfo : allDBFSInfoNode)
+	auto dBFSInfoNode = value["DBFSInfo"];
+	if(!dBFSInfoNode["Status"].isNull())
+		dBFSInfo_.status = dBFSInfoNode["Status"].asString();
+	if(!dBFSInfoNode["PayType"].isNull())
+		dBFSInfo_.payType = dBFSInfoNode["PayType"].asString();
+	if(!dBFSInfoNode["FsId"].isNull())
+		dBFSInfo_.fsId = dBFSInfoNode["FsId"].asString();
+	if(!dBFSInfoNode["SizeG"].isNull())
+		dBFSInfo_.sizeG = std::stoi(dBFSInfoNode["SizeG"].asString());
+	if(!dBFSInfoNode["RegionId"].isNull())
+		dBFSInfo_.regionId = dBFSInfoNode["RegionId"].asString();
+	if(!dBFSInfoNode["DBFSClusterId"].isNull())
+		dBFSInfo_.dBFSClusterId = dBFSInfoNode["DBFSClusterId"].asString();
+	if(!dBFSInfoNode["Description"].isNull())
+		dBFSInfo_.description = dBFSInfoNode["Description"].asString();
+	if(!dBFSInfoNode["ZoneId"].isNull())
+		dBFSInfo_.zoneId = dBFSInfoNode["ZoneId"].asString();
+	if(!dBFSInfoNode["FsName"].isNull())
+		dBFSInfo_.fsName = dBFSInfoNode["FsName"].asString();
+	if(!dBFSInfoNode["Category"].isNull())
+		dBFSInfo_.category = dBFSInfoNode["Category"].asString();
+	if(!dBFSInfoNode["CreatedTime"].isNull())
+		dBFSInfo_.createdTime = dBFSInfoNode["CreatedTime"].asString();
+	if(!dBFSInfoNode["AttachNodeNumber"].isNull())
+		dBFSInfo_.attachNodeNumber = std::stoi(dBFSInfoNode["AttachNodeNumber"].asString());
+	if(!dBFSInfoNode["KMSKeyId"].isNull())
+		dBFSInfo_.kMSKeyId = dBFSInfoNode["KMSKeyId"].asString();
+	if(!dBFSInfoNode["Encryption"].isNull())
+		dBFSInfo_.encryption = dBFSInfoNode["Encryption"].asString() == "true";
+	if(!dBFSInfoNode["PerformanceLevel"].isNull())
+		dBFSInfo_.performanceLevel = dBFSInfoNode["PerformanceLevel"].asString();
+	if(!dBFSInfoNode["UsedScene"].isNull())
+		dBFSInfo_.usedScene = dBFSInfoNode["UsedScene"].asString();
+	if(!dBFSInfoNode["LastMountTime"].isNull())
+		dBFSInfo_.lastMountTime = dBFSInfoNode["LastMountTime"].asString();
+	if(!dBFSInfoNode["LastUmountTime"].isNull())
+		dBFSInfo_.lastUmountTime = dBFSInfoNode["LastUmountTime"].asString();
+	if(!dBFSInfoNode["EnableRaid"].isNull())
+		dBFSInfo_.enableRaid = dBFSInfoNode["EnableRaid"].asString() == "true";
+	if(!dBFSInfoNode["RaidStrip"].isNull())
+		dBFSInfo_.raidStrip = std::stoi(dBFSInfoNode["RaidStrip"].asString());
+	auto allTagsNode = dBFSInfoNode["Tags"]["TagList"];
+	for (auto dBFSInfoNodeTagsTagList : allTagsNode)
 	{
-		Info dBFSInfoObject;
-		if(!valueDBFSInfoInfo["FsName"].isNull())
-			dBFSInfoObject.fsName = valueDBFSInfoInfo["FsName"].asString();
-		if(!valueDBFSInfoInfo["DBFSClusterId"].isNull())
-			dBFSInfoObject.dBFSClusterId = valueDBFSInfoInfo["DBFSClusterId"].asString();
-		if(!valueDBFSInfoInfo["Category"].isNull())
-			dBFSInfoObject.category = valueDBFSInfoInfo["Category"].asString();
-		if(!valueDBFSInfoInfo["Status"].isNull())
-			dBFSInfoObject.status = valueDBFSInfoInfo["Status"].asString();
-		if(!valueDBFSInfoInfo["RegionId"].isNull())
-			dBFSInfoObject.regionId = valueDBFSInfoInfo["RegionId"].asString();
-		if(!valueDBFSInfoInfo["ZoneId"].isNull())
-			dBFSInfoObject.zoneId = valueDBFSInfoInfo["ZoneId"].asString();
-		if(!valueDBFSInfoInfo["AttachNodeNumber"].isNull())
-			dBFSInfoObject.attachNodeNumber = std::stoi(valueDBFSInfoInfo["AttachNodeNumber"].asString());
-		if(!valueDBFSInfoInfo["PayType"].isNull())
-			dBFSInfoObject.payType = valueDBFSInfoInfo["PayType"].asString();
-		if(!valueDBFSInfoInfo["FsId"].isNull())
-			dBFSInfoObject.fsId = valueDBFSInfoInfo["FsId"].asString();
-		if(!valueDBFSInfoInfo["SizeG"].isNull())
-			dBFSInfoObject.sizeG = std::stoi(valueDBFSInfoInfo["SizeG"].asString());
-		dBFSInfo_.push_back(dBFSInfoObject);
+		DBFSInfo::TagList tagListObject;
+		if(!dBFSInfoNodeTagsTagList["TagValue"].isNull())
+			tagListObject.tagValue = dBFSInfoNodeTagsTagList["TagValue"].asString();
+		if(!dBFSInfoNodeTagsTagList["Id"].isNull())
+			tagListObject.id = std::stoi(dBFSInfoNodeTagsTagList["Id"].asString());
+		if(!dBFSInfoNodeTagsTagList["TagKey"].isNull())
+			tagListObject.tagKey = dBFSInfoNodeTagsTagList["TagKey"].asString();
+		dBFSInfo_.tags.push_back(tagListObject);
+	}
+	auto allEcsListNode = dBFSInfoNode["EcsList"]["EcsListItem"];
+	for (auto dBFSInfoNodeEcsListEcsListItem : allEcsListNode)
+	{
+		DBFSInfo::EcsListItem ecsListItemObject;
+		if(!dBFSInfoNodeEcsListEcsListItem["EcsId"].isNull())
+			ecsListItemObject.ecsId = dBFSInfoNodeEcsListEcsListItem["EcsId"].asString();
+		dBFSInfo_.ecsList.push_back(ecsListItemObject);
+	}
+	auto allEbsListNode = dBFSInfoNode["EbsList"]["EbsListItem"];
+	for (auto dBFSInfoNodeEbsListEbsListItem : allEbsListNode)
+	{
+		DBFSInfo::EbsListItem ebsListItemObject;
+		if(!dBFSInfoNodeEbsListEbsListItem["EbsId"].isNull())
+			ebsListItemObject.ebsId = dBFSInfoNodeEbsListEbsListItem["EbsId"].asString();
+		if(!dBFSInfoNodeEbsListEbsListItem["SizeG"].isNull())
+			ebsListItemObject.sizeG = std::stoi(dBFSInfoNodeEbsListEbsListItem["SizeG"].asString());
+		dBFSInfo_.ebsList.push_back(ebsListItemObject);
 	}
 
 }
 
-std::vector<GetDbfsResult::Info> GetDbfsResult::getDBFSInfo()const
+GetDbfsResult::DBFSInfo GetDbfsResult::getDBFSInfo()const
 {
 	return dBFSInfo_;
 }

dbfs/src/model/GetServiceLinkedRoleRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * 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/dbfs/model/GetServiceLinkedRoleRequest.h>
+
+using AlibabaCloud::DBFS::Model::GetServiceLinkedRoleRequest;
+
+GetServiceLinkedRoleRequest::GetServiceLinkedRoleRequest() :
+	RpcServiceRequest("dbfs", "2020-04-18", "GetServiceLinkedRole")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetServiceLinkedRoleRequest::~GetServiceLinkedRoleRequest()
+{}
+
+std::string GetServiceLinkedRoleRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GetServiceLinkedRoleRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+

dbfs/src/model/GetServiceLinkedRoleResult.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/dbfs/model/GetServiceLinkedRoleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::DBFS;
+using namespace AlibabaCloud::DBFS::Model;
+
+GetServiceLinkedRoleResult::GetServiceLinkedRoleResult() :
+	ServiceResult()
+{}
+
+GetServiceLinkedRoleResult::GetServiceLinkedRoleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetServiceLinkedRoleResult::~GetServiceLinkedRoleResult()
+{}
+
+void GetServiceLinkedRoleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["AccountId"].isNull())
+		accountId_ = value["AccountId"].asString();
+	if(!value["RegionId"].isNull())
+		regionId_ = value["RegionId"].asString();
+	if(!value["DbfsLinkedRole"].isNull())
+		dbfsLinkedRole_ = value["DbfsLinkedRole"].asString() == "true";
+
+}
+
+std::string GetServiceLinkedRoleResult::getAccountId()const
+{
+	return accountId_;
+}
+
+bool GetServiceLinkedRoleResult::getDbfsLinkedRole()const
+{
+	return dbfsLinkedRole_;
+}
+
+std::string GetServiceLinkedRoleResult::getRegionId()const
+{
+	return regionId_;
+}
+

dbfs/src/model/GetSynchronizConstantsRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dbfs/model/GetSynchronizConstantsRequest.h>
+
+using AlibabaCloud::DBFS::Model::GetSynchronizConstantsRequest;
+
+GetSynchronizConstantsRequest::GetSynchronizConstantsRequest() :
+	RpcServiceRequest("dbfs", "2020-04-18", "GetSynchronizConstants")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetSynchronizConstantsRequest::~GetSynchronizConstantsRequest()
+{}
+
+int GetSynchronizConstantsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void GetSynchronizConstantsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string GetSynchronizConstantsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GetSynchronizConstantsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+int GetSynchronizConstantsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void GetSynchronizConstantsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+

dbfs/src/model/GetSynchronizConstantsResult.cc

@@ -0,0 +1,121 @@
+/*
+ * 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/dbfs/model/GetSynchronizConstantsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::DBFS;
+using namespace AlibabaCloud::DBFS::Model;
+
+GetSynchronizConstantsResult::GetSynchronizConstantsResult() :
+	ServiceResult()
+{}
+
+GetSynchronizConstantsResult::GetSynchronizConstantsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetSynchronizConstantsResult::~GetSynchronizConstantsResult()
+{}
+
+void GetSynchronizConstantsResult::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["PageSize"].isNull())
+		pageSize_ = std::stol(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stol(value["TotalCount"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stol(value["PageNumber"].asString());
+	if(!value["RegionData"].isNull())
+		regionData_ = value["RegionData"].asString();
+	if(!value["ZoneData"].isNull())
+		zoneData_ = value["ZoneData"].asString();
+	if(!value["OsversionData"].isNull())
+		osversionData_ = value["OsversionData"].asString();
+	if(!value["ProductCodeData"].isNull())
+		productCodeData_ = value["ProductCodeData"].asString();
+	if(!value["MasterData"].isNull())
+		masterData_ = value["MasterData"].asString();
+	if(!value["EndpointData"].isNull())
+		endpointData_ = value["EndpointData"].asString();
+	if(!value["AccessData"].isNull())
+		accessData_ = value["AccessData"].asString();
+
+}
+
+long GetSynchronizConstantsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::string GetSynchronizConstantsResult::getMasterData()const
+{
+	return masterData_;
+}
+
+long GetSynchronizConstantsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+std::string GetSynchronizConstantsResult::getZoneData()const
+{
+	return zoneData_;
+}
+
+long GetSynchronizConstantsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::string GetSynchronizConstantsResult::getAccessData()const
+{
+	return accessData_;
+}
+
+std::string GetSynchronizConstantsResult::getProductCodeData()const
+{
+	return productCodeData_;
+}
+
+std::string GetSynchronizConstantsResult::getOsversionData()const
+{
+	return osversionData_;
+}
+
+std::string GetSynchronizConstantsResult::getData()const
+{
+	return data_;
+}
+
+std::string GetSynchronizConstantsResult::getRegionData()const
+{
+	return regionData_;
+}
+
+std::string GetSynchronizConstantsResult::getEndpointData()const
+{
+	return endpointData_;
+}
+

dbfs/src/model/InsertSynchronizConstantsRequest.cc

@@ -0,0 +1,139 @@
+/*
+ * 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/dbfs/model/InsertSynchronizConstantsRequest.h>
+
+using AlibabaCloud::DBFS::Model::InsertSynchronizConstantsRequest;
+
+InsertSynchronizConstantsRequest::InsertSynchronizConstantsRequest() :
+	RpcServiceRequest("dbfs", "2020-04-18", "InsertSynchronizConstants")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+InsertSynchronizConstantsRequest::~InsertSynchronizConstantsRequest()
+{}
+
+std::string InsertSynchronizConstantsRequest::getZoneData()const
+{
+	return zoneData_;
+}
+
+void InsertSynchronizConstantsRequest::setZoneData(const std::string& zoneData)
+{
+	zoneData_ = zoneData;
+	setParameter("ZoneData", zoneData);
+}
+
+std::string InsertSynchronizConstantsRequest::getOsversionData()const
+{
+	return osversionData_;
+}
+
+void InsertSynchronizConstantsRequest::setOsversionData(const std::string& osversionData)
+{
+	osversionData_ = osversionData;
+	setParameter("OsversionData", osversionData);
+}
+
+std::string InsertSynchronizConstantsRequest::getEndpointData()const
+{
+	return endpointData_;
+}
+
+void InsertSynchronizConstantsRequest::setEndpointData(const std::string& endpointData)
+{
+	endpointData_ = endpointData;
+	setParameter("EndpointData", endpointData);
+}
+
+int InsertSynchronizConstantsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void InsertSynchronizConstantsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string InsertSynchronizConstantsRequest::getMasterData()const
+{
+	return masterData_;
+}
+
+void InsertSynchronizConstantsRequest::setMasterData(const std::string& masterData)
+{
+	masterData_ = masterData;
+	setParameter("MasterData", masterData);
+}
+
+std::string InsertSynchronizConstantsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void InsertSynchronizConstantsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string InsertSynchronizConstantsRequest::getProductCodeData()const
+{
+	return productCodeData_;
+}
+
+void InsertSynchronizConstantsRequest::setProductCodeData(const std::string& productCodeData)
+{
+	productCodeData_ = productCodeData;
+	setParameter("ProductCodeData", productCodeData);
+}
+
+int InsertSynchronizConstantsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void InsertSynchronizConstantsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string InsertSynchronizConstantsRequest::getAccessData()const
+{
+	return accessData_;
+}
+
+void InsertSynchronizConstantsRequest::setAccessData(const std::string& accessData)
+{
+	accessData_ = accessData;
+	setParameter("AccessData", accessData);
+}
+
+std::string InsertSynchronizConstantsRequest::getRegionData()const
+{
+	return regionData_;
+}
+
+void InsertSynchronizConstantsRequest::setRegionData(const std::string& regionData)
+{
+	regionData_ = regionData;
+	setParameter("RegionData", regionData);
+}
+

dbfs/src/model/InsertSynchronizConstantsResult.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dbfs/model/InsertSynchronizConstantsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::DBFS;
+using namespace AlibabaCloud::DBFS::Model;
+
+InsertSynchronizConstantsResult::InsertSynchronizConstantsResult() :
+	ServiceResult()
+{}
+
+InsertSynchronizConstantsResult::InsertSynchronizConstantsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+InsertSynchronizConstantsResult::~InsertSynchronizConstantsResult()
+{}
+
+void InsertSynchronizConstantsResult::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["PageSize"].isNull())
+		pageSize_ = std::stol(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stol(value["TotalCount"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stol(value["PageNumber"].asString());
+
+}
+
+long InsertSynchronizConstantsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+long InsertSynchronizConstantsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+long InsertSynchronizConstantsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::string InsertSynchronizConstantsResult::getData()const
+{
+	return data_;
+}
+

dbfs/src/model/ListConstantsRequest.cc

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dbfs/model/ListConstantsRequest.h>
+
+using AlibabaCloud::DBFS::Model::ListConstantsRequest;
+
+ListConstantsRequest::ListConstantsRequest() :
+	RpcServiceRequest("dbfs", "2020-04-18", "ListConstants")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListConstantsRequest::~ListConstantsRequest()
+{}
+
+int ListConstantsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListConstantsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string ListConstantsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ListConstantsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string ListConstantsRequest::getConstantsData()const
+{
+	return constantsData_;
+}
+
+void ListConstantsRequest::setConstantsData(const std::string& constantsData)
+{
+	constantsData_ = constantsData;
+	setParameter("ConstantsData", constantsData);
+}
+
+int ListConstantsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListConstantsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+

dbfs/src/model/ListConstantsResult.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dbfs/model/ListConstantsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::DBFS;
+using namespace AlibabaCloud::DBFS::Model;
+
+ListConstantsResult::ListConstantsResult() :
+	ServiceResult()
+{}
+
+ListConstantsResult::ListConstantsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListConstantsResult::~ListConstantsResult()
+{}
+
+void ListConstantsResult::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["PageSize"].isNull())
+		pageSize_ = std::stol(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stol(value["TotalCount"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stol(value["PageNumber"].asString());
+
+}
+
+long ListConstantsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+long ListConstantsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+long ListConstantsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::string ListConstantsResult::getData()const
+{
+	return data_;
+}
+

dbfs/src/model/ListDbfsRequest.cc

@@ -19,7 +19,7 @@
 using AlibabaCloud::DBFS::Model::ListDbfsRequest;
 
 ListDbfsRequest::ListDbfsRequest() :
-	RpcServiceRequest("dbfs", "2020-02-19", "ListDbfs")
+	RpcServiceRequest("dbfs", "2020-04-18", "ListDbfs")
 {
 	setMethod(HttpRequest::Method::Post);
 }
@@ -27,6 +27,72 @@ ListDbfsRequest::ListDbfsRequest() :
 ListDbfsRequest::~ListDbfsRequest()
 {}
 
+std::string ListDbfsRequest::getSortType()const
+{
+	return sortType_;
+}
+
+void ListDbfsRequest::setSortType(const std::string& sortType)
+{
+	sortType_ = sortType;
+	setParameter("SortType", sortType);
+}
+
+std::string ListDbfsRequest::getFilterValue()const
+{
+	return filterValue_;
+}
+
+void ListDbfsRequest::setFilterValue(const std::string& filterValue)
+{
+	filterValue_ = filterValue;
+	setParameter("FilterValue", filterValue);
+}
+
+int ListDbfsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListDbfsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string ListDbfsRequest::getTags()const
+{
+	return tags_;
+}
+
+void ListDbfsRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+
+std::string ListDbfsRequest::getFilterKey()const
+{
+	return filterKey_;
+}
+
+void ListDbfsRequest::setFilterKey(const std::string& filterKey)
+{
+	filterKey_ = filterKey;
+	setParameter("FilterKey", filterKey);
+}
+
+std::string ListDbfsRequest::getSortKey()const
+{
+	return sortKey_;
+}
+
+void ListDbfsRequest::setSortKey(const std::string& sortKey)
+{
+	sortKey_ = sortKey;
+	setParameter("SortKey", sortKey);
+}
+
 std::string ListDbfsRequest::getRegionId()const
 {
 	return regionId_;
@@ -38,3 +104,14 @@ void ListDbfsRequest::setRegionId(const std::string& regionId)
 	setParameter("RegionId", regionId);
 }
 
+int ListDbfsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListDbfsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+

dbfs/src/model/ListDbfsResult.cc

@@ -43,34 +43,82 @@ void ListDbfsResult::parse(const std::string &payload)
 	for (auto valueDBFSInfoInfo : allDBFSInfoNode)
 	{
 		Info dBFSInfoObject;
-		if(!valueDBFSInfoInfo["FsName"].isNull())
-			dBFSInfoObject.fsName = valueDBFSInfoInfo["FsName"].asString();
-		if(!valueDBFSInfoInfo["DBFSClusterId"].isNull())
-			dBFSInfoObject.dBFSClusterId = valueDBFSInfoInfo["DBFSClusterId"].asString();
-		if(!valueDBFSInfoInfo["Category"].isNull())
-			dBFSInfoObject.category = valueDBFSInfoInfo["Category"].asString();
 		if(!valueDBFSInfoInfo["Status"].isNull())
 			dBFSInfoObject.status = valueDBFSInfoInfo["Status"].asString();
-		if(!valueDBFSInfoInfo["RegionId"].isNull())
-			dBFSInfoObject.regionId = valueDBFSInfoInfo["RegionId"].asString();
-		if(!valueDBFSInfoInfo["ZoneId"].isNull())
-			dBFSInfoObject.zoneId = valueDBFSInfoInfo["ZoneId"].asString();
-		if(!valueDBFSInfoInfo["AttachNodeNumber"].isNull())
-			dBFSInfoObject.attachNodeNumber = std::stoi(valueDBFSInfoInfo["AttachNodeNumber"].asString());
+		if(!valueDBFSInfoInfo["Encryption"].isNull())
+			dBFSInfoObject.encryption = valueDBFSInfoInfo["Encryption"].asString() == "true";
 		if(!valueDBFSInfoInfo["PayType"].isNull())
 			dBFSInfoObject.payType = valueDBFSInfoInfo["PayType"].asString();
 		if(!valueDBFSInfoInfo["FsId"].isNull())
 			dBFSInfoObject.fsId = valueDBFSInfoInfo["FsId"].asString();
 		if(!valueDBFSInfoInfo["SizeG"].isNull())
 			dBFSInfoObject.sizeG = std::stoi(valueDBFSInfoInfo["SizeG"].asString());
+		if(!valueDBFSInfoInfo["RegionId"].isNull())
+			dBFSInfoObject.regionId = valueDBFSInfoInfo["RegionId"].asString();
+		if(!valueDBFSInfoInfo["DBFSClusterId"].isNull())
+			dBFSInfoObject.dBFSClusterId = valueDBFSInfoInfo["DBFSClusterId"].asString();
+		if(!valueDBFSInfoInfo["ZoneId"].isNull())
+			dBFSInfoObject.zoneId = valueDBFSInfoInfo["ZoneId"].asString();
+		if(!valueDBFSInfoInfo["FsName"].isNull())
+			dBFSInfoObject.fsName = valueDBFSInfoInfo["FsName"].asString();
+		if(!valueDBFSInfoInfo["Category"].isNull())
+			dBFSInfoObject.category = valueDBFSInfoInfo["Category"].asString();
+		if(!valueDBFSInfoInfo["CreatedTime"].isNull())
+			dBFSInfoObject.createdTime = valueDBFSInfoInfo["CreatedTime"].asString();
+		if(!valueDBFSInfoInfo["AttachNodeNumber"].isNull())
+			dBFSInfoObject.attachNodeNumber = std::stoi(valueDBFSInfoInfo["AttachNodeNumber"].asString());
+		if(!valueDBFSInfoInfo["KMSKeyId"].isNull())
+			dBFSInfoObject.kMSKeyId = valueDBFSInfoInfo["KMSKeyId"].asString();
+		if(!valueDBFSInfoInfo["PerformanceLevel"].isNull())
+			dBFSInfoObject.performanceLevel = valueDBFSInfoInfo["PerformanceLevel"].asString();
+		if(!valueDBFSInfoInfo["UsedScene"].isNull())
+			dBFSInfoObject.usedScene = valueDBFSInfoInfo["UsedScene"].asString();
+		if(!valueDBFSInfoInfo["LastMountTime"].isNull())
+			dBFSInfoObject.lastMountTime = valueDBFSInfoInfo["LastMountTime"].asString();
+		if(!valueDBFSInfoInfo["LastUmountTime"].isNull())
+			dBFSInfoObject.lastUmountTime = valueDBFSInfoInfo["LastUmountTime"].asString();
+		if(!valueDBFSInfoInfo["EnableRaid"].isNull())
+			dBFSInfoObject.enableRaid = valueDBFSInfoInfo["EnableRaid"].asString() == "true";
+		if(!valueDBFSInfoInfo["RaidStrip"].isNull())
+			dBFSInfoObject.raidStrip = std::stoi(valueDBFSInfoInfo["RaidStrip"].asString());
+		auto allTagsNode = valueDBFSInfoInfo["Tags"]["TagList"];
+		for (auto valueDBFSInfoInfoTagsTagList : allTagsNode)
+		{
+			Info::TagList tagsObject;
+			if(!valueDBFSInfoInfoTagsTagList["TagValue"].isNull())
+				tagsObject.tagValue = valueDBFSInfoInfoTagsTagList["TagValue"].asString();
+			if(!valueDBFSInfoInfoTagsTagList["Id"].isNull())
+				tagsObject.id = std::stol(valueDBFSInfoInfoTagsTagList["Id"].asString());
+			if(!valueDBFSInfoInfoTagsTagList["TagKey"].isNull())
+				tagsObject.tagKey = valueDBFSInfoInfoTagsTagList["TagKey"].asString();
+			dBFSInfoObject.tags.push_back(tagsObject);
+		}
+		auto allEcsListNode = valueDBFSInfoInfo["EcsList"]["EcsListItem"];
+		for (auto valueDBFSInfoInfoEcsListEcsListItem : allEcsListNode)
+		{
+			Info::EcsListItem ecsListObject;
+			if(!valueDBFSInfoInfoEcsListEcsListItem["EcsId"].isNull())
+				ecsListObject.ecsId = valueDBFSInfoInfoEcsListEcsListItem["EcsId"].asString();
+			dBFSInfoObject.ecsList.push_back(ecsListObject);
+		}
+		auto allEbsListNode = valueDBFSInfoInfo["EbsList"]["EbsListItem"];
+		for (auto valueDBFSInfoInfoEbsListEbsListItem : allEbsListNode)
+		{
+			Info::EbsListItem ebsListObject;
+			if(!valueDBFSInfoInfoEbsListEbsListItem["EbsId"].isNull())
+				ebsListObject.ebsId = valueDBFSInfoInfoEbsListEbsListItem["EbsId"].asString();
+			if(!valueDBFSInfoInfoEbsListEbsListItem["SizeG"].isNull())
+				ebsListObject.sizeG = std::stoi(valueDBFSInfoInfoEbsListEbsListItem["SizeG"].asString());
+			dBFSInfoObject.ebsList.push_back(ebsListObject);
+		}
 		dBFSInfo_.push_back(dBFSInfoObject);
 	}
 	if(!value["TotalCount"].isNull())
 		totalCount_ = std::stoi(value["TotalCount"].asString());
-	if(!value["PageNumber"].isNull())
-		pageNumber_ = std::stoi(value["PageNumber"].asString());
 	if(!value["PageSize"].isNull())
 		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
 
 }
 

dbfs/src/model/ListSnapshotRequest.cc

@@ -0,0 +1,161 @@
+/*
+ * 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/dbfs/model/ListSnapshotRequest.h>
+
+using AlibabaCloud::DBFS::Model::ListSnapshotRequest;
+
+ListSnapshotRequest::ListSnapshotRequest() :
+	RpcServiceRequest("dbfs", "2020-04-18", "ListSnapshot")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListSnapshotRequest::~ListSnapshotRequest()
+{}
+
+std::string ListSnapshotRequest::getSortType()const
+{
+	return sortType_;
+}
+
+void ListSnapshotRequest::setSortType(const std::string& sortType)
+{
+	sortType_ = sortType;
+	setParameter("SortType", sortType);
+}
+
+std::string ListSnapshotRequest::getSnapshotIds()const
+{
+	return snapshotIds_;
+}
+
+void ListSnapshotRequest::setSnapshotIds(const std::string& snapshotIds)
+{
+	snapshotIds_ = snapshotIds;
+	setParameter("SnapshotIds", snapshotIds);
+}
+
+std::string ListSnapshotRequest::getFilterValue()const
+{
+	return filterValue_;
+}
+
+void ListSnapshotRequest::setFilterValue(const std::string& filterValue)
+{
+	filterValue_ = filterValue;
+	setParameter("FilterValue", filterValue);
+}
+
+std::string ListSnapshotRequest::getSnapshotName()const
+{
+	return snapshotName_;
+}
+
+void ListSnapshotRequest::setSnapshotName(const std::string& snapshotName)
+{
+	snapshotName_ = snapshotName;
+	setParameter("SnapshotName", snapshotName);
+}
+
+int ListSnapshotRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListSnapshotRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string ListSnapshotRequest::getFilterKey()const
+{
+	return filterKey_;
+}
+
+void ListSnapshotRequest::setFilterKey(const std::string& filterKey)
+{
+	filterKey_ = filterKey;
+	setParameter("FilterKey", filterKey);
+}
+
+std::string ListSnapshotRequest::getSortKey()const
+{
+	return sortKey_;
+}
+
+void ListSnapshotRequest::setSortKey(const std::string& sortKey)
+{
+	sortKey_ = sortKey;
+	setParameter("SortKey", sortKey);
+}
+
+std::string ListSnapshotRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ListSnapshotRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+int ListSnapshotRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListSnapshotRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string ListSnapshotRequest::getFsId()const
+{
+	return fsId_;
+}
+
+void ListSnapshotRequest::setFsId(const std::string& fsId)
+{
+	fsId_ = fsId;
+	setParameter("FsId", fsId);
+}
+
+std::string ListSnapshotRequest::getSnapshotType()const
+{
+	return snapshotType_;
+}
+
+void ListSnapshotRequest::setSnapshotType(const std::string& snapshotType)
+{
+	snapshotType_ = snapshotType;
+	setParameter("SnapshotType", snapshotType);
+}
+
+std::string ListSnapshotRequest::getStatus()const
+{
+	return status_;
+}
+
+void ListSnapshotRequest::setStatus(const std::string& status)
+{
+	status_ = status;
+	setParameter("Status", status);
+}
+

dbfs/src/model/ListSnapshotResult.cc

@@ -0,0 +1,102 @@
+/*
+ * 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/dbfs/model/ListSnapshotResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::DBFS;
+using namespace AlibabaCloud::DBFS::Model;
+
+ListSnapshotResult::ListSnapshotResult() :
+	ServiceResult()
+{}
+
+ListSnapshotResult::ListSnapshotResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListSnapshotResult::~ListSnapshotResult()
+{}
+
+void ListSnapshotResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allSnapshotsNode = value["Snapshots"]["SnapshotsItem"];
+	for (auto valueSnapshotsSnapshotsItem : allSnapshotsNode)
+	{
+		SnapshotsItem snapshotsObject;
+		if(!valueSnapshotsSnapshotsItem["Category"].isNull())
+			snapshotsObject.category = valueSnapshotsSnapshotsItem["Category"].asString();
+		if(!valueSnapshotsSnapshotsItem["CreationTime"].isNull())
+			snapshotsObject.creationTime = valueSnapshotsSnapshotsItem["CreationTime"].asString();
+		if(!valueSnapshotsSnapshotsItem["Description"].isNull())
+			snapshotsObject.description = valueSnapshotsSnapshotsItem["Description"].asString();
+		if(!valueSnapshotsSnapshotsItem["LastModifiedTime"].isNull())
+			snapshotsObject.lastModifiedTime = valueSnapshotsSnapshotsItem["LastModifiedTime"].asString();
+		if(!valueSnapshotsSnapshotsItem["Progress"].isNull())
+			snapshotsObject.progress = valueSnapshotsSnapshotsItem["Progress"].asString();
+		if(!valueSnapshotsSnapshotsItem["RemainTime"].isNull())
+			snapshotsObject.remainTime = std::stoi(valueSnapshotsSnapshotsItem["RemainTime"].asString());
+		if(!valueSnapshotsSnapshotsItem["RetentionDays"].isNull())
+			snapshotsObject.retentionDays = std::stoi(valueSnapshotsSnapshotsItem["RetentionDays"].asString());
+		if(!valueSnapshotsSnapshotsItem["SnapshotId"].isNull())
+			snapshotsObject.snapshotId = valueSnapshotsSnapshotsItem["SnapshotId"].asString();
+		if(!valueSnapshotsSnapshotsItem["SnapshotName"].isNull())
+			snapshotsObject.snapshotName = valueSnapshotsSnapshotsItem["SnapshotName"].asString();
+		if(!valueSnapshotsSnapshotsItem["SnapshotType"].isNull())
+			snapshotsObject.snapshotType = valueSnapshotsSnapshotsItem["SnapshotType"].asString();
+		if(!valueSnapshotsSnapshotsItem["Status"].isNull())
+			snapshotsObject.status = valueSnapshotsSnapshotsItem["Status"].asString();
+		if(!valueSnapshotsSnapshotsItem["SourceFsId"].isNull())
+			snapshotsObject.sourceFsId = valueSnapshotsSnapshotsItem["SourceFsId"].asString();
+		if(!valueSnapshotsSnapshotsItem["SourceFsSize"].isNull())
+			snapshotsObject.sourceFsSize = std::stoi(valueSnapshotsSnapshotsItem["SourceFsSize"].asString());
+		snapshots_.push_back(snapshotsObject);
+	}
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+
+}
+
+int ListSnapshotResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int ListSnapshotResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int ListSnapshotResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<ListSnapshotResult::SnapshotsItem> ListSnapshotResult::getSnapshots()const
+{
+	return snapshots_;
+}
+

dbfs/src/model/ListTagKeysRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * 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/dbfs/model/ListTagKeysRequest.h>
+
+using AlibabaCloud::DBFS::Model::ListTagKeysRequest;
+
+ListTagKeysRequest::ListTagKeysRequest() :
+	RpcServiceRequest("dbfs", "2020-04-18", "ListTagKeys")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListTagKeysRequest::~ListTagKeysRequest()
+{}
+
+std::string ListTagKeysRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ListTagKeysRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+

dbfs/src/model/ListTagKeysResult.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/dbfs/model/ListTagKeysResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::DBFS;
+using namespace AlibabaCloud::DBFS::Model;
+
+ListTagKeysResult::ListTagKeysResult() :
+	ServiceResult()
+{}
+
+ListTagKeysResult::ListTagKeysResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListTagKeysResult::~ListTagKeysResult()
+{}
+
+void ListTagKeysResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTagKeys = value["TagKeys"]["TagKey"];
+	for (const auto &item : allTagKeys)
+		tagKeys_.push_back(item.asString());
+
+}
+
+std::vector<std::string> ListTagKeysResult::getTagKeys()const
+{
+	return tagKeys_;
+}
+

dbfs/src/model/ListTagValuesRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dbfs/model/ListTagValuesRequest.h>
+
+using AlibabaCloud::DBFS::Model::ListTagValuesRequest;
+
+ListTagValuesRequest::ListTagValuesRequest() :
+	RpcServiceRequest("dbfs", "2020-04-18", "ListTagValues")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListTagValuesRequest::~ListTagValuesRequest()
+{}
+
+std::string ListTagValuesRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ListTagValuesRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string ListTagValuesRequest::getTagKey()const
+{
+	return tagKey_;
+}
+
+void ListTagValuesRequest::setTagKey(const std::string& tagKey)
+{
+	tagKey_ = tagKey;
+	setParameter("TagKey", tagKey);
+}
+