Add SmartQ APIs.

VERSION

@@ -1 +1 @@
-1.36.2035
+1.36.2036

quickbi-public/CMakeLists.txt

@@ -85,6 +85,8 @@ set(quickbi-public_public_header_model
 	include/alibabacloud/quickbi-public/model/DeleteUserGroupMembersResult.h
 	include/alibabacloud/quickbi-public/model/DeleteUserTagMetaRequest.h
 	include/alibabacloud/quickbi-public/model/DeleteUserTagMetaResult.h
+	include/alibabacloud/quickbi-public/model/GetDataSourceConnectionInfoRequest.h
+	include/alibabacloud/quickbi-public/model/GetDataSourceConnectionInfoResult.h
 	include/alibabacloud/quickbi-public/model/GetMailTaskStatusRequest.h
 	include/alibabacloud/quickbi-public/model/GetMailTaskStatusResult.h
 	include/alibabacloud/quickbi-public/model/GetUserGroupInfoRequest.h
@@ -101,6 +103,8 @@ set(quickbi-public_public_header_model
 	include/alibabacloud/quickbi-public/model/ListCubeDataLevelPermissionConfigResult.h
 	include/alibabacloud/quickbi-public/model/ListDataLevelPermissionWhiteListRequest.h
 	include/alibabacloud/quickbi-public/model/ListDataLevelPermissionWhiteListResult.h
+	include/alibabacloud/quickbi-public/model/ListDataSourceRequest.h
+	include/alibabacloud/quickbi-public/model/ListDataSourceResult.h
 	include/alibabacloud/quickbi-public/model/ListFavoriteReportsRequest.h
 	include/alibabacloud/quickbi-public/model/ListFavoriteReportsResult.h
 	include/alibabacloud/quickbi-public/model/ListOrganizationRoleUsersRequest.h
@@ -153,12 +157,16 @@ set(quickbi-public_public_header_model
 	include/alibabacloud/quickbi-public/model/QueryDatasetInfoResult.h
 	include/alibabacloud/quickbi-public/model/QueryDatasetListRequest.h
 	include/alibabacloud/quickbi-public/model/QueryDatasetListResult.h
+	include/alibabacloud/quickbi-public/model/QueryDatasetSmartqStatusRequest.h
+	include/alibabacloud/quickbi-public/model/QueryDatasetSmartqStatusResult.h
 	include/alibabacloud/quickbi-public/model/QueryDatasetSwitchInfoRequest.h
 	include/alibabacloud/quickbi-public/model/QueryDatasetSwitchInfoResult.h
 	include/alibabacloud/quickbi-public/model/QueryEmbeddedInfoRequest.h
 	include/alibabacloud/quickbi-public/model/QueryEmbeddedInfoResult.h
 	include/alibabacloud/quickbi-public/model/QueryEmbeddedStatusRequest.h
 	include/alibabacloud/quickbi-public/model/QueryEmbeddedStatusResult.h
+	include/alibabacloud/quickbi-public/model/QueryLlmCubeWithThemeListByUserIdRequest.h
+	include/alibabacloud/quickbi-public/model/QueryLlmCubeWithThemeListByUserIdResult.h
 	include/alibabacloud/quickbi-public/model/QueryOrganizationRoleConfigRequest.h
 	include/alibabacloud/quickbi-public/model/QueryOrganizationRoleConfigResult.h
 	include/alibabacloud/quickbi-public/model/QueryOrganizationWorkspaceListRequest.h
@@ -171,6 +179,8 @@ set(quickbi-public_public_header_model
 	include/alibabacloud/quickbi-public/model/QueryShareListResult.h
 	include/alibabacloud/quickbi-public/model/QuerySharesToUserListRequest.h
 	include/alibabacloud/quickbi-public/model/QuerySharesToUserListResult.h
+	include/alibabacloud/quickbi-public/model/QuerySmartqPermissionByCubeIdRequest.h
+	include/alibabacloud/quickbi-public/model/QuerySmartqPermissionByCubeIdResult.h
 	include/alibabacloud/quickbi-public/model/QueryTicketInfoRequest.h
 	include/alibabacloud/quickbi-public/model/QueryTicketInfoResult.h
 	include/alibabacloud/quickbi-public/model/QueryUserGroupListByParentIdRequest.h
@@ -211,6 +221,10 @@ set(quickbi-public_public_header_model
 	include/alibabacloud/quickbi-public/model/SetDataLevelPermissionRuleConfigResult.h
 	include/alibabacloud/quickbi-public/model/SetDataLevelPermissionWhiteListRequest.h
 	include/alibabacloud/quickbi-public/model/SetDataLevelPermissionWhiteListResult.h
+	include/alibabacloud/quickbi-public/model/SmartqAuthTransferRequest.h
+	include/alibabacloud/quickbi-public/model/SmartqAuthTransferResult.h
+	include/alibabacloud/quickbi-public/model/SmartqAuthorizeRequest.h
+	include/alibabacloud/quickbi-public/model/SmartqAuthorizeResult.h
 	include/alibabacloud/quickbi-public/model/SmartqQueryAbilityRequest.h
 	include/alibabacloud/quickbi-public/model/SmartqQueryAbilityResult.h
 	include/alibabacloud/quickbi-public/model/UpdateDataLevelPermissionStatusRequest.h
@@ -300,6 +314,8 @@ set(quickbi-public_src
 	src/model/DeleteUserGroupMembersResult.cc
 	src/model/DeleteUserTagMetaRequest.cc
 	src/model/DeleteUserTagMetaResult.cc
+	src/model/GetDataSourceConnectionInfoRequest.cc
+	src/model/GetDataSourceConnectionInfoResult.cc
 	src/model/GetMailTaskStatusRequest.cc
 	src/model/GetMailTaskStatusResult.cc
 	src/model/GetUserGroupInfoRequest.cc
@@ -316,6 +332,8 @@ set(quickbi-public_src
 	src/model/ListCubeDataLevelPermissionConfigResult.cc
 	src/model/ListDataLevelPermissionWhiteListRequest.cc
 	src/model/ListDataLevelPermissionWhiteListResult.cc
+	src/model/ListDataSourceRequest.cc
+	src/model/ListDataSourceResult.cc
 	src/model/ListFavoriteReportsRequest.cc
 	src/model/ListFavoriteReportsResult.cc
 	src/model/ListOrganizationRoleUsersRequest.cc
@@ -368,12 +386,16 @@ set(quickbi-public_src
 	src/model/QueryDatasetInfoResult.cc
 	src/model/QueryDatasetListRequest.cc
 	src/model/QueryDatasetListResult.cc
+	src/model/QueryDatasetSmartqStatusRequest.cc
+	src/model/QueryDatasetSmartqStatusResult.cc
 	src/model/QueryDatasetSwitchInfoRequest.cc
 	src/model/QueryDatasetSwitchInfoResult.cc
 	src/model/QueryEmbeddedInfoRequest.cc
 	src/model/QueryEmbeddedInfoResult.cc
 	src/model/QueryEmbeddedStatusRequest.cc
 	src/model/QueryEmbeddedStatusResult.cc
+	src/model/QueryLlmCubeWithThemeListByUserIdRequest.cc
+	src/model/QueryLlmCubeWithThemeListByUserIdResult.cc
 	src/model/QueryOrganizationRoleConfigRequest.cc
 	src/model/QueryOrganizationRoleConfigResult.cc
 	src/model/QueryOrganizationWorkspaceListRequest.cc
@@ -386,6 +408,8 @@ set(quickbi-public_src
 	src/model/QueryShareListResult.cc
 	src/model/QuerySharesToUserListRequest.cc
 	src/model/QuerySharesToUserListResult.cc
+	src/model/QuerySmartqPermissionByCubeIdRequest.cc
+	src/model/QuerySmartqPermissionByCubeIdResult.cc
 	src/model/QueryTicketInfoRequest.cc
 	src/model/QueryTicketInfoResult.cc
 	src/model/QueryUserGroupListByParentIdRequest.cc
@@ -426,6 +450,10 @@ set(quickbi-public_src
 	src/model/SetDataLevelPermissionRuleConfigResult.cc
 	src/model/SetDataLevelPermissionWhiteListRequest.cc
 	src/model/SetDataLevelPermissionWhiteListResult.cc
+	src/model/SmartqAuthTransferRequest.cc
+	src/model/SmartqAuthTransferResult.cc
+	src/model/SmartqAuthorizeRequest.cc
+	src/model/SmartqAuthorizeResult.cc
 	src/model/SmartqQueryAbilityRequest.cc
 	src/model/SmartqQueryAbilityResult.cc
 	src/model/UpdateDataLevelPermissionStatusRequest.cc

quickbi-public/include/alibabacloud/quickbi-public/Quickbi_publicClient.h

@@ -86,6 +86,8 @@
 #include "model/DeleteUserGroupMembersResult.h"
 #include "model/DeleteUserTagMetaRequest.h"
 #include "model/DeleteUserTagMetaResult.h"
+#include "model/GetDataSourceConnectionInfoRequest.h"
+#include "model/GetDataSourceConnectionInfoResult.h"
 #include "model/GetMailTaskStatusRequest.h"
 #include "model/GetMailTaskStatusResult.h"
 #include "model/GetUserGroupInfoRequest.h"
@@ -102,6 +104,8 @@
 #include "model/ListCubeDataLevelPermissionConfigResult.h"
 #include "model/ListDataLevelPermissionWhiteListRequest.h"
 #include "model/ListDataLevelPermissionWhiteListResult.h"
+#include "model/ListDataSourceRequest.h"
+#include "model/ListDataSourceResult.h"
 #include "model/ListFavoriteReportsRequest.h"
 #include "model/ListFavoriteReportsResult.h"
 #include "model/ListOrganizationRoleUsersRequest.h"
@@ -154,12 +158,16 @@
 #include "model/QueryDatasetInfoResult.h"
 #include "model/QueryDatasetListRequest.h"
 #include "model/QueryDatasetListResult.h"
+#include "model/QueryDatasetSmartqStatusRequest.h"
+#include "model/QueryDatasetSmartqStatusResult.h"
 #include "model/QueryDatasetSwitchInfoRequest.h"
 #include "model/QueryDatasetSwitchInfoResult.h"
 #include "model/QueryEmbeddedInfoRequest.h"
 #include "model/QueryEmbeddedInfoResult.h"
 #include "model/QueryEmbeddedStatusRequest.h"
 #include "model/QueryEmbeddedStatusResult.h"
+#include "model/QueryLlmCubeWithThemeListByUserIdRequest.h"
+#include "model/QueryLlmCubeWithThemeListByUserIdResult.h"
 #include "model/QueryOrganizationRoleConfigRequest.h"
 #include "model/QueryOrganizationRoleConfigResult.h"
 #include "model/QueryOrganizationWorkspaceListRequest.h"
@@ -172,6 +180,8 @@
 #include "model/QueryShareListResult.h"
 #include "model/QuerySharesToUserListRequest.h"
 #include "model/QuerySharesToUserListResult.h"
+#include "model/QuerySmartqPermissionByCubeIdRequest.h"
+#include "model/QuerySmartqPermissionByCubeIdResult.h"
 #include "model/QueryTicketInfoRequest.h"
 #include "model/QueryTicketInfoResult.h"
 #include "model/QueryUserGroupListByParentIdRequest.h"
@@ -212,6 +222,10 @@
 #include "model/SetDataLevelPermissionRuleConfigResult.h"
 #include "model/SetDataLevelPermissionWhiteListRequest.h"
 #include "model/SetDataLevelPermissionWhiteListResult.h"
+#include "model/SmartqAuthTransferRequest.h"
+#include "model/SmartqAuthTransferResult.h"
+#include "model/SmartqAuthorizeRequest.h"
+#include "model/SmartqAuthorizeResult.h"
 #include "model/SmartqQueryAbilityRequest.h"
 #include "model/SmartqQueryAbilityResult.h"
 #include "model/UpdateDataLevelPermissionStatusRequest.h"
@@ -339,6 +353,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteUserTagMetaResult> DeleteUserTagMetaOutcome;
 			typedef std::future<DeleteUserTagMetaOutcome> DeleteUserTagMetaOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::DeleteUserTagMetaRequest&, const DeleteUserTagMetaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteUserTagMetaAsyncHandler;
+			typedef Outcome<Error, Model::GetDataSourceConnectionInfoResult> GetDataSourceConnectionInfoOutcome;
+			typedef std::future<GetDataSourceConnectionInfoOutcome> GetDataSourceConnectionInfoOutcomeCallable;
+			typedef std::function<void(const Quickbi_publicClient*, const Model::GetDataSourceConnectionInfoRequest&, const GetDataSourceConnectionInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDataSourceConnectionInfoAsyncHandler;
 			typedef Outcome<Error, Model::GetMailTaskStatusResult> GetMailTaskStatusOutcome;
 			typedef std::future<GetMailTaskStatusOutcome> GetMailTaskStatusOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::GetMailTaskStatusRequest&, const GetMailTaskStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMailTaskStatusAsyncHandler;
@@ -363,6 +380,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListDataLevelPermissionWhiteListResult> ListDataLevelPermissionWhiteListOutcome;
 			typedef std::future<ListDataLevelPermissionWhiteListOutcome> ListDataLevelPermissionWhiteListOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::ListDataLevelPermissionWhiteListRequest&, const ListDataLevelPermissionWhiteListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDataLevelPermissionWhiteListAsyncHandler;
+			typedef Outcome<Error, Model::ListDataSourceResult> ListDataSourceOutcome;
+			typedef std::future<ListDataSourceOutcome> ListDataSourceOutcomeCallable;
+			typedef std::function<void(const Quickbi_publicClient*, const Model::ListDataSourceRequest&, const ListDataSourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDataSourceAsyncHandler;
 			typedef Outcome<Error, Model::ListFavoriteReportsResult> ListFavoriteReportsOutcome;
 			typedef std::future<ListFavoriteReportsOutcome> ListFavoriteReportsOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::ListFavoriteReportsRequest&, const ListFavoriteReportsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFavoriteReportsAsyncHandler;
@@ -441,6 +461,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::QueryDatasetListResult> QueryDatasetListOutcome;
 			typedef std::future<QueryDatasetListOutcome> QueryDatasetListOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryDatasetListRequest&, const QueryDatasetListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryDatasetListAsyncHandler;
+			typedef Outcome<Error, Model::QueryDatasetSmartqStatusResult> QueryDatasetSmartqStatusOutcome;
+			typedef std::future<QueryDatasetSmartqStatusOutcome> QueryDatasetSmartqStatusOutcomeCallable;
+			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryDatasetSmartqStatusRequest&, const QueryDatasetSmartqStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryDatasetSmartqStatusAsyncHandler;
 			typedef Outcome<Error, Model::QueryDatasetSwitchInfoResult> QueryDatasetSwitchInfoOutcome;
 			typedef std::future<QueryDatasetSwitchInfoOutcome> QueryDatasetSwitchInfoOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryDatasetSwitchInfoRequest&, const QueryDatasetSwitchInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryDatasetSwitchInfoAsyncHandler;
@@ -450,6 +473,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::QueryEmbeddedStatusResult> QueryEmbeddedStatusOutcome;
 			typedef std::future<QueryEmbeddedStatusOutcome> QueryEmbeddedStatusOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryEmbeddedStatusRequest&, const QueryEmbeddedStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryEmbeddedStatusAsyncHandler;
+			typedef Outcome<Error, Model::QueryLlmCubeWithThemeListByUserIdResult> QueryLlmCubeWithThemeListByUserIdOutcome;
+			typedef std::future<QueryLlmCubeWithThemeListByUserIdOutcome> QueryLlmCubeWithThemeListByUserIdOutcomeCallable;
+			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryLlmCubeWithThemeListByUserIdRequest&, const QueryLlmCubeWithThemeListByUserIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryLlmCubeWithThemeListByUserIdAsyncHandler;
 			typedef Outcome<Error, Model::QueryOrganizationRoleConfigResult> QueryOrganizationRoleConfigOutcome;
 			typedef std::future<QueryOrganizationRoleConfigOutcome> QueryOrganizationRoleConfigOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryOrganizationRoleConfigRequest&, const QueryOrganizationRoleConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryOrganizationRoleConfigAsyncHandler;
@@ -468,6 +494,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::QuerySharesToUserListResult> QuerySharesToUserListOutcome;
 			typedef std::future<QuerySharesToUserListOutcome> QuerySharesToUserListOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::QuerySharesToUserListRequest&, const QuerySharesToUserListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QuerySharesToUserListAsyncHandler;
+			typedef Outcome<Error, Model::QuerySmartqPermissionByCubeIdResult> QuerySmartqPermissionByCubeIdOutcome;
+			typedef std::future<QuerySmartqPermissionByCubeIdOutcome> QuerySmartqPermissionByCubeIdOutcomeCallable;
+			typedef std::function<void(const Quickbi_publicClient*, const Model::QuerySmartqPermissionByCubeIdRequest&, const QuerySmartqPermissionByCubeIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QuerySmartqPermissionByCubeIdAsyncHandler;
 			typedef Outcome<Error, Model::QueryTicketInfoResult> QueryTicketInfoOutcome;
 			typedef std::future<QueryTicketInfoOutcome> QueryTicketInfoOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryTicketInfoRequest&, const QueryTicketInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryTicketInfoAsyncHandler;
@@ -528,6 +557,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::SetDataLevelPermissionWhiteListResult> SetDataLevelPermissionWhiteListOutcome;
 			typedef std::future<SetDataLevelPermissionWhiteListOutcome> SetDataLevelPermissionWhiteListOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::SetDataLevelPermissionWhiteListRequest&, const SetDataLevelPermissionWhiteListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetDataLevelPermissionWhiteListAsyncHandler;
+			typedef Outcome<Error, Model::SmartqAuthTransferResult> SmartqAuthTransferOutcome;
+			typedef std::future<SmartqAuthTransferOutcome> SmartqAuthTransferOutcomeCallable;
+			typedef std::function<void(const Quickbi_publicClient*, const Model::SmartqAuthTransferRequest&, const SmartqAuthTransferOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SmartqAuthTransferAsyncHandler;
+			typedef Outcome<Error, Model::SmartqAuthorizeResult> SmartqAuthorizeOutcome;
+			typedef std::future<SmartqAuthorizeOutcome> SmartqAuthorizeOutcomeCallable;
+			typedef std::function<void(const Quickbi_publicClient*, const Model::SmartqAuthorizeRequest&, const SmartqAuthorizeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SmartqAuthorizeAsyncHandler;
 			typedef Outcome<Error, Model::SmartqQueryAbilityResult> SmartqQueryAbilityOutcome;
 			typedef std::future<SmartqQueryAbilityOutcome> SmartqQueryAbilityOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::SmartqQueryAbilityRequest&, const SmartqQueryAbilityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SmartqQueryAbilityAsyncHandler;
@@ -662,6 +697,9 @@ namespace AlibabaCloud
 			DeleteUserTagMetaOutcome deleteUserTagMeta(const Model::DeleteUserTagMetaRequest &request)const;
 			void deleteUserTagMetaAsync(const Model::DeleteUserTagMetaRequest& request, const DeleteUserTagMetaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteUserTagMetaOutcomeCallable deleteUserTagMetaCallable(const Model::DeleteUserTagMetaRequest& request) const;
+			GetDataSourceConnectionInfoOutcome getDataSourceConnectionInfo(const Model::GetDataSourceConnectionInfoRequest &request)const;
+			void getDataSourceConnectionInfoAsync(const Model::GetDataSourceConnectionInfoRequest& request, const GetDataSourceConnectionInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetDataSourceConnectionInfoOutcomeCallable getDataSourceConnectionInfoCallable(const Model::GetDataSourceConnectionInfoRequest& request) const;
 			GetMailTaskStatusOutcome getMailTaskStatus(const Model::GetMailTaskStatusRequest &request)const;
 			void getMailTaskStatusAsync(const Model::GetMailTaskStatusRequest& request, const GetMailTaskStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetMailTaskStatusOutcomeCallable getMailTaskStatusCallable(const Model::GetMailTaskStatusRequest& request) const;
@@ -686,6 +724,9 @@ namespace AlibabaCloud
 			ListDataLevelPermissionWhiteListOutcome listDataLevelPermissionWhiteList(const Model::ListDataLevelPermissionWhiteListRequest &request)const;
 			void listDataLevelPermissionWhiteListAsync(const Model::ListDataLevelPermissionWhiteListRequest& request, const ListDataLevelPermissionWhiteListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListDataLevelPermissionWhiteListOutcomeCallable listDataLevelPermissionWhiteListCallable(const Model::ListDataLevelPermissionWhiteListRequest& request) const;
+			ListDataSourceOutcome listDataSource(const Model::ListDataSourceRequest &request)const;
+			void listDataSourceAsync(const Model::ListDataSourceRequest& request, const ListDataSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListDataSourceOutcomeCallable listDataSourceCallable(const Model::ListDataSourceRequest& request) const;
 			ListFavoriteReportsOutcome listFavoriteReports(const Model::ListFavoriteReportsRequest &request)const;
 			void listFavoriteReportsAsync(const Model::ListFavoriteReportsRequest& request, const ListFavoriteReportsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListFavoriteReportsOutcomeCallable listFavoriteReportsCallable(const Model::ListFavoriteReportsRequest& request) const;
@@ -764,6 +805,9 @@ namespace AlibabaCloud
 			QueryDatasetListOutcome queryDatasetList(const Model::QueryDatasetListRequest &request)const;
 			void queryDatasetListAsync(const Model::QueryDatasetListRequest& request, const QueryDatasetListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryDatasetListOutcomeCallable queryDatasetListCallable(const Model::QueryDatasetListRequest& request) const;
+			QueryDatasetSmartqStatusOutcome queryDatasetSmartqStatus(const Model::QueryDatasetSmartqStatusRequest &request)const;
+			void queryDatasetSmartqStatusAsync(const Model::QueryDatasetSmartqStatusRequest& request, const QueryDatasetSmartqStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryDatasetSmartqStatusOutcomeCallable queryDatasetSmartqStatusCallable(const Model::QueryDatasetSmartqStatusRequest& request) const;
 			QueryDatasetSwitchInfoOutcome queryDatasetSwitchInfo(const Model::QueryDatasetSwitchInfoRequest &request)const;
 			void queryDatasetSwitchInfoAsync(const Model::QueryDatasetSwitchInfoRequest& request, const QueryDatasetSwitchInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryDatasetSwitchInfoOutcomeCallable queryDatasetSwitchInfoCallable(const Model::QueryDatasetSwitchInfoRequest& request) const;
@@ -773,6 +817,9 @@ namespace AlibabaCloud
 			QueryEmbeddedStatusOutcome queryEmbeddedStatus(const Model::QueryEmbeddedStatusRequest &request)const;
 			void queryEmbeddedStatusAsync(const Model::QueryEmbeddedStatusRequest& request, const QueryEmbeddedStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryEmbeddedStatusOutcomeCallable queryEmbeddedStatusCallable(const Model::QueryEmbeddedStatusRequest& request) const;
+			QueryLlmCubeWithThemeListByUserIdOutcome queryLlmCubeWithThemeListByUserId(const Model::QueryLlmCubeWithThemeListByUserIdRequest &request)const;
+			void queryLlmCubeWithThemeListByUserIdAsync(const Model::QueryLlmCubeWithThemeListByUserIdRequest& request, const QueryLlmCubeWithThemeListByUserIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryLlmCubeWithThemeListByUserIdOutcomeCallable queryLlmCubeWithThemeListByUserIdCallable(const Model::QueryLlmCubeWithThemeListByUserIdRequest& request) const;
 			QueryOrganizationRoleConfigOutcome queryOrganizationRoleConfig(const Model::QueryOrganizationRoleConfigRequest &request)const;
 			void queryOrganizationRoleConfigAsync(const Model::QueryOrganizationRoleConfigRequest& request, const QueryOrganizationRoleConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryOrganizationRoleConfigOutcomeCallable queryOrganizationRoleConfigCallable(const Model::QueryOrganizationRoleConfigRequest& request) const;
@@ -791,6 +838,9 @@ namespace AlibabaCloud
 			QuerySharesToUserListOutcome querySharesToUserList(const Model::QuerySharesToUserListRequest &request)const;
 			void querySharesToUserListAsync(const Model::QuerySharesToUserListRequest& request, const QuerySharesToUserListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QuerySharesToUserListOutcomeCallable querySharesToUserListCallable(const Model::QuerySharesToUserListRequest& request) const;
+			QuerySmartqPermissionByCubeIdOutcome querySmartqPermissionByCubeId(const Model::QuerySmartqPermissionByCubeIdRequest &request)const;
+			void querySmartqPermissionByCubeIdAsync(const Model::QuerySmartqPermissionByCubeIdRequest& request, const QuerySmartqPermissionByCubeIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QuerySmartqPermissionByCubeIdOutcomeCallable querySmartqPermissionByCubeIdCallable(const Model::QuerySmartqPermissionByCubeIdRequest& request) const;
 			QueryTicketInfoOutcome queryTicketInfo(const Model::QueryTicketInfoRequest &request)const;
 			void queryTicketInfoAsync(const Model::QueryTicketInfoRequest& request, const QueryTicketInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryTicketInfoOutcomeCallable queryTicketInfoCallable(const Model::QueryTicketInfoRequest& request) const;
@@ -851,6 +901,12 @@ namespace AlibabaCloud
 			SetDataLevelPermissionWhiteListOutcome setDataLevelPermissionWhiteList(const Model::SetDataLevelPermissionWhiteListRequest &request)const;
 			void setDataLevelPermissionWhiteListAsync(const Model::SetDataLevelPermissionWhiteListRequest& request, const SetDataLevelPermissionWhiteListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetDataLevelPermissionWhiteListOutcomeCallable setDataLevelPermissionWhiteListCallable(const Model::SetDataLevelPermissionWhiteListRequest& request) const;
+			SmartqAuthTransferOutcome smartqAuthTransfer(const Model::SmartqAuthTransferRequest &request)const;
+			void smartqAuthTransferAsync(const Model::SmartqAuthTransferRequest& request, const SmartqAuthTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SmartqAuthTransferOutcomeCallable smartqAuthTransferCallable(const Model::SmartqAuthTransferRequest& request) const;
+			SmartqAuthorizeOutcome smartqAuthorize(const Model::SmartqAuthorizeRequest &request)const;
+			void smartqAuthorizeAsync(const Model::SmartqAuthorizeRequest& request, const SmartqAuthorizeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SmartqAuthorizeOutcomeCallable smartqAuthorizeCallable(const Model::SmartqAuthorizeRequest& request) const;
 			SmartqQueryAbilityOutcome smartqQueryAbility(const Model::SmartqQueryAbilityRequest &request)const;
 			void smartqQueryAbilityAsync(const Model::SmartqQueryAbilityRequest& request, const SmartqQueryAbilityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SmartqQueryAbilityOutcomeCallable smartqQueryAbilityCallable(const Model::SmartqQueryAbilityRequest& request) const;

quickbi-public/include/alibabacloud/quickbi-public/model/CancelAuthorizationMenuRequest.h

@@ -34,22 +34,22 @@ public:
 	void setDataPortalId(const std::string &dataPortalId);
 	std::string getAccessPoint() const;
 	void setAccessPoint(const std::string &accessPoint);
+	std::string getMenuIds() const;
+	void setMenuIds(const std::string &menuIds);
 	std::string getSignType() const;
 	void setSignType(const std::string &signType);
 	std::string getUserGroupIds() const;
 	void setUserGroupIds(const std::string &userGroupIds);
 	std::string getUserIds() const;
 	void setUserIds(const std::string &userIds);
-	std::string getMenuIds() const;
-	void setMenuIds(const std::string &menuIds);
 
 private:
 	std::string dataPortalId_;
 	std::string accessPoint_;
+	std::string menuIds_;
 	std::string signType_;
 	std::string userGroupIds_;
 	std::string userIds_;
-	std::string menuIds_;
 };
 } // namespace Model
 } // namespace Quickbi_public

quickbi-public/include/alibabacloud/quickbi-public/model/GetDataSourceConnectionInfoRequest.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_QUICKBI_PUBLIC_MODEL_GETDATASOURCECONNECTIONINFOREQUEST_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_GETDATASOURCECONNECTIONINFOREQUEST_H_
+
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Quickbi_public {
+namespace Model {
+class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT GetDataSourceConnectionInfoRequest : public RpcServiceRequest {
+public:
+	GetDataSourceConnectionInfoRequest();
+	~GetDataSourceConnectionInfoRequest();
+	std::string getDsId() const;
+	void setDsId(const std::string &dsId);
+	std::string getAccessPoint() const;
+	void setAccessPoint(const std::string &accessPoint);
+	std::string getSignType() const;
+	void setSignType(const std::string &signType);
+
+private:
+	std::string dsId_;
+	std::string accessPoint_;
+	std::string signType_;
+};
+} // namespace Model
+} // namespace Quickbi_public
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_GETDATASOURCECONNECTIONINFOREQUEST_H_

quickbi-public/include/alibabacloud/quickbi-public/model/GetDataSourceConnectionInfoResult.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_QUICKBI_PUBLIC_MODEL_GETDATASOURCECONNECTIONINFORESULT_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_GETDATASOURCECONNECTIONINFORESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Quickbi_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT GetDataSourceConnectionInfoResult : public ServiceResult
+			{
+			public:
+				struct Result
+				{
+					std::string modifyUser;
+					std::string address;
+					std::string instance;
+					std::string instanceId;
+					std::string creatorId;
+					std::string port;
+					std::string schema;
+					std::string workspaceId;
+					std::string dsId;
+					std::string parentDsType;
+					std::string dsVersion;
+					std::string showName;
+					std::string authLevel;
+					std::string dsType;
+					std::string project;
+					bool noSasl;
+				};
+
+
+				GetDataSourceConnectionInfoResult();
+				explicit GetDataSourceConnectionInfoResult(const std::string &payload);
+				~GetDataSourceConnectionInfoResult();
+				bool getSuccess()const;
+				Result getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+				Result result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_GETDATASOURCECONNECTIONINFORESULT_H_

quickbi-public/include/alibabacloud/quickbi-public/model/ListDataSourceRequest.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_QUICKBI_PUBLIC_MODEL_LISTDATASOURCEREQUEST_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_LISTDATASOURCEREQUEST_H_
+
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Quickbi_public {
+namespace Model {
+class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT ListDataSourceRequest : public RpcServiceRequest {
+public:
+	ListDataSourceRequest();
+	~ListDataSourceRequest();
+	std::string getDsType() const;
+	void setDsType(const std::string &dsType);
+	std::string getAccessPoint() const;
+	void setAccessPoint(const std::string &accessPoint);
+	std::string getSignType() const;
+	void setSignType(const std::string &signType);
+	std::string getWorkspaceId() const;
+	void setWorkspaceId(const std::string &workspaceId);
+
+private:
+	std::string dsType_;
+	std::string accessPoint_;
+	std::string signType_;
+	std::string workspaceId_;
+};
+} // namespace Model
+} // namespace Quickbi_public
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_LISTDATASOURCEREQUEST_H_

quickbi-public/include/alibabacloud/quickbi-public/model/ListDataSourceResult.h

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

quickbi-public/include/alibabacloud/quickbi-public/model/QueryAuditLogResult.h

@@ -41,6 +41,7 @@ namespace AlibabaCloud
 					std::string workspaceId;
 					std::string targetName;
 					std::string operatorType;
+					std::string targetId;
 				};
 
 

quickbi-public/include/alibabacloud/quickbi-public/model/QueryDatasetSmartqStatusRequest.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_QUICKBI_PUBLIC_MODEL_QUERYDATASETSMARTQSTATUSREQUEST_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATASETSMARTQSTATUSREQUEST_H_
+
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Quickbi_public {
+namespace Model {
+class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT QueryDatasetSmartqStatusRequest : public RpcServiceRequest {
+public:
+	QueryDatasetSmartqStatusRequest();
+	~QueryDatasetSmartqStatusRequest();
+	std::string getAccessPoint() const;
+	void setAccessPoint(const std::string &accessPoint);
+	std::string getSignType() const;
+	void setSignType(const std::string &signType);
+	std::string getCubeId() const;
+	void setCubeId(const std::string &cubeId);
+
+private:
+	std::string accessPoint_;
+	std::string signType_;
+	std::string cubeId_;
+};
+} // namespace Model
+} // namespace Quickbi_public
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATASETSMARTQSTATUSREQUEST_H_

quickbi-public/include/alibabacloud/quickbi-public/model/QueryDatasetSmartqStatusResult.h

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

quickbi-public/include/alibabacloud/quickbi-public/model/QueryLlmCubeWithThemeListByUserIdRequest.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_QUICKBI_PUBLIC_MODEL_QUERYLLMCUBEWITHTHEMELISTBYUSERIDREQUEST_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYLLMCUBEWITHTHEMELISTBYUSERIDREQUEST_H_
+
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Quickbi_public {
+namespace Model {
+class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT QueryLlmCubeWithThemeListByUserIdRequest : public RpcServiceRequest {
+public:
+	QueryLlmCubeWithThemeListByUserIdRequest();
+	~QueryLlmCubeWithThemeListByUserIdRequest();
+	std::string getAccessPoint() const;
+	void setAccessPoint(const std::string &accessPoint);
+	std::string getSignType() const;
+	void setSignType(const std::string &signType);
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+
+private:
+	std::string accessPoint_;
+	std::string signType_;
+	std::string userId_;
+};
+} // namespace Model
+} // namespace Quickbi_public
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYLLMCUBEWITHTHEMELISTBYUSERIDREQUEST_H_

quickbi-public/include/alibabacloud/quickbi-public/model/QueryLlmCubeWithThemeListByUserIdResult.h

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

quickbi-public/include/alibabacloud/quickbi-public/model/QuerySmartqPermissionByCubeIdRequest.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_QUICKBI_PUBLIC_MODEL_QUERYSMARTQPERMISSIONBYCUBEIDREQUEST_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYSMARTQPERMISSIONBYCUBEIDREQUEST_H_
+
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Quickbi_public {
+namespace Model {
+class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT QuerySmartqPermissionByCubeIdRequest : public RpcServiceRequest {
+public:
+	QuerySmartqPermissionByCubeIdRequest();
+	~QuerySmartqPermissionByCubeIdRequest();
+	std::string getAccessPoint() const;
+	void setAccessPoint(const std::string &accessPoint);
+	std::string getSignType() const;
+	void setSignType(const std::string &signType);
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	std::string getCubeId() const;
+	void setCubeId(const std::string &cubeId);
+
+private:
+	std::string accessPoint_;
+	std::string signType_;
+	std::string userId_;
+	std::string cubeId_;
+};
+} // namespace Model
+} // namespace Quickbi_public
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYSMARTQPERMISSIONBYCUBEIDREQUEST_H_

quickbi-public/include/alibabacloud/quickbi-public/model/QuerySmartqPermissionByCubeIdResult.h

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

quickbi-public/include/alibabacloud/quickbi-public/model/QueryWorksBloodRelationshipResult.h

@@ -40,6 +40,7 @@ namespace AlibabaCloud
 						std::string pathId;
 						std::string uid;
 						bool isMeasure;
+						std::string expression;
 						std::string areaId;
 						std::string dataType;
 						std::string caption;
@@ -48,6 +49,7 @@ namespace AlibabaCloud
 					std::string componentTypeName;
 					std::vector<Item::QueryParam> queryParams;
 					std::string componentName;
+					std::string componentTypeCnName;
 					std::string componentId;
 					std::string datasetId;
 				};

quickbi-public/include/alibabacloud/quickbi-public/model/SmartqAuthTransferRequest.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_QUICKBI_PUBLIC_MODEL_SMARTQAUTHTRANSFERREQUEST_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_SMARTQAUTHTRANSFERREQUEST_H_
+
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Quickbi_public {
+namespace Model {
+class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT SmartqAuthTransferRequest : public RpcServiceRequest {
+public:
+	SmartqAuthTransferRequest();
+	~SmartqAuthTransferRequest();
+	std::string getAccessPoint() const;
+	void setAccessPoint(const std::string &accessPoint);
+	std::string getTargetUserIds() const;
+	void setTargetUserIds(const std::string &targetUserIds);
+	std::string getSignType() const;
+	void setSignType(const std::string &signType);
+	std::string getOriginUserId() const;
+	void setOriginUserId(const std::string &originUserId);
+
+private:
+	std::string accessPoint_;
+	std::string targetUserIds_;
+	std::string signType_;
+	std::string originUserId_;
+};
+} // namespace Model
+} // namespace Quickbi_public
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_SMARTQAUTHTRANSFERREQUEST_H_

quickbi-public/include/alibabacloud/quickbi-public/model/SmartqAuthTransferResult.h

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

quickbi-public/include/alibabacloud/quickbi-public/model/SmartqAuthorizeRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_SMARTQAUTHORIZEREQUEST_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_SMARTQAUTHORIZEREQUEST_H_
+
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Quickbi_public {
+namespace Model {
+class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT SmartqAuthorizeRequest : public RpcServiceRequest {
+public:
+	SmartqAuthorizeRequest();
+	~SmartqAuthorizeRequest();
+	std::string getLlmCubeThemes() const;
+	void setLlmCubeThemes(const std::string &llmCubeThemes);
+	std::string getAccessPoint() const;
+	void setAccessPoint(const std::string &accessPoint);
+	std::string getLlmCubes() const;
+	void setLlmCubes(const std::string &llmCubes);
+	std::string getSignType() const;
+	void setSignType(const std::string &signType);
+	int getOperationType() const;
+	void setOperationType(int operationType);
+	std::string getExpireDay() const;
+	void setExpireDay(const std::string &expireDay);
+	std::string getUserIds() const;
+	void setUserIds(const std::string &userIds);
+
+private:
+	std::string llmCubeThemes_;
+	std::string accessPoint_;
+	std::string llmCubes_;
+	std::string signType_;
+	int operationType_;
+	std::string expireDay_;
+	std::string userIds_;
+};
+} // namespace Model
+} // namespace Quickbi_public
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_SMARTQAUTHORIZEREQUEST_H_

quickbi-public/include/alibabacloud/quickbi-public/model/SmartqAuthorizeResult.h

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

quickbi-public/include/alibabacloud/quickbi-public/model/UpdateWorkspaceUserRoleRequest.h

@@ -34,18 +34,21 @@ public:
 	void setRoleId(long roleId);
 	std::string getAccessPoint() const;
 	void setAccessPoint(const std::string &accessPoint);
-	std::string getSignType() const;
-	void setSignType(const std::string &signType);
 	std::string getUserId() const;
 	void setUserId(const std::string &userId);
+	std::string getRoleIds() const;
+	void setRoleIds(const std::string &roleIds);
+	std::string getSignType() const;
+	void setSignType(const std::string &signType);
 	std::string getWorkspaceId() const;
 	void setWorkspaceId(const std::string &workspaceId);
 
 private:
 	long roleId_;
 	std::string accessPoint_;
-	std::string signType_;
 	std::string userId_;
+	std::string roleIds_;
+	std::string signType_;
 	std::string workspaceId_;
 };
 } // namespace Model

quickbi-public/src/Quickbi-publicClient.cc

@@ -1203,6 +1203,42 @@ Quickbi_publicClient::DeleteUserTagMetaOutcomeCallable Quickbi_publicClient::del
 	return task->get_future();
 }
 
+Quickbi_publicClient::GetDataSourceConnectionInfoOutcome Quickbi_publicClient::getDataSourceConnectionInfo(const GetDataSourceConnectionInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetDataSourceConnectionInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetDataSourceConnectionInfoOutcome(GetDataSourceConnectionInfoResult(outcome.result()));
+	else
+		return GetDataSourceConnectionInfoOutcome(outcome.error());
+}
+
+void Quickbi_publicClient::getDataSourceConnectionInfoAsync(const GetDataSourceConnectionInfoRequest& request, const GetDataSourceConnectionInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getDataSourceConnectionInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Quickbi_publicClient::GetDataSourceConnectionInfoOutcomeCallable Quickbi_publicClient::getDataSourceConnectionInfoCallable(const GetDataSourceConnectionInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetDataSourceConnectionInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->getDataSourceConnectionInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Quickbi_publicClient::GetMailTaskStatusOutcome Quickbi_publicClient::getMailTaskStatus(const GetMailTaskStatusRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1491,6 +1527,42 @@ Quickbi_publicClient::ListDataLevelPermissionWhiteListOutcomeCallable Quickbi_pu
 	return task->get_future();
 }
 
+Quickbi_publicClient::ListDataSourceOutcome Quickbi_publicClient::listDataSource(const ListDataSourceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListDataSourceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListDataSourceOutcome(ListDataSourceResult(outcome.result()));
+	else
+		return ListDataSourceOutcome(outcome.error());
+}
+
+void Quickbi_publicClient::listDataSourceAsync(const ListDataSourceRequest& request, const ListDataSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listDataSource(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Quickbi_publicClient::ListDataSourceOutcomeCallable Quickbi_publicClient::listDataSourceCallable(const ListDataSourceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListDataSourceOutcome()>>(
+			[this, request]()
+			{
+			return this->listDataSource(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Quickbi_publicClient::ListFavoriteReportsOutcome Quickbi_publicClient::listFavoriteReports(const ListFavoriteReportsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2427,6 +2499,42 @@ Quickbi_publicClient::QueryDatasetListOutcomeCallable Quickbi_publicClient::quer
 	return task->get_future();
 }
 
+Quickbi_publicClient::QueryDatasetSmartqStatusOutcome Quickbi_publicClient::queryDatasetSmartqStatus(const QueryDatasetSmartqStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return QueryDatasetSmartqStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return QueryDatasetSmartqStatusOutcome(QueryDatasetSmartqStatusResult(outcome.result()));
+	else
+		return QueryDatasetSmartqStatusOutcome(outcome.error());
+}
+
+void Quickbi_publicClient::queryDatasetSmartqStatusAsync(const QueryDatasetSmartqStatusRequest& request, const QueryDatasetSmartqStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, queryDatasetSmartqStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Quickbi_publicClient::QueryDatasetSmartqStatusOutcomeCallable Quickbi_publicClient::queryDatasetSmartqStatusCallable(const QueryDatasetSmartqStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<QueryDatasetSmartqStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->queryDatasetSmartqStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Quickbi_publicClient::QueryDatasetSwitchInfoOutcome Quickbi_publicClient::queryDatasetSwitchInfo(const QueryDatasetSwitchInfoRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2535,6 +2643,42 @@ Quickbi_publicClient::QueryEmbeddedStatusOutcomeCallable Quickbi_publicClient::q
 	return task->get_future();
 }
 
+Quickbi_publicClient::QueryLlmCubeWithThemeListByUserIdOutcome Quickbi_publicClient::queryLlmCubeWithThemeListByUserId(const QueryLlmCubeWithThemeListByUserIdRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return QueryLlmCubeWithThemeListByUserIdOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return QueryLlmCubeWithThemeListByUserIdOutcome(QueryLlmCubeWithThemeListByUserIdResult(outcome.result()));
+	else
+		return QueryLlmCubeWithThemeListByUserIdOutcome(outcome.error());
+}
+
+void Quickbi_publicClient::queryLlmCubeWithThemeListByUserIdAsync(const QueryLlmCubeWithThemeListByUserIdRequest& request, const QueryLlmCubeWithThemeListByUserIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, queryLlmCubeWithThemeListByUserId(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Quickbi_publicClient::QueryLlmCubeWithThemeListByUserIdOutcomeCallable Quickbi_publicClient::queryLlmCubeWithThemeListByUserIdCallable(const QueryLlmCubeWithThemeListByUserIdRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<QueryLlmCubeWithThemeListByUserIdOutcome()>>(
+			[this, request]()
+			{
+			return this->queryLlmCubeWithThemeListByUserId(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Quickbi_publicClient::QueryOrganizationRoleConfigOutcome Quickbi_publicClient::queryOrganizationRoleConfig(const QueryOrganizationRoleConfigRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2751,6 +2895,42 @@ Quickbi_publicClient::QuerySharesToUserListOutcomeCallable Quickbi_publicClient:
 	return task->get_future();
 }
 
+Quickbi_publicClient::QuerySmartqPermissionByCubeIdOutcome Quickbi_publicClient::querySmartqPermissionByCubeId(const QuerySmartqPermissionByCubeIdRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return QuerySmartqPermissionByCubeIdOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return QuerySmartqPermissionByCubeIdOutcome(QuerySmartqPermissionByCubeIdResult(outcome.result()));
+	else
+		return QuerySmartqPermissionByCubeIdOutcome(outcome.error());
+}
+
+void Quickbi_publicClient::querySmartqPermissionByCubeIdAsync(const QuerySmartqPermissionByCubeIdRequest& request, const QuerySmartqPermissionByCubeIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, querySmartqPermissionByCubeId(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Quickbi_publicClient::QuerySmartqPermissionByCubeIdOutcomeCallable Quickbi_publicClient::querySmartqPermissionByCubeIdCallable(const QuerySmartqPermissionByCubeIdRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<QuerySmartqPermissionByCubeIdOutcome()>>(
+			[this, request]()
+			{
+			return this->querySmartqPermissionByCubeId(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Quickbi_publicClient::QueryTicketInfoOutcome Quickbi_publicClient::queryTicketInfo(const QueryTicketInfoRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3471,6 +3651,78 @@ Quickbi_publicClient::SetDataLevelPermissionWhiteListOutcomeCallable Quickbi_pub
 	return task->get_future();
 }
 
+Quickbi_publicClient::SmartqAuthTransferOutcome Quickbi_publicClient::smartqAuthTransfer(const SmartqAuthTransferRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SmartqAuthTransferOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SmartqAuthTransferOutcome(SmartqAuthTransferResult(outcome.result()));
+	else
+		return SmartqAuthTransferOutcome(outcome.error());
+}
+
+void Quickbi_publicClient::smartqAuthTransferAsync(const SmartqAuthTransferRequest& request, const SmartqAuthTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, smartqAuthTransfer(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Quickbi_publicClient::SmartqAuthTransferOutcomeCallable Quickbi_publicClient::smartqAuthTransferCallable(const SmartqAuthTransferRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SmartqAuthTransferOutcome()>>(
+			[this, request]()
+			{
+			return this->smartqAuthTransfer(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Quickbi_publicClient::SmartqAuthorizeOutcome Quickbi_publicClient::smartqAuthorize(const SmartqAuthorizeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SmartqAuthorizeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SmartqAuthorizeOutcome(SmartqAuthorizeResult(outcome.result()));
+	else
+		return SmartqAuthorizeOutcome(outcome.error());
+}
+
+void Quickbi_publicClient::smartqAuthorizeAsync(const SmartqAuthorizeRequest& request, const SmartqAuthorizeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, smartqAuthorize(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Quickbi_publicClient::SmartqAuthorizeOutcomeCallable Quickbi_publicClient::smartqAuthorizeCallable(const SmartqAuthorizeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SmartqAuthorizeOutcome()>>(
+			[this, request]()
+			{
+			return this->smartqAuthorize(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Quickbi_publicClient::SmartqQueryAbilityOutcome Quickbi_publicClient::smartqQueryAbility(const SmartqQueryAbilityRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

quickbi-public/src/model/CancelAuthorizationMenuRequest.cc

@@ -43,6 +43,15 @@ void CancelAuthorizationMenuRequest::setAccessPoint(const std::string &accessPoi
   setParameter(std::string("AccessPoint"), accessPoint);
 }
 
+std::string CancelAuthorizationMenuRequest::getMenuIds() const {
+  return menuIds_;
+}
+
+void CancelAuthorizationMenuRequest::setMenuIds(const std::string &menuIds) {
+  menuIds_ = menuIds;
+  setParameter(std::string("MenuIds"), menuIds);
+}
+
 std::string CancelAuthorizationMenuRequest::getSignType() const {
   return signType_;
 }
@@ -70,12 +79,3 @@ void CancelAuthorizationMenuRequest::setUserIds(const std::string &userIds) {
   setParameter(std::string("UserIds"), userIds);
 }
 
-std::string CancelAuthorizationMenuRequest::getMenuIds() const {
-  return menuIds_;
-}
-
-void CancelAuthorizationMenuRequest::setMenuIds(const std::string &menuIds) {
-  menuIds_ = menuIds;
-  setParameter(std::string("MenuIds"), menuIds);
-}
-

quickbi-public/src/model/GetDataSourceConnectionInfoRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/quickbi-public/model/GetDataSourceConnectionInfoRequest.h>
+
+using AlibabaCloud::Quickbi_public::Model::GetDataSourceConnectionInfoRequest;
+
+GetDataSourceConnectionInfoRequest::GetDataSourceConnectionInfoRequest()
+    : RpcServiceRequest("quickbi-public", "2022-01-01", "GetDataSourceConnectionInfo") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetDataSourceConnectionInfoRequest::~GetDataSourceConnectionInfoRequest() {}
+
+std::string GetDataSourceConnectionInfoRequest::getDsId() const {
+  return dsId_;
+}
+
+void GetDataSourceConnectionInfoRequest::setDsId(const std::string &dsId) {
+  dsId_ = dsId;
+  setParameter(std::string("DsId"), dsId);
+}
+
+std::string GetDataSourceConnectionInfoRequest::getAccessPoint() const {
+  return accessPoint_;
+}
+
+void GetDataSourceConnectionInfoRequest::setAccessPoint(const std::string &accessPoint) {
+  accessPoint_ = accessPoint;
+  setParameter(std::string("AccessPoint"), accessPoint);
+}
+
+std::string GetDataSourceConnectionInfoRequest::getSignType() const {
+  return signType_;
+}
+
+void GetDataSourceConnectionInfoRequest::setSignType(const std::string &signType) {
+  signType_ = signType;
+  setParameter(std::string("SignType"), signType);
+}
+

quickbi-public/src/model/GetDataSourceConnectionInfoResult.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/quickbi-public/model/GetDataSourceConnectionInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Quickbi_public;
+using namespace AlibabaCloud::Quickbi_public::Model;
+
+GetDataSourceConnectionInfoResult::GetDataSourceConnectionInfoResult() :
+	ServiceResult()
+{}
+
+GetDataSourceConnectionInfoResult::GetDataSourceConnectionInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetDataSourceConnectionInfoResult::~GetDataSourceConnectionInfoResult()
+{}
+
+void GetDataSourceConnectionInfoResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto resultNode = value["Result"];
+	if(!resultNode["Address"].isNull())
+		result_.address = resultNode["Address"].asString();
+	if(!resultNode["AuthLevel"].isNull())
+		result_.authLevel = resultNode["AuthLevel"].asString();
+	if(!resultNode["CreatorId"].isNull())
+		result_.creatorId = resultNode["CreatorId"].asString();
+	if(!resultNode["DsId"].isNull())
+		result_.dsId = resultNode["DsId"].asString();
+	if(!resultNode["DsType"].isNull())
+		result_.dsType = resultNode["DsType"].asString();
+	if(!resultNode["DsVersion"].isNull())
+		result_.dsVersion = resultNode["DsVersion"].asString();
+	if(!resultNode["Instance"].isNull())
+		result_.instance = resultNode["Instance"].asString();
+	if(!resultNode["InstanceId"].isNull())
+		result_.instanceId = resultNode["InstanceId"].asString();
+	if(!resultNode["ModifyUser"].isNull())
+		result_.modifyUser = resultNode["ModifyUser"].asString();
+	if(!resultNode["NoSasl"].isNull())
+		result_.noSasl = resultNode["NoSasl"].asString() == "true";
+	if(!resultNode["ParentDsType"].isNull())
+		result_.parentDsType = resultNode["ParentDsType"].asString();
+	if(!resultNode["Port"].isNull())
+		result_.port = resultNode["Port"].asString();
+	if(!resultNode["Project"].isNull())
+		result_.project = resultNode["Project"].asString();
+	if(!resultNode["Schema"].isNull())
+		result_.schema = resultNode["Schema"].asString();
+	if(!resultNode["ShowName"].isNull())
+		result_.showName = resultNode["ShowName"].asString();
+	if(!resultNode["WorkspaceId"].isNull())
+		result_.workspaceId = resultNode["WorkspaceId"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+bool GetDataSourceConnectionInfoResult::getSuccess()const
+{
+	return success_;
+}
+
+GetDataSourceConnectionInfoResult::Result GetDataSourceConnectionInfoResult::getResult()const
+{
+	return result_;
+}
+

quickbi-public/src/model/ListDataSourceRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/quickbi-public/model/ListDataSourceRequest.h>
+
+using AlibabaCloud::Quickbi_public::Model::ListDataSourceRequest;
+
+ListDataSourceRequest::ListDataSourceRequest()
+    : RpcServiceRequest("quickbi-public", "2022-01-01", "ListDataSource") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListDataSourceRequest::~ListDataSourceRequest() {}
+
+std::string ListDataSourceRequest::getDsType() const {
+  return dsType_;
+}
+
+void ListDataSourceRequest::setDsType(const std::string &dsType) {
+  dsType_ = dsType;
+  setParameter(std::string("DsType"), dsType);
+}
+
+std::string ListDataSourceRequest::getAccessPoint() const {
+  return accessPoint_;
+}
+
+void ListDataSourceRequest::setAccessPoint(const std::string &accessPoint) {
+  accessPoint_ = accessPoint;
+  setParameter(std::string("AccessPoint"), accessPoint);
+}
+
+std::string ListDataSourceRequest::getSignType() const {
+  return signType_;
+}
+
+void ListDataSourceRequest::setSignType(const std::string &signType) {
+  signType_ = signType;
+  setParameter(std::string("SignType"), signType);
+}
+
+std::string ListDataSourceRequest::getWorkspaceId() const {
+  return workspaceId_;
+}
+
+void ListDataSourceRequest::setWorkspaceId(const std::string &workspaceId) {
+  workspaceId_ = workspaceId;
+  setParameter(std::string("WorkspaceId"), workspaceId);
+}
+

quickbi-public/src/model/ListDataSourceResult.cc

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/quickbi-public/model/ListDataSourceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Quickbi_public;
+using namespace AlibabaCloud::Quickbi_public::Model;
+
+ListDataSourceResult::ListDataSourceResult() :
+	ServiceResult()
+{}
+
+ListDataSourceResult::ListDataSourceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListDataSourceResult::~ListDataSourceResult()
+{}
+
+void ListDataSourceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allResultNode = value["Result"]["Data"];
+	for (auto valueResultData : allResultNode)
+	{
+		Data resultObject;
+		if(!valueResultData["CreatorId"].isNull())
+			resultObject.creatorId = valueResultData["CreatorId"].asString();
+		if(!valueResultData["CreatorName"].isNull())
+			resultObject.creatorName = valueResultData["CreatorName"].asString();
+		if(!valueResultData["DatasourceId"].isNull())
+			resultObject.datasourceId = valueResultData["DatasourceId"].asString();
+		if(!valueResultData["GmtCreate"].isNull())
+			resultObject.gmtCreate = valueResultData["GmtCreate"].asString();
+		if(!valueResultData["GmtModified"].isNull())
+			resultObject.gmtModified = valueResultData["GmtModified"].asString();
+		if(!valueResultData["ShowName"].isNull())
+			resultObject.showName = valueResultData["ShowName"].asString();
+		if(!valueResultData["DsType"].isNull())
+			resultObject.dsType = valueResultData["DsType"].asString();
+		if(!valueResultData["ParentDsType"].isNull())
+			resultObject.parentDsType = valueResultData["ParentDsType"].asString();
+		result_.push_back(resultObject);
+	}
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+bool ListDataSourceResult::getSuccess()const
+{
+	return success_;
+}
+
+std::vector<ListDataSourceResult::Data> ListDataSourceResult::getResult()const
+{
+	return result_;
+}
+

quickbi-public/src/model/QueryAuditLogResult.cc

@@ -57,6 +57,8 @@ void QueryAuditLogResult::parse(const std::string &payload)
 			resultObject.targetType = valueResultLogApiResultModel["TargetType"].asString();
 		if(!valueResultLogApiResultModel["WorkspaceId"].isNull())
 			resultObject.workspaceId = valueResultLogApiResultModel["WorkspaceId"].asString();
+		if(!valueResultLogApiResultModel["TargetId"].isNull())
+			resultObject.targetId = valueResultLogApiResultModel["TargetId"].asString();
 		result_.push_back(resultObject);
 	}
 	if(!value["Success"].isNull())

quickbi-public/src/model/QueryDatasetSmartqStatusRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/quickbi-public/model/QueryDatasetSmartqStatusRequest.h>
+
+using AlibabaCloud::Quickbi_public::Model::QueryDatasetSmartqStatusRequest;
+
+QueryDatasetSmartqStatusRequest::QueryDatasetSmartqStatusRequest()
+    : RpcServiceRequest("quickbi-public", "2022-01-01", "QueryDatasetSmartqStatus") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+QueryDatasetSmartqStatusRequest::~QueryDatasetSmartqStatusRequest() {}
+
+std::string QueryDatasetSmartqStatusRequest::getAccessPoint() const {
+  return accessPoint_;
+}
+
+void QueryDatasetSmartqStatusRequest::setAccessPoint(const std::string &accessPoint) {
+  accessPoint_ = accessPoint;
+  setParameter(std::string("AccessPoint"), accessPoint);
+}
+
+std::string QueryDatasetSmartqStatusRequest::getSignType() const {
+  return signType_;
+}
+
+void QueryDatasetSmartqStatusRequest::setSignType(const std::string &signType) {
+  signType_ = signType;
+  setParameter(std::string("SignType"), signType);
+}
+
+std::string QueryDatasetSmartqStatusRequest::getCubeId() const {
+  return cubeId_;
+}
+
+void QueryDatasetSmartqStatusRequest::setCubeId(const std::string &cubeId) {
+  cubeId_ = cubeId;
+  setParameter(std::string("CubeId"), cubeId);
+}
+

quickbi-public/src/model/QueryDatasetSmartqStatusResult.cc

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

quickbi-public/src/model/QueryLlmCubeWithThemeListByUserIdRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/quickbi-public/model/QueryLlmCubeWithThemeListByUserIdRequest.h>
+
+using AlibabaCloud::Quickbi_public::Model::QueryLlmCubeWithThemeListByUserIdRequest;
+
+QueryLlmCubeWithThemeListByUserIdRequest::QueryLlmCubeWithThemeListByUserIdRequest()
+    : RpcServiceRequest("quickbi-public", "2022-01-01", "QueryLlmCubeWithThemeListByUserId") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+QueryLlmCubeWithThemeListByUserIdRequest::~QueryLlmCubeWithThemeListByUserIdRequest() {}
+
+std::string QueryLlmCubeWithThemeListByUserIdRequest::getAccessPoint() const {
+  return accessPoint_;
+}
+
+void QueryLlmCubeWithThemeListByUserIdRequest::setAccessPoint(const std::string &accessPoint) {
+  accessPoint_ = accessPoint;
+  setParameter(std::string("AccessPoint"), accessPoint);
+}
+
+std::string QueryLlmCubeWithThemeListByUserIdRequest::getSignType() const {
+  return signType_;
+}
+
+void QueryLlmCubeWithThemeListByUserIdRequest::setSignType(const std::string &signType) {
+  signType_ = signType;
+  setParameter(std::string("SignType"), signType);
+}
+
+std::string QueryLlmCubeWithThemeListByUserIdRequest::getUserId() const {
+  return userId_;
+}
+
+void QueryLlmCubeWithThemeListByUserIdRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+

quickbi-public/src/model/QueryLlmCubeWithThemeListByUserIdResult.cc

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

quickbi-public/src/model/QuerySmartqPermissionByCubeIdRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/quickbi-public/model/QuerySmartqPermissionByCubeIdRequest.h>
+
+using AlibabaCloud::Quickbi_public::Model::QuerySmartqPermissionByCubeIdRequest;
+
+QuerySmartqPermissionByCubeIdRequest::QuerySmartqPermissionByCubeIdRequest()
+    : RpcServiceRequest("quickbi-public", "2022-01-01", "QuerySmartqPermissionByCubeId") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+QuerySmartqPermissionByCubeIdRequest::~QuerySmartqPermissionByCubeIdRequest() {}
+
+std::string QuerySmartqPermissionByCubeIdRequest::getAccessPoint() const {
+  return accessPoint_;
+}
+
+void QuerySmartqPermissionByCubeIdRequest::setAccessPoint(const std::string &accessPoint) {
+  accessPoint_ = accessPoint;
+  setParameter(std::string("AccessPoint"), accessPoint);
+}
+
+std::string QuerySmartqPermissionByCubeIdRequest::getSignType() const {
+  return signType_;
+}
+
+void QuerySmartqPermissionByCubeIdRequest::setSignType(const std::string &signType) {
+  signType_ = signType;
+  setParameter(std::string("SignType"), signType);
+}
+
+std::string QuerySmartqPermissionByCubeIdRequest::getUserId() const {
+  return userId_;
+}
+
+void QuerySmartqPermissionByCubeIdRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+
+std::string QuerySmartqPermissionByCubeIdRequest::getCubeId() const {
+  return cubeId_;
+}
+
+void QuerySmartqPermissionByCubeIdRequest::setCubeId(const std::string &cubeId) {
+  cubeId_ = cubeId;
+  setParameter(std::string("CubeId"), cubeId);
+}
+

quickbi-public/src/model/QuerySmartqPermissionByCubeIdResult.cc

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

quickbi-public/src/model/QueryWorksBloodRelationshipResult.cc

@@ -51,6 +51,8 @@ void QueryWorksBloodRelationshipResult::parse(const std::string &payload)
 			resultObject.componentType = std::stoi(valueResultItem["ComponentType"].asString());
 		if(!valueResultItem["ComponentTypeName"].isNull())
 			resultObject.componentTypeName = valueResultItem["ComponentTypeName"].asString();
+		if(!valueResultItem["ComponentTypeCnName"].isNull())
+			resultObject.componentTypeCnName = valueResultItem["ComponentTypeCnName"].asString();
 		if(!valueResultItem["DatasetId"].isNull())
 			resultObject.datasetId = valueResultItem["DatasetId"].asString();
 		auto allQueryParamsNode = valueResultItem["QueryParams"]["QueryParam"];
@@ -71,6 +73,8 @@ void QueryWorksBloodRelationshipResult::parse(const std::string &payload)
 				queryParamsObject.pathId = valueResultItemQueryParamsQueryParam["PathId"].asString();
 			if(!valueResultItemQueryParamsQueryParam["Uid"].isNull())
 				queryParamsObject.uid = valueResultItemQueryParamsQueryParam["Uid"].asString();
+			if(!valueResultItemQueryParamsQueryParam["Expression"].isNull())
+				queryParamsObject.expression = valueResultItemQueryParamsQueryParam["Expression"].asString();
 			resultObject.queryParams.push_back(queryParamsObject);
 		}
 		result_.push_back(resultObject);

quickbi-public/src/model/SmartqAuthTransferRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/quickbi-public/model/SmartqAuthTransferRequest.h>
+
+using AlibabaCloud::Quickbi_public::Model::SmartqAuthTransferRequest;
+
+SmartqAuthTransferRequest::SmartqAuthTransferRequest()
+    : RpcServiceRequest("quickbi-public", "2022-01-01", "SmartqAuthTransfer") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+SmartqAuthTransferRequest::~SmartqAuthTransferRequest() {}
+
+std::string SmartqAuthTransferRequest::getAccessPoint() const {
+  return accessPoint_;
+}
+
+void SmartqAuthTransferRequest::setAccessPoint(const std::string &accessPoint) {
+  accessPoint_ = accessPoint;
+  setParameter(std::string("AccessPoint"), accessPoint);
+}
+
+std::string SmartqAuthTransferRequest::getTargetUserIds() const {
+  return targetUserIds_;
+}
+
+void SmartqAuthTransferRequest::setTargetUserIds(const std::string &targetUserIds) {
+  targetUserIds_ = targetUserIds;
+  setParameter(std::string("TargetUserIds"), targetUserIds);
+}
+
+std::string SmartqAuthTransferRequest::getSignType() const {
+  return signType_;
+}
+
+void SmartqAuthTransferRequest::setSignType(const std::string &signType) {
+  signType_ = signType;
+  setParameter(std::string("SignType"), signType);
+}
+
+std::string SmartqAuthTransferRequest::getOriginUserId() const {
+  return originUserId_;
+}
+
+void SmartqAuthTransferRequest::setOriginUserId(const std::string &originUserId) {
+  originUserId_ = originUserId;
+  setParameter(std::string("OriginUserId"), originUserId);
+}
+

quickbi-public/src/model/SmartqAuthTransferResult.cc

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

quickbi-public/src/model/SmartqAuthorizeRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * 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/quickbi-public/model/SmartqAuthorizeRequest.h>
+
+using AlibabaCloud::Quickbi_public::Model::SmartqAuthorizeRequest;
+
+SmartqAuthorizeRequest::SmartqAuthorizeRequest()
+    : RpcServiceRequest("quickbi-public", "2022-01-01", "SmartqAuthorize") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+SmartqAuthorizeRequest::~SmartqAuthorizeRequest() {}
+
+std::string SmartqAuthorizeRequest::getLlmCubeThemes() const {
+  return llmCubeThemes_;
+}
+
+void SmartqAuthorizeRequest::setLlmCubeThemes(const std::string &llmCubeThemes) {
+  llmCubeThemes_ = llmCubeThemes;
+  setParameter(std::string("LlmCubeThemes"), llmCubeThemes);
+}
+
+std::string SmartqAuthorizeRequest::getAccessPoint() const {
+  return accessPoint_;
+}
+
+void SmartqAuthorizeRequest::setAccessPoint(const std::string &accessPoint) {
+  accessPoint_ = accessPoint;
+  setParameter(std::string("AccessPoint"), accessPoint);
+}
+
+std::string SmartqAuthorizeRequest::getLlmCubes() const {
+  return llmCubes_;
+}
+
+void SmartqAuthorizeRequest::setLlmCubes(const std::string &llmCubes) {
+  llmCubes_ = llmCubes;
+  setParameter(std::string("LlmCubes"), llmCubes);
+}
+
+std::string SmartqAuthorizeRequest::getSignType() const {
+  return signType_;
+}
+
+void SmartqAuthorizeRequest::setSignType(const std::string &signType) {
+  signType_ = signType;
+  setParameter(std::string("SignType"), signType);
+}
+
+int SmartqAuthorizeRequest::getOperationType() const {
+  return operationType_;
+}
+
+void SmartqAuthorizeRequest::setOperationType(int operationType) {
+  operationType_ = operationType;
+  setParameter(std::string("OperationType"), std::to_string(operationType));
+}
+
+std::string SmartqAuthorizeRequest::getExpireDay() const {
+  return expireDay_;
+}
+
+void SmartqAuthorizeRequest::setExpireDay(const std::string &expireDay) {
+  expireDay_ = expireDay;
+  setParameter(std::string("ExpireDay"), expireDay);
+}
+
+std::string SmartqAuthorizeRequest::getUserIds() const {
+  return userIds_;
+}
+
+void SmartqAuthorizeRequest::setUserIds(const std::string &userIds) {
+  userIds_ = userIds;
+  setParameter(std::string("UserIds"), userIds);
+}
+

quickbi-public/src/model/SmartqAuthorizeResult.cc

@@ -0,0 +1,70 @@
+/*
+ * 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/quickbi-public/model/SmartqAuthorizeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Quickbi_public;
+using namespace AlibabaCloud::Quickbi_public::Model;
+
+SmartqAuthorizeResult::SmartqAuthorizeResult() :
+	ServiceResult()
+{}
+
+SmartqAuthorizeResult::SmartqAuthorizeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SmartqAuthorizeResult::~SmartqAuthorizeResult()
+{}
+
+void SmartqAuthorizeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allResultNode = value["Result"]["Data"];
+	for (auto valueResultData : allResultNode)
+	{
+		Data resultObject;
+		if(!valueResultData["UserId"].isNull())
+			resultObject.userId = valueResultData["UserId"].asString();
+		if(!valueResultData["LlmCube"].isNull())
+			resultObject.llmCube = valueResultData["LlmCube"].asString();
+		if(!valueResultData["LlmCubeTheme"].isNull())
+			resultObject.llmCubeTheme = valueResultData["LlmCubeTheme"].asString();
+		if(!valueResultData["DetailMessage"].isNull())
+			resultObject.detailMessage = valueResultData["DetailMessage"].asString();
+		result_.push_back(resultObject);
+	}
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+bool SmartqAuthorizeResult::getSuccess()const
+{
+	return success_;
+}
+
+std::vector<SmartqAuthorizeResult::Data> SmartqAuthorizeResult::getResult()const
+{
+	return result_;
+}
+

quickbi-public/src/model/UpdateWorkspaceUserRoleRequest.cc

@@ -43,15 +43,6 @@ void UpdateWorkspaceUserRoleRequest::setAccessPoint(const std::string &accessPoi
   setParameter(std::string("AccessPoint"), accessPoint);
 }
 
-std::string UpdateWorkspaceUserRoleRequest::getSignType() const {
-  return signType_;
-}
-
-void UpdateWorkspaceUserRoleRequest::setSignType(const std::string &signType) {
-  signType_ = signType;
-  setParameter(std::string("SignType"), signType);
-}
-
 std::string UpdateWorkspaceUserRoleRequest::getUserId() const {
   return userId_;
 }
@@ -61,6 +52,24 @@ void UpdateWorkspaceUserRoleRequest::setUserId(const std::string &userId) {
   setParameter(std::string("UserId"), userId);
 }
 
+std::string UpdateWorkspaceUserRoleRequest::getRoleIds() const {
+  return roleIds_;
+}
+
+void UpdateWorkspaceUserRoleRequest::setRoleIds(const std::string &roleIds) {
+  roleIds_ = roleIds;
+  setParameter(std::string("RoleIds"), roleIds);
+}
+
+std::string UpdateWorkspaceUserRoleRequest::getSignType() const {
+  return signType_;
+}
+
+void UpdateWorkspaceUserRoleRequest::setSignType(const std::string &signType) {
+  signType_ = signType;
+  setParameter(std::string("SignType"), signType);
+}
+
 std::string UpdateWorkspaceUserRoleRequest::getWorkspaceId() const {
   return workspaceId_;
 }