Add QueryData, ModifyCopilotEmbedConfig, QueryCopilotEmbedConfig and QueryDataRange APIs.

VERSION

@@ -1 +1 @@
-1.36.1967
+1.36.1968

quickbi-public/CMakeLists.txt

@@ -119,16 +119,24 @@ set(quickbi-public_public_header_model
 	include/alibabacloud/quickbi-public/model/ListWorkspaceRolesResult.h
 	include/alibabacloud/quickbi-public/model/ModifyApiDatasourceParametersRequest.h
 	include/alibabacloud/quickbi-public/model/ModifyApiDatasourceParametersResult.h
+	include/alibabacloud/quickbi-public/model/ModifyCopilotEmbedConfigRequest.h
+	include/alibabacloud/quickbi-public/model/ModifyCopilotEmbedConfigResult.h
 	include/alibabacloud/quickbi-public/model/QueryApprovalInfoRequest.h
 	include/alibabacloud/quickbi-public/model/QueryApprovalInfoResult.h
 	include/alibabacloud/quickbi-public/model/QueryAuditLogRequest.h
 	include/alibabacloud/quickbi-public/model/QueryAuditLogResult.h
 	include/alibabacloud/quickbi-public/model/QueryComponentPerformanceRequest.h
 	include/alibabacloud/quickbi-public/model/QueryComponentPerformanceResult.h
+	include/alibabacloud/quickbi-public/model/QueryCopilotEmbedConfigRequest.h
+	include/alibabacloud/quickbi-public/model/QueryCopilotEmbedConfigResult.h
 	include/alibabacloud/quickbi-public/model/QueryCubeOptimizationRequest.h
 	include/alibabacloud/quickbi-public/model/QueryCubeOptimizationResult.h
 	include/alibabacloud/quickbi-public/model/QueryCubePerformanceRequest.h
 	include/alibabacloud/quickbi-public/model/QueryCubePerformanceResult.h
+	include/alibabacloud/quickbi-public/model/QueryDataRequest.h
+	include/alibabacloud/quickbi-public/model/QueryDataResult.h
+	include/alibabacloud/quickbi-public/model/QueryDataRangeRequest.h
+	include/alibabacloud/quickbi-public/model/QueryDataRangeResult.h
 	include/alibabacloud/quickbi-public/model/QueryDataServiceRequest.h
 	include/alibabacloud/quickbi-public/model/QueryDataServiceResult.h
 	include/alibabacloud/quickbi-public/model/QueryDataServiceListRequest.h
@@ -318,16 +326,24 @@ set(quickbi-public_src
 	src/model/ListWorkspaceRolesResult.cc
 	src/model/ModifyApiDatasourceParametersRequest.cc
 	src/model/ModifyApiDatasourceParametersResult.cc
+	src/model/ModifyCopilotEmbedConfigRequest.cc
+	src/model/ModifyCopilotEmbedConfigResult.cc
 	src/model/QueryApprovalInfoRequest.cc
 	src/model/QueryApprovalInfoResult.cc
 	src/model/QueryAuditLogRequest.cc
 	src/model/QueryAuditLogResult.cc
 	src/model/QueryComponentPerformanceRequest.cc
 	src/model/QueryComponentPerformanceResult.cc
+	src/model/QueryCopilotEmbedConfigRequest.cc
+	src/model/QueryCopilotEmbedConfigResult.cc
 	src/model/QueryCubeOptimizationRequest.cc
 	src/model/QueryCubeOptimizationResult.cc
 	src/model/QueryCubePerformanceRequest.cc
 	src/model/QueryCubePerformanceResult.cc
+	src/model/QueryDataRequest.cc
+	src/model/QueryDataResult.cc
+	src/model/QueryDataRangeRequest.cc
+	src/model/QueryDataRangeResult.cc
 	src/model/QueryDataServiceRequest.cc
 	src/model/QueryDataServiceResult.cc
 	src/model/QueryDataServiceListRequest.cc

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

@@ -120,16 +120,24 @@
 #include "model/ListWorkspaceRolesResult.h"
 #include "model/ModifyApiDatasourceParametersRequest.h"
 #include "model/ModifyApiDatasourceParametersResult.h"
+#include "model/ModifyCopilotEmbedConfigRequest.h"
+#include "model/ModifyCopilotEmbedConfigResult.h"
 #include "model/QueryApprovalInfoRequest.h"
 #include "model/QueryApprovalInfoResult.h"
 #include "model/QueryAuditLogRequest.h"
 #include "model/QueryAuditLogResult.h"
 #include "model/QueryComponentPerformanceRequest.h"
 #include "model/QueryComponentPerformanceResult.h"
+#include "model/QueryCopilotEmbedConfigRequest.h"
+#include "model/QueryCopilotEmbedConfigResult.h"
 #include "model/QueryCubeOptimizationRequest.h"
 #include "model/QueryCubeOptimizationResult.h"
 #include "model/QueryCubePerformanceRequest.h"
 #include "model/QueryCubePerformanceResult.h"
+#include "model/QueryDataRequest.h"
+#include "model/QueryDataResult.h"
+#include "model/QueryDataRangeRequest.h"
+#include "model/QueryDataRangeResult.h"
 #include "model/QueryDataServiceRequest.h"
 #include "model/QueryDataServiceResult.h"
 #include "model/QueryDataServiceListRequest.h"
@@ -374,6 +382,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ModifyApiDatasourceParametersResult> ModifyApiDatasourceParametersOutcome;
 			typedef std::future<ModifyApiDatasourceParametersOutcome> ModifyApiDatasourceParametersOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::ModifyApiDatasourceParametersRequest&, const ModifyApiDatasourceParametersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyApiDatasourceParametersAsyncHandler;
+			typedef Outcome<Error, Model::ModifyCopilotEmbedConfigResult> ModifyCopilotEmbedConfigOutcome;
+			typedef std::future<ModifyCopilotEmbedConfigOutcome> ModifyCopilotEmbedConfigOutcomeCallable;
+			typedef std::function<void(const Quickbi_publicClient*, const Model::ModifyCopilotEmbedConfigRequest&, const ModifyCopilotEmbedConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyCopilotEmbedConfigAsyncHandler;
 			typedef Outcome<Error, Model::QueryApprovalInfoResult> QueryApprovalInfoOutcome;
 			typedef std::future<QueryApprovalInfoOutcome> QueryApprovalInfoOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryApprovalInfoRequest&, const QueryApprovalInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryApprovalInfoAsyncHandler;
@@ -383,12 +394,21 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::QueryComponentPerformanceResult> QueryComponentPerformanceOutcome;
 			typedef std::future<QueryComponentPerformanceOutcome> QueryComponentPerformanceOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryComponentPerformanceRequest&, const QueryComponentPerformanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryComponentPerformanceAsyncHandler;
+			typedef Outcome<Error, Model::QueryCopilotEmbedConfigResult> QueryCopilotEmbedConfigOutcome;
+			typedef std::future<QueryCopilotEmbedConfigOutcome> QueryCopilotEmbedConfigOutcomeCallable;
+			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryCopilotEmbedConfigRequest&, const QueryCopilotEmbedConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryCopilotEmbedConfigAsyncHandler;
 			typedef Outcome<Error, Model::QueryCubeOptimizationResult> QueryCubeOptimizationOutcome;
 			typedef std::future<QueryCubeOptimizationOutcome> QueryCubeOptimizationOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryCubeOptimizationRequest&, const QueryCubeOptimizationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryCubeOptimizationAsyncHandler;
 			typedef Outcome<Error, Model::QueryCubePerformanceResult> QueryCubePerformanceOutcome;
 			typedef std::future<QueryCubePerformanceOutcome> QueryCubePerformanceOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryCubePerformanceRequest&, const QueryCubePerformanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryCubePerformanceAsyncHandler;
+			typedef Outcome<Error, Model::QueryDataResult> QueryDataOutcome;
+			typedef std::future<QueryDataOutcome> QueryDataOutcomeCallable;
+			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryDataRequest&, const QueryDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryDataAsyncHandler;
+			typedef Outcome<Error, Model::QueryDataRangeResult> QueryDataRangeOutcome;
+			typedef std::future<QueryDataRangeOutcome> QueryDataRangeOutcomeCallable;
+			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryDataRangeRequest&, const QueryDataRangeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryDataRangeAsyncHandler;
 			typedef Outcome<Error, Model::QueryDataServiceResult> QueryDataServiceOutcome;
 			typedef std::future<QueryDataServiceOutcome> QueryDataServiceOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryDataServiceRequest&, const QueryDataServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryDataServiceAsyncHandler;
@@ -673,6 +693,9 @@ namespace AlibabaCloud
 			ModifyApiDatasourceParametersOutcome modifyApiDatasourceParameters(const Model::ModifyApiDatasourceParametersRequest &request)const;
 			void modifyApiDatasourceParametersAsync(const Model::ModifyApiDatasourceParametersRequest& request, const ModifyApiDatasourceParametersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyApiDatasourceParametersOutcomeCallable modifyApiDatasourceParametersCallable(const Model::ModifyApiDatasourceParametersRequest& request) const;
+			ModifyCopilotEmbedConfigOutcome modifyCopilotEmbedConfig(const Model::ModifyCopilotEmbedConfigRequest &request)const;
+			void modifyCopilotEmbedConfigAsync(const Model::ModifyCopilotEmbedConfigRequest& request, const ModifyCopilotEmbedConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyCopilotEmbedConfigOutcomeCallable modifyCopilotEmbedConfigCallable(const Model::ModifyCopilotEmbedConfigRequest& request) const;
 			QueryApprovalInfoOutcome queryApprovalInfo(const Model::QueryApprovalInfoRequest &request)const;
 			void queryApprovalInfoAsync(const Model::QueryApprovalInfoRequest& request, const QueryApprovalInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryApprovalInfoOutcomeCallable queryApprovalInfoCallable(const Model::QueryApprovalInfoRequest& request) const;
@@ -682,12 +705,21 @@ namespace AlibabaCloud
 			QueryComponentPerformanceOutcome queryComponentPerformance(const Model::QueryComponentPerformanceRequest &request)const;
 			void queryComponentPerformanceAsync(const Model::QueryComponentPerformanceRequest& request, const QueryComponentPerformanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryComponentPerformanceOutcomeCallable queryComponentPerformanceCallable(const Model::QueryComponentPerformanceRequest& request) const;
+			QueryCopilotEmbedConfigOutcome queryCopilotEmbedConfig(const Model::QueryCopilotEmbedConfigRequest &request)const;
+			void queryCopilotEmbedConfigAsync(const Model::QueryCopilotEmbedConfigRequest& request, const QueryCopilotEmbedConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryCopilotEmbedConfigOutcomeCallable queryCopilotEmbedConfigCallable(const Model::QueryCopilotEmbedConfigRequest& request) const;
 			QueryCubeOptimizationOutcome queryCubeOptimization(const Model::QueryCubeOptimizationRequest &request)const;
 			void queryCubeOptimizationAsync(const Model::QueryCubeOptimizationRequest& request, const QueryCubeOptimizationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryCubeOptimizationOutcomeCallable queryCubeOptimizationCallable(const Model::QueryCubeOptimizationRequest& request) const;
 			QueryCubePerformanceOutcome queryCubePerformance(const Model::QueryCubePerformanceRequest &request)const;
 			void queryCubePerformanceAsync(const Model::QueryCubePerformanceRequest& request, const QueryCubePerformanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryCubePerformanceOutcomeCallable queryCubePerformanceCallable(const Model::QueryCubePerformanceRequest& request) const;
+			QueryDataOutcome queryData(const Model::QueryDataRequest &request)const;
+			void queryDataAsync(const Model::QueryDataRequest& request, const QueryDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryDataOutcomeCallable queryDataCallable(const Model::QueryDataRequest& request) const;
+			QueryDataRangeOutcome queryDataRange(const Model::QueryDataRangeRequest &request)const;
+			void queryDataRangeAsync(const Model::QueryDataRangeRequest& request, const QueryDataRangeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryDataRangeOutcomeCallable queryDataRangeCallable(const Model::QueryDataRangeRequest& request) const;
 			QueryDataServiceOutcome queryDataService(const Model::QueryDataServiceRequest &request)const;
 			void queryDataServiceAsync(const Model::QueryDataServiceRequest& request, const QueryDataServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryDataServiceOutcomeCallable queryDataServiceCallable(const Model::QueryDataServiceRequest& request) const;

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

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_MODIFYCOPILOTEMBEDCONFIGREQUEST_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_MODIFYCOPILOTEMBEDCONFIGREQUEST_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 ModifyCopilotEmbedConfigRequest : public RpcServiceRequest {
+public:
+	ModifyCopilotEmbedConfigRequest();
+	~ModifyCopilotEmbedConfigRequest();
+	std::string getCopilotId() const;
+	void setCopilotId(const std::string &copilotId);
+	std::string getAgentName() const;
+	void setAgentName(const std::string &agentName);
+	std::string getAccessPoint() const;
+	void setAccessPoint(const std::string &accessPoint);
+	std::string getDataRange() const;
+	void setDataRange(const std::string &dataRange);
+	std::string getModuleName() const;
+	void setModuleName(const std::string &moduleName);
+	std::string getSignType() const;
+	void setSignType(const std::string &signType);
+
+private:
+	std::string copilotId_;
+	std::string agentName_;
+	std::string accessPoint_;
+	std::string dataRange_;
+	std::string moduleName_;
+	std::string signType_;
+};
+} // namespace Model
+} // namespace Quickbi_public
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_MODIFYCOPILOTEMBEDCONFIGREQUEST_H_

quickbi-public/include/alibabacloud/quickbi-public/model/ModifyCopilotEmbedConfigResult.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_MODIFYCOPILOTEMBEDCONFIGRESULT_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_MODIFYCOPILOTEMBEDCONFIGRESULT_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 ModifyCopilotEmbedConfigResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyCopilotEmbedConfigResult();
+				explicit ModifyCopilotEmbedConfigResult(const std::string &payload);
+				~ModifyCopilotEmbedConfigResult();
+				bool getSuccess()const;
+				bool getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+				bool result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_MODIFYCOPILOTEMBEDCONFIGRESULT_H_

quickbi-public/include/alibabacloud/quickbi-public/model/QueryCopilotEmbedConfigRequest.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_QUERYCOPILOTEMBEDCONFIGREQUEST_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYCOPILOTEMBEDCONFIGREQUEST_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 QueryCopilotEmbedConfigRequest : public RpcServiceRequest {
+public:
+	QueryCopilotEmbedConfigRequest();
+	~QueryCopilotEmbedConfigRequest();
+	std::string getAccessPoint() const;
+	void setAccessPoint(const std::string &accessPoint);
+	std::string getSignType() const;
+	void setSignType(const std::string &signType);
+	std::string getKeyword() const;
+	void setKeyword(const std::string &keyword);
+
+private:
+	std::string accessPoint_;
+	std::string signType_;
+	std::string keyword_;
+};
+} // namespace Model
+} // namespace Quickbi_public
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYCOPILOTEMBEDCONFIGREQUEST_H_

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

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYCOPILOTEMBEDCONFIGRESULT_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYCOPILOTEMBEDCONFIGRESULT_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 QueryCopilotEmbedConfigResult : public ServiceResult
+			{
+			public:
+				struct ResultItem
+				{
+					struct DataRange
+					{
+						std::vector<std::string> llmCubes;
+						bool allTheme;
+						bool allCube;
+						std::vector<std::string> themes;
+					};
+					std::string modifyUser;
+					std::string moduleName;
+					std::string createUser;
+					DataRange dataRange;
+					std::string agentName;
+					std::string showName;
+					std::string createUserName;
+					std::string copilotId;
+				};
+
+
+				QueryCopilotEmbedConfigResult();
+				explicit QueryCopilotEmbedConfigResult(const std::string &payload);
+				~QueryCopilotEmbedConfigResult();
+				bool getSuccess()const;
+				std::vector<ResultItem> getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+				std::vector<ResultItem> result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYCOPILOTEMBEDCONFIGRESULT_H_

quickbi-public/include/alibabacloud/quickbi-public/model/QueryDataRangeRequest.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_QUERYDATARANGEREQUEST_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATARANGEREQUEST_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 QueryDataRangeRequest : public RpcServiceRequest {
+public:
+	QueryDataRangeRequest();
+	~QueryDataRangeRequest();
+	std::string getAccessPoint() const;
+	void setAccessPoint(const std::string &accessPoint);
+	std::string getSignType() const;
+	void setSignType(const std::string &signType);
+	std::string getType() const;
+	void setType(const std::string &type);
+	std::string getKeyword() const;
+	void setKeyword(const std::string &keyword);
+
+private:
+	std::string accessPoint_;
+	std::string signType_;
+	std::string type_;
+	std::string keyword_;
+};
+} // namespace Model
+} // namespace Quickbi_public
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATARANGEREQUEST_H_

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

@@ -0,0 +1,77 @@
+/*
+ * 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_QUERYDATARANGERESULT_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATARANGERESULT_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 QueryDataRangeResult : public ServiceResult
+			{
+			public:
+				struct Result
+				{
+					struct ApiCopilotLlmCubeModelsItem
+					{
+						std::string alias;
+						std::string llmCubeId;
+						std::string createUser;
+					};
+					struct ApiCopilotThemeModelsItem
+					{
+						struct ApiCopilotLlmCubeModelsItem2
+						{
+							std::string alias;
+							std::string llmCubeId;
+							std::string createUser;
+						};
+						std::string themeId;
+						std::string createUser;
+						std::vector<ApiCopilotThemeModelsItem::ApiCopilotLlmCubeModelsItem2> apiCopilotLlmCubeModels1;
+						std::string themeName;
+					};
+					std::vector<ApiCopilotThemeModelsItem> apiCopilotThemeModels;
+					std::vector<ApiCopilotLlmCubeModelsItem> apiCopilotLlmCubeModels;
+				};
+
+
+				QueryDataRangeResult();
+				explicit QueryDataRangeResult(const std::string &payload);
+				~QueryDataRangeResult();
+				bool getSuccess()const;
+				Result getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+				Result result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATARANGERESULT_H_

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

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATAREQUEST_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATAREQUEST_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 QueryDataRequest : public RpcServiceRequest {
+public:
+	QueryDataRequest();
+	~QueryDataRequest();
+	std::string getReturnFields() const;
+	void setReturnFields(const std::string &returnFields);
+	std::string getAccessPoint() const;
+	void setAccessPoint(const std::string &accessPoint);
+	std::string getSignType() const;
+	void setSignType(const std::string &signType);
+	std::string getConditions() const;
+	void setConditions(const std::string &conditions);
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	std::string getApiId() const;
+	void setApiId(const std::string &apiId);
+
+private:
+	std::string returnFields_;
+	std::string accessPoint_;
+	std::string signType_;
+	std::string conditions_;
+	std::string userId_;
+	std::string apiId_;
+};
+} // namespace Model
+} // namespace Quickbi_public
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATAREQUEST_H_

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

@@ -0,0 +1,68 @@
+/*
+ * 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_QUERYDATARESULT_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATARESULT_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 QueryDataResult : public ServiceResult
+			{
+			public:
+				struct Result
+				{
+					struct HeadersItem
+					{
+						std::string type;
+						std::string column;
+						std::string label;
+						std::string dataType;
+						std::string aggregator;
+						std::string granularity;
+					};
+					std::vector<HeadersItem> headers;
+					std::vector<std::string> values;
+					std::string sql;
+				};
+
+
+				QueryDataResult();
+				explicit QueryDataResult(const std::string &payload);
+				~QueryDataResult();
+				bool getSuccess()const;
+				Result getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+				Result result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATARESULT_H_

quickbi-public/src/Quickbi-publicClient.cc

@@ -1815,6 +1815,42 @@ Quickbi_publicClient::ModifyApiDatasourceParametersOutcomeCallable Quickbi_publi
 	return task->get_future();
 }
 
+Quickbi_publicClient::ModifyCopilotEmbedConfigOutcome Quickbi_publicClient::modifyCopilotEmbedConfig(const ModifyCopilotEmbedConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyCopilotEmbedConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyCopilotEmbedConfigOutcome(ModifyCopilotEmbedConfigResult(outcome.result()));
+	else
+		return ModifyCopilotEmbedConfigOutcome(outcome.error());
+}
+
+void Quickbi_publicClient::modifyCopilotEmbedConfigAsync(const ModifyCopilotEmbedConfigRequest& request, const ModifyCopilotEmbedConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyCopilotEmbedConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Quickbi_publicClient::ModifyCopilotEmbedConfigOutcomeCallable Quickbi_publicClient::modifyCopilotEmbedConfigCallable(const ModifyCopilotEmbedConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyCopilotEmbedConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyCopilotEmbedConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Quickbi_publicClient::QueryApprovalInfoOutcome Quickbi_publicClient::queryApprovalInfo(const QueryApprovalInfoRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1923,6 +1959,42 @@ Quickbi_publicClient::QueryComponentPerformanceOutcomeCallable Quickbi_publicCli
 	return task->get_future();
 }
 
+Quickbi_publicClient::QueryCopilotEmbedConfigOutcome Quickbi_publicClient::queryCopilotEmbedConfig(const QueryCopilotEmbedConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return QueryCopilotEmbedConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return QueryCopilotEmbedConfigOutcome(QueryCopilotEmbedConfigResult(outcome.result()));
+	else
+		return QueryCopilotEmbedConfigOutcome(outcome.error());
+}
+
+void Quickbi_publicClient::queryCopilotEmbedConfigAsync(const QueryCopilotEmbedConfigRequest& request, const QueryCopilotEmbedConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, queryCopilotEmbedConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Quickbi_publicClient::QueryCopilotEmbedConfigOutcomeCallable Quickbi_publicClient::queryCopilotEmbedConfigCallable(const QueryCopilotEmbedConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<QueryCopilotEmbedConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->queryCopilotEmbedConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Quickbi_publicClient::QueryCubeOptimizationOutcome Quickbi_publicClient::queryCubeOptimization(const QueryCubeOptimizationRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1995,6 +2067,78 @@ Quickbi_publicClient::QueryCubePerformanceOutcomeCallable Quickbi_publicClient::
 	return task->get_future();
 }
 
+Quickbi_publicClient::QueryDataOutcome Quickbi_publicClient::queryData(const QueryDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return QueryDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return QueryDataOutcome(QueryDataResult(outcome.result()));
+	else
+		return QueryDataOutcome(outcome.error());
+}
+
+void Quickbi_publicClient::queryDataAsync(const QueryDataRequest& request, const QueryDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, queryData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Quickbi_publicClient::QueryDataOutcomeCallable Quickbi_publicClient::queryDataCallable(const QueryDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<QueryDataOutcome()>>(
+			[this, request]()
+			{
+			return this->queryData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Quickbi_publicClient::QueryDataRangeOutcome Quickbi_publicClient::queryDataRange(const QueryDataRangeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return QueryDataRangeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return QueryDataRangeOutcome(QueryDataRangeResult(outcome.result()));
+	else
+		return QueryDataRangeOutcome(outcome.error());
+}
+
+void Quickbi_publicClient::queryDataRangeAsync(const QueryDataRangeRequest& request, const QueryDataRangeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, queryDataRange(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Quickbi_publicClient::QueryDataRangeOutcomeCallable Quickbi_publicClient::queryDataRangeCallable(const QueryDataRangeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<QueryDataRangeOutcome()>>(
+			[this, request]()
+			{
+			return this->queryDataRange(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Quickbi_publicClient::QueryDataServiceOutcome Quickbi_publicClient::queryDataService(const QueryDataServiceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

quickbi-public/src/model/ModifyCopilotEmbedConfigRequest.cc

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

quickbi-public/src/model/ModifyCopilotEmbedConfigResult.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/ModifyCopilotEmbedConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Quickbi_public;
+using namespace AlibabaCloud::Quickbi_public::Model;
+
+ModifyCopilotEmbedConfigResult::ModifyCopilotEmbedConfigResult() :
+	ServiceResult()
+{}
+
+ModifyCopilotEmbedConfigResult::ModifyCopilotEmbedConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ModifyCopilotEmbedConfigResult::~ModifyCopilotEmbedConfigResult()
+{}
+
+void ModifyCopilotEmbedConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Result"].isNull())
+		result_ = value["Result"].asString() == "true";
+
+}
+
+bool ModifyCopilotEmbedConfigResult::getSuccess()const
+{
+	return success_;
+}
+
+bool ModifyCopilotEmbedConfigResult::getResult()const
+{
+	return result_;
+}
+

quickbi-public/src/model/QueryCopilotEmbedConfigRequest.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/QueryCopilotEmbedConfigRequest.h>
+
+using AlibabaCloud::Quickbi_public::Model::QueryCopilotEmbedConfigRequest;
+
+QueryCopilotEmbedConfigRequest::QueryCopilotEmbedConfigRequest()
+    : RpcServiceRequest("quickbi-public", "2022-01-01", "QueryCopilotEmbedConfig") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+QueryCopilotEmbedConfigRequest::~QueryCopilotEmbedConfigRequest() {}
+
+std::string QueryCopilotEmbedConfigRequest::getAccessPoint() const {
+  return accessPoint_;
+}
+
+void QueryCopilotEmbedConfigRequest::setAccessPoint(const std::string &accessPoint) {
+  accessPoint_ = accessPoint;
+  setParameter(std::string("AccessPoint"), accessPoint);
+}
+
+std::string QueryCopilotEmbedConfigRequest::getSignType() const {
+  return signType_;
+}
+
+void QueryCopilotEmbedConfigRequest::setSignType(const std::string &signType) {
+  signType_ = signType;
+  setParameter(std::string("SignType"), signType);
+}
+
+std::string QueryCopilotEmbedConfigRequest::getKeyword() const {
+  return keyword_;
+}
+
+void QueryCopilotEmbedConfigRequest::setKeyword(const std::string &keyword) {
+  keyword_ = keyword;
+  setParameter(std::string("Keyword"), keyword);
+}
+

quickbi-public/src/model/QueryCopilotEmbedConfigResult.cc

@@ -0,0 +1,87 @@
+/*
+ * 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/QueryCopilotEmbedConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Quickbi_public;
+using namespace AlibabaCloud::Quickbi_public::Model;
+
+QueryCopilotEmbedConfigResult::QueryCopilotEmbedConfigResult() :
+	ServiceResult()
+{}
+
+QueryCopilotEmbedConfigResult::QueryCopilotEmbedConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+QueryCopilotEmbedConfigResult::~QueryCopilotEmbedConfigResult()
+{}
+
+void QueryCopilotEmbedConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allResultNode = value["Result"]["ResultItem"];
+	for (auto valueResultResultItem : allResultNode)
+	{
+		ResultItem resultObject;
+		if(!valueResultResultItem["CopilotId"].isNull())
+			resultObject.copilotId = valueResultResultItem["CopilotId"].asString();
+		if(!valueResultResultItem["ShowName"].isNull())
+			resultObject.showName = valueResultResultItem["ShowName"].asString();
+		if(!valueResultResultItem["CreateUser"].isNull())
+			resultObject.createUser = valueResultResultItem["CreateUser"].asString();
+		if(!valueResultResultItem["CreateUserName"].isNull())
+			resultObject.createUserName = valueResultResultItem["CreateUserName"].asString();
+		if(!valueResultResultItem["ModifyUser"].isNull())
+			resultObject.modifyUser = valueResultResultItem["ModifyUser"].asString();
+		if(!valueResultResultItem["ModuleName"].isNull())
+			resultObject.moduleName = valueResultResultItem["ModuleName"].asString();
+		if(!valueResultResultItem["AgentName"].isNull())
+			resultObject.agentName = valueResultResultItem["AgentName"].asString();
+		auto dataRangeNode = value["DataRange"];
+		if(!dataRangeNode["AllTheme"].isNull())
+			resultObject.dataRange.allTheme = dataRangeNode["AllTheme"].asString() == "true";
+		if(!dataRangeNode["AllCube"].isNull())
+			resultObject.dataRange.allCube = dataRangeNode["AllCube"].asString() == "true";
+			auto allThemes = dataRangeNode["Themes"]["Themes"];
+			for (auto value : allThemes)
+				resultObject.dataRange.themes.push_back(value.asString());
+			auto allLlmCubes = dataRangeNode["LlmCubes"]["LlmCubes"];
+			for (auto value : allLlmCubes)
+				resultObject.dataRange.llmCubes.push_back(value.asString());
+		result_.push_back(resultObject);
+	}
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+bool QueryCopilotEmbedConfigResult::getSuccess()const
+{
+	return success_;
+}
+
+std::vector<QueryCopilotEmbedConfigResult::ResultItem> QueryCopilotEmbedConfigResult::getResult()const
+{
+	return result_;
+}
+

quickbi-public/src/model/QueryDataRangeRequest.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/QueryDataRangeRequest.h>
+
+using AlibabaCloud::Quickbi_public::Model::QueryDataRangeRequest;
+
+QueryDataRangeRequest::QueryDataRangeRequest()
+    : RpcServiceRequest("quickbi-public", "2022-01-01", "QueryDataRange") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+QueryDataRangeRequest::~QueryDataRangeRequest() {}
+
+std::string QueryDataRangeRequest::getAccessPoint() const {
+  return accessPoint_;
+}
+
+void QueryDataRangeRequest::setAccessPoint(const std::string &accessPoint) {
+  accessPoint_ = accessPoint;
+  setParameter(std::string("AccessPoint"), accessPoint);
+}
+
+std::string QueryDataRangeRequest::getSignType() const {
+  return signType_;
+}
+
+void QueryDataRangeRequest::setSignType(const std::string &signType) {
+  signType_ = signType;
+  setParameter(std::string("SignType"), signType);
+}
+
+std::string QueryDataRangeRequest::getType() const {
+  return type_;
+}
+
+void QueryDataRangeRequest::setType(const std::string &type) {
+  type_ = type;
+  setParameter(std::string("Type"), type);
+}
+
+std::string QueryDataRangeRequest::getKeyword() const {
+  return keyword_;
+}
+
+void QueryDataRangeRequest::setKeyword(const std::string &keyword) {
+  keyword_ = keyword;
+  setParameter(std::string("Keyword"), keyword);
+}
+

quickbi-public/src/model/QueryDataRangeResult.cc

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/quickbi-public/model/QueryDataRangeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Quickbi_public;
+using namespace AlibabaCloud::Quickbi_public::Model;
+
+QueryDataRangeResult::QueryDataRangeResult() :
+	ServiceResult()
+{}
+
+QueryDataRangeResult::QueryDataRangeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+QueryDataRangeResult::~QueryDataRangeResult()
+{}
+
+void QueryDataRangeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto resultNode = value["Result"];
+	auto allApiCopilotLlmCubeModelsNode = resultNode["ApiCopilotLlmCubeModels"]["ApiCopilotLlmCubeModelsItem"];
+	for (auto resultNodeApiCopilotLlmCubeModelsApiCopilotLlmCubeModelsItem : allApiCopilotLlmCubeModelsNode)
+	{
+		Result::ApiCopilotLlmCubeModelsItem apiCopilotLlmCubeModelsItemObject;
+		if(!resultNodeApiCopilotLlmCubeModelsApiCopilotLlmCubeModelsItem["LlmCubeId"].isNull())
+			apiCopilotLlmCubeModelsItemObject.llmCubeId = resultNodeApiCopilotLlmCubeModelsApiCopilotLlmCubeModelsItem["LlmCubeId"].asString();
+		if(!resultNodeApiCopilotLlmCubeModelsApiCopilotLlmCubeModelsItem["Alias"].isNull())
+			apiCopilotLlmCubeModelsItemObject.alias = resultNodeApiCopilotLlmCubeModelsApiCopilotLlmCubeModelsItem["Alias"].asString();
+		if(!resultNodeApiCopilotLlmCubeModelsApiCopilotLlmCubeModelsItem["CreateUser"].isNull())
+			apiCopilotLlmCubeModelsItemObject.createUser = resultNodeApiCopilotLlmCubeModelsApiCopilotLlmCubeModelsItem["CreateUser"].asString();
+		result_.apiCopilotLlmCubeModels.push_back(apiCopilotLlmCubeModelsItemObject);
+	}
+	auto allApiCopilotThemeModelsNode = resultNode["ApiCopilotThemeModels"]["ApiCopilotThemeModelsItem"];
+	for (auto resultNodeApiCopilotThemeModelsApiCopilotThemeModelsItem : allApiCopilotThemeModelsNode)
+	{
+		Result::ApiCopilotThemeModelsItem apiCopilotThemeModelsItemObject;
+		if(!resultNodeApiCopilotThemeModelsApiCopilotThemeModelsItem["ThemeId"].isNull())
+			apiCopilotThemeModelsItemObject.themeId = resultNodeApiCopilotThemeModelsApiCopilotThemeModelsItem["ThemeId"].asString();
+		if(!resultNodeApiCopilotThemeModelsApiCopilotThemeModelsItem["ThemeName"].isNull())
+			apiCopilotThemeModelsItemObject.themeName = resultNodeApiCopilotThemeModelsApiCopilotThemeModelsItem["ThemeName"].asString();
+		if(!resultNodeApiCopilotThemeModelsApiCopilotThemeModelsItem["CreateUser"].isNull())
+			apiCopilotThemeModelsItemObject.createUser = resultNodeApiCopilotThemeModelsApiCopilotThemeModelsItem["CreateUser"].asString();
+		auto allApiCopilotLlmCubeModels1Node = resultNodeApiCopilotThemeModelsApiCopilotThemeModelsItem["ApiCopilotLlmCubeModels"]["ApiCopilotLlmCubeModelsItem"];
+		for (auto resultNodeApiCopilotThemeModelsApiCopilotThemeModelsItemApiCopilotLlmCubeModelsApiCopilotLlmCubeModelsItem : allApiCopilotLlmCubeModels1Node)
+		{
+			Result::ApiCopilotThemeModelsItem::ApiCopilotLlmCubeModelsItem2 apiCopilotLlmCubeModels1Object;
+			if(!resultNodeApiCopilotThemeModelsApiCopilotThemeModelsItemApiCopilotLlmCubeModelsApiCopilotLlmCubeModelsItem["LlmCubeId"].isNull())
+				apiCopilotLlmCubeModels1Object.llmCubeId = resultNodeApiCopilotThemeModelsApiCopilotThemeModelsItemApiCopilotLlmCubeModelsApiCopilotLlmCubeModelsItem["LlmCubeId"].asString();
+			if(!resultNodeApiCopilotThemeModelsApiCopilotThemeModelsItemApiCopilotLlmCubeModelsApiCopilotLlmCubeModelsItem["Alias"].isNull())
+				apiCopilotLlmCubeModels1Object.alias = resultNodeApiCopilotThemeModelsApiCopilotThemeModelsItemApiCopilotLlmCubeModelsApiCopilotLlmCubeModelsItem["Alias"].asString();
+			if(!resultNodeApiCopilotThemeModelsApiCopilotThemeModelsItemApiCopilotLlmCubeModelsApiCopilotLlmCubeModelsItem["CreateUser"].isNull())
+				apiCopilotLlmCubeModels1Object.createUser = resultNodeApiCopilotThemeModelsApiCopilotThemeModelsItemApiCopilotLlmCubeModelsApiCopilotLlmCubeModelsItem["CreateUser"].asString();
+			apiCopilotThemeModelsItemObject.apiCopilotLlmCubeModels1.push_back(apiCopilotLlmCubeModels1Object);
+		}
+		result_.apiCopilotThemeModels.push_back(apiCopilotThemeModelsItemObject);
+	}
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+bool QueryDataRangeResult::getSuccess()const
+{
+	return success_;
+}
+
+QueryDataRangeResult::Result QueryDataRangeResult::getResult()const
+{
+	return result_;
+}
+

quickbi-public/src/model/QueryDataRequest.cc

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

quickbi-public/src/model/QueryDataResult.cc

@@ -0,0 +1,80 @@
+/*
+ * 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/QueryDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Quickbi_public;
+using namespace AlibabaCloud::Quickbi_public::Model;
+
+QueryDataResult::QueryDataResult() :
+	ServiceResult()
+{}
+
+QueryDataResult::QueryDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+QueryDataResult::~QueryDataResult()
+{}
+
+void QueryDataResult::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["Sql"].isNull())
+		result_.sql = resultNode["Sql"].asString();
+	auto allHeadersNode = resultNode["Headers"]["HeadersItem"];
+	for (auto resultNodeHeadersHeadersItem : allHeadersNode)
+	{
+		Result::HeadersItem headersItemObject;
+		if(!resultNodeHeadersHeadersItem["Type"].isNull())
+			headersItemObject.type = resultNodeHeadersHeadersItem["Type"].asString();
+		if(!resultNodeHeadersHeadersItem["DataType"].isNull())
+			headersItemObject.dataType = resultNodeHeadersHeadersItem["DataType"].asString();
+		if(!resultNodeHeadersHeadersItem["Granularity"].isNull())
+			headersItemObject.granularity = resultNodeHeadersHeadersItem["Granularity"].asString();
+		if(!resultNodeHeadersHeadersItem["Label"].isNull())
+			headersItemObject.label = resultNodeHeadersHeadersItem["Label"].asString();
+		if(!resultNodeHeadersHeadersItem["Column"].isNull())
+			headersItemObject.column = resultNodeHeadersHeadersItem["Column"].asString();
+		if(!resultNodeHeadersHeadersItem["Aggregator"].isNull())
+			headersItemObject.aggregator = resultNodeHeadersHeadersItem["Aggregator"].asString();
+		result_.headers.push_back(headersItemObject);
+	}
+		auto allValues = resultNode["Values"]["Values"];
+		for (auto value : allValues)
+			result_.values.push_back(value.asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+bool QueryDataResult::getSuccess()const
+{
+	return success_;
+}
+
+QueryDataResult::Result QueryDataResult::getResult()const
+{
+	return result_;
+}
+