@qlik/api 1.31.0 → 1.33.0

package/data-alerts.js

@@ -0,0 +1,187 @@
+import {
+  clearApiCache,
+  invokeFetch
+} from "./chunks/LIEZG7IM.js";
+import "./chunks/GPRUNZV4.js";
+import "./chunks/7MMXU6EL.js";
+
+// src/public/rest/data-alerts.ts
+async function getDataAlerts(query, options) {
+  return invokeFetch("data-alerts", {
+    method: "get",
+    pathTemplate: "/api/v1/data-alerts",
+    query,
+    options
+  });
+}
+async function createDataAlert(body, options) {
+  return invokeFetch("data-alerts", {
+    method: "post",
+    pathTemplate: "/api/v1/data-alerts",
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function triggerDataAlerts(body, options) {
+  return invokeFetch("data-alerts", {
+    method: "post",
+    pathTemplate: "/api/v1/data-alerts/actions/trigger",
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function validateDataAlerts(body, options) {
+  return invokeFetch("data-alerts", {
+    method: "post",
+    pathTemplate: "/api/v1/data-alerts/actions/validate",
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function getDataAlertsSettings(options) {
+  return invokeFetch("data-alerts", {
+    method: "get",
+    pathTemplate: "/api/v1/data-alerts/settings",
+    options
+  });
+}
+async function setDataAlertsSettings(body, options) {
+  return invokeFetch("data-alerts", {
+    method: "put",
+    pathTemplate: "/api/v1/data-alerts/settings",
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function deleteDataAlert(alertId, options) {
+  return invokeFetch("data-alerts", {
+    method: "delete",
+    pathTemplate: "/api/v1/data-alerts/{alertId}",
+    pathVariables: { alertId },
+    options
+  });
+}
+async function getDataAlert(alertId, options) {
+  return invokeFetch("data-alerts", {
+    method: "get",
+    pathTemplate: "/api/v1/data-alerts/{alertId}",
+    pathVariables: { alertId },
+    options
+  });
+}
+async function patchDataAlert(alertId, body, options) {
+  return invokeFetch("data-alerts", {
+    method: "patch",
+    pathTemplate: "/api/v1/data-alerts/{alertId}",
+    pathVariables: { alertId },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function getDataAlertCondition(alertId, options) {
+  return invokeFetch("data-alerts", {
+    method: "get",
+    pathTemplate: "/api/v1/data-alerts/{alertId}/condition",
+    pathVariables: { alertId },
+    options
+  });
+}
+async function deleteDataAlertExecution(alertId, executionId, options) {
+  return invokeFetch("data-alerts", {
+    method: "delete",
+    pathTemplate: "/api/v1/data-alerts/{alertId}/executions/{executionId}",
+    pathVariables: { alertId, executionId },
+    options
+  });
+}
+async function getDataAlertExecution(alertId, executionId, options) {
+  return invokeFetch("data-alerts", {
+    method: "get",
+    pathTemplate: "/api/v1/data-alerts/{alertId}/executions/{executionId}",
+    pathVariables: { alertId, executionId },
+    options
+  });
+}
+async function getDataAlertRecipientStats(alertId, query, options) {
+  return invokeFetch("data-alerts", {
+    method: "get",
+    pathTemplate: "/api/v1/data-alerts/{alertId}/recipient-stats",
+    pathVariables: { alertId },
+    query,
+    options
+  });
+}
+async function getDataAlertExecutions(taskId, query, options) {
+  return invokeFetch("data-alerts", {
+    method: "get",
+    pathTemplate: "/api/v1/data-alerts/{taskId}/executions",
+    pathVariables: { taskId },
+    query,
+    options
+  });
+}
+async function getDataAlertExecutionsStats(taskId, query, options) {
+  return invokeFetch("data-alerts", {
+    method: "get",
+    pathTemplate: "/api/v1/data-alerts/{taskId}/executions/stats",
+    pathVariables: { taskId },
+    query,
+    options
+  });
+}
+async function getDataAlertExecutionEvaluations(taskId, executionId, options) {
+  return invokeFetch("data-alerts", {
+    method: "get",
+    pathTemplate: "/api/v1/data-alerts/{taskId}/executions/{executionId}/evaluations",
+    pathVariables: { taskId, executionId },
+    options
+  });
+}
+function clearCache() {
+  return clearApiCache("data-alerts");
+}
+var dataAlertsExport = {
+  getDataAlerts,
+  createDataAlert,
+  triggerDataAlerts,
+  validateDataAlerts,
+  getDataAlertsSettings,
+  setDataAlertsSettings,
+  deleteDataAlert,
+  getDataAlert,
+  patchDataAlert,
+  getDataAlertCondition,
+  deleteDataAlertExecution,
+  getDataAlertExecution,
+  getDataAlertRecipientStats,
+  getDataAlertExecutions,
+  getDataAlertExecutionsStats,
+  getDataAlertExecutionEvaluations,
+  clearCache
+};
+var data_alerts_default = dataAlertsExport;
+export {
+  clearCache,
+  createDataAlert,
+  data_alerts_default as default,
+  deleteDataAlert,
+  deleteDataAlertExecution,
+  getDataAlert,
+  getDataAlertCondition,
+  getDataAlertExecution,
+  getDataAlertExecutionEvaluations,
+  getDataAlertExecutions,
+  getDataAlertExecutionsStats,
+  getDataAlertRecipientStats,
+  getDataAlerts,
+  getDataAlertsSettings,
+  patchDataAlert,
+  setDataAlertsSettings,
+  triggerDataAlerts,
+  validateDataAlerts
+};

package/data-assets.d.ts

@@ -1,5 +1,5 @@
-import { A as ApiCallOptions } from './invoke-fetch-types-Cq7bjkqn.js';
-import './auth-types-DqfMuSRX.js';
+import { A as ApiCallOptions } from './invoke-fetch-types-BYCD4pc9.js';
+import './auth-types-Cj5bM3Yk.js';
 
 type BatchIdDto = {
     ids?: string[];
@@ -66,7 +66,7 @@ type JsonPatch = {
  * @param body an object with the body content
  * @throws DeleteDataAssetsHttpError
  */
-declare const deleteDataAssets: (body: BatchIdDto, options?: ApiCallOptions) => Promise<DeleteDataAssetsHttpResponse>;
+declare function deleteDataAssets(body: BatchIdDto, options?: ApiCallOptions): Promise<DeleteDataAssetsHttpResponse>;
 type DeleteDataAssetsHttpResponse = {
     data: void;
     headers: Headers;
@@ -83,7 +83,7 @@ type DeleteDataAssetsHttpError = {
  * @param body an object with the body content
  * @throws CreateDataAssetHttpError
  */
-declare const createDataAsset: (body: DataAsset, options?: ApiCallOptions) => Promise<CreateDataAssetHttpResponse>;
+declare function createDataAsset(body: DataAsset, options?: ApiCallOptions): Promise<CreateDataAssetHttpResponse>;
 type CreateDataAssetHttpResponse = {
     data: DataAsset;
     headers: Headers;
@@ -101,10 +101,10 @@ type CreateDataAssetHttpError = {
  * @param query an object with query parameters
  * @throws GetDataAssetHttpError
  */
-declare const getDataAsset: (dataAssetId: string, query: {
+declare function getDataAsset(dataAssetId: string, query: {
     /** Comma-separated fields to return in the response. */
     projections?: string[];
-}, options?: ApiCallOptions) => Promise<GetDataAssetHttpResponse>;
+}, options?: ApiCallOptions): Promise<GetDataAssetHttpResponse>;
 type GetDataAssetHttpResponse = {
     data: DataAsset;
     headers: Headers;
@@ -122,7 +122,7 @@ type GetDataAssetHttpError = {
  * @param body an object with the body content
  * @throws PatchDataAssetHttpError
  */
-declare const patchDataAsset: (dataAssetId: string, body: JsonPatch[], options?: ApiCallOptions) => Promise<PatchDataAssetHttpResponse>;
+declare function patchDataAsset(dataAssetId: string, body: JsonPatch[], options?: ApiCallOptions): Promise<PatchDataAssetHttpResponse>;
 type PatchDataAssetHttpResponse = {
     data: DataAsset;
     headers: Headers;
@@ -140,7 +140,7 @@ type PatchDataAssetHttpError = {
  * @param body an object with the body content
  * @throws UpdateDataAssetHttpError
  */
-declare const updateDataAsset: (dataAssetId: string, body: DataAsset, options?: ApiCallOptions) => Promise<UpdateDataAssetHttpResponse>;
+declare function updateDataAsset(dataAssetId: string, body: DataAsset, options?: ApiCallOptions): Promise<UpdateDataAssetHttpResponse>;
 type UpdateDataAssetHttpResponse = {
     data: DataAsset;
     headers: Headers;

package/data-assets.js

@@ -1,48 +1,58 @@
 import {
   clearApiCache,
   invokeFetch
-} from "./chunks/YKZ2QYHN.js";
-import "./chunks/DLKLPD7T.js";
-import "./chunks/2ZQ3ZX7F.js";
+} from "./chunks/LIEZG7IM.js";
+import "./chunks/GPRUNZV4.js";
+import "./chunks/7MMXU6EL.js";
 
 // src/public/rest/data-assets.ts
-var deleteDataAssets = async (body, options) => invokeFetch("data-assets", {
-  method: "delete",
-  pathTemplate: "/api/v1/data-assets",
-  body,
-  contentType: "application/json",
-  options
-});
-var createDataAsset = async (body, options) => invokeFetch("data-assets", {
-  method: "post",
-  pathTemplate: "/api/v1/data-assets",
-  body,
-  contentType: "application/json",
-  options
-});
-var getDataAsset = async (dataAssetId, query, options) => invokeFetch("data-assets", {
-  method: "get",
-  pathTemplate: "/api/v1/data-assets/{data-asset-id}",
-  pathVariables: { "data-asset-id": dataAssetId },
-  query,
-  options
-});
-var patchDataAsset = async (dataAssetId, body, options) => invokeFetch("data-assets", {
-  method: "patch",
-  pathTemplate: "/api/v1/data-assets/{data-asset-id}",
-  pathVariables: { "data-asset-id": dataAssetId },
-  body,
-  contentType: "application/json",
-  options
-});
-var updateDataAsset = async (dataAssetId, body, options) => invokeFetch("data-assets", {
-  method: "put",
-  pathTemplate: "/api/v1/data-assets/{data-asset-id}",
-  pathVariables: { "data-asset-id": dataAssetId },
-  body,
-  contentType: "application/json",
-  options
-});
+async function deleteDataAssets(body, options) {
+  return invokeFetch("data-assets", {
+    method: "delete",
+    pathTemplate: "/api/v1/data-assets",
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function createDataAsset(body, options) {
+  return invokeFetch("data-assets", {
+    method: "post",
+    pathTemplate: "/api/v1/data-assets",
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function getDataAsset(dataAssetId, query, options) {
+  return invokeFetch("data-assets", {
+    method: "get",
+    pathTemplate: "/api/v1/data-assets/{data-asset-id}",
+    pathVariables: { "data-asset-id": dataAssetId },
+    query,
+    options
+  });
+}
+async function patchDataAsset(dataAssetId, body, options) {
+  return invokeFetch("data-assets", {
+    method: "patch",
+    pathTemplate: "/api/v1/data-assets/{data-asset-id}",
+    pathVariables: { "data-asset-id": dataAssetId },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function updateDataAsset(dataAssetId, body, options) {
+  return invokeFetch("data-assets", {
+    method: "put",
+    pathTemplate: "/api/v1/data-assets/{data-asset-id}",
+    pathVariables: { "data-asset-id": dataAssetId },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
 function clearCache() {
   return clearApiCache("data-assets");
 }

package/data-connections.d.ts

@@ -1,5 +1,5 @@
-import { A as ApiCallOptions } from './invoke-fetch-types-Cq7bjkqn.js';
-import './auth-types-DqfMuSRX.js';
+import { A as ApiCallOptions } from './invoke-fetch-types-BYCD4pc9.js';
+import './auth-types-Cj5bM3Yk.js';
 
 type ActionDeleteRequest = {
     connections: {
@@ -314,7 +314,7 @@ type TopLevelLink = {
  * @param query an object with query parameters
  * @throws GetDataConnectionsHttpError
  */
-declare const getDataConnections: (query: {
+declare function getDataConnections(query: {
     /** Sort results will be returned in case insensitive order if set to true (Only used along with sort query) */
     caseinsensitive?: boolean;
     /** Provides an alternate name to be used for data[] element in GET response. */
@@ -345,7 +345,7 @@ declare const getDataConnections: (query: {
     spaceId?: string;
     /** Filtering on userId. Requires admin role if specified userId doesn't match that is defined in JWT. */
     userId?: string;
-}, options?: ApiCallOptions) => Promise<GetDataConnectionsHttpResponse>;
+}, options?: ApiCallOptions): Promise<GetDataConnectionsHttpResponse>;
 type GetDataConnectionsHttpResponse = {
     data: Connections;
     headers: Headers;
@@ -364,7 +364,7 @@ type GetDataConnectionsHttpError = {
  * @param body an object with the body content
  * @throws CreateDataConnectionHttpError
  */
-declare const createDataConnection: (body: ConnectionCreate | DcaasConnectionCreate, options?: ApiCallOptions) => Promise<CreateDataConnectionHttpResponse>;
+declare function createDataConnection(body: ConnectionCreate | DcaasConnectionCreate, options?: ApiCallOptions): Promise<CreateDataConnectionHttpResponse>;
 type CreateDataConnectionHttpResponse = {
     data: ConnectionCreateResponse | DcaasConnectionCreateAuthResponse;
     headers: Headers;
@@ -381,7 +381,7 @@ type CreateDataConnectionHttpError = {
  * @param body an object with the body content
  * @throws DeleteDataConnectionsHttpError
  */
-declare const deleteDataConnections: (body: ActionDeleteRequest, options?: ApiCallOptions) => Promise<DeleteDataConnectionsHttpResponse>;
+declare function deleteDataConnections(body: ActionDeleteRequest, options?: ApiCallOptions): Promise<DeleteDataConnectionsHttpResponse>;
 type DeleteDataConnectionsHttpResponse = {
     data: BulkResponse;
     headers: Headers;
@@ -398,7 +398,7 @@ type DeleteDataConnectionsHttpError = {
  * @param body an object with the body content
  * @throws DuplicateDataAConnectionHttpError
  */
-declare const duplicateDataAConnection: (body: ActionDuplicateRequest, options?: ApiCallOptions) => Promise<DuplicateDataAConnectionHttpResponse>;
+declare function duplicateDataAConnection(body: ActionDuplicateRequest, options?: ApiCallOptions): Promise<DuplicateDataAConnectionHttpResponse>;
 type DuplicateDataAConnectionHttpResponse = {
     data: ConnectionCreateResponse;
     headers: Headers;
@@ -415,7 +415,7 @@ type DuplicateDataAConnectionHttpError = {
  * @param body an object with the body content
  * @throws UpdateDataConnectionsHttpError
  */
-declare const updateDataConnections: (body: ActionUpdateRequest, options?: ApiCallOptions) => Promise<UpdateDataConnectionsHttpResponse>;
+declare function updateDataConnections(body: ActionUpdateRequest, options?: ApiCallOptions): Promise<UpdateDataConnectionsHttpResponse>;
 type UpdateDataConnectionsHttpResponse = {
     data: BulkResponse;
     headers: Headers;
@@ -441,12 +441,12 @@ type UpdateDataConnectionsHttpError = {
  * @param query an object with query parameters
  * @throws DeleteDataConnectionHttpError
  */
-declare const deleteDataConnection: (qID: string, query: {
+declare function deleteDataConnection(qID: string, query: {
     /** Filtering on connections by space ID */
     spaceId?: string;
     /** Connection / credential ID defined in path become connection / credential name when this query parameter is set */
     type?: "connectionname" | "credentialname";
-}, options?: ApiCallOptions) => Promise<DeleteDataConnectionHttpResponse>;
+}, options?: ApiCallOptions): Promise<DeleteDataConnectionHttpResponse>;
 type DeleteDataConnectionHttpResponse = {
     data: void;
     headers: Headers;
@@ -477,7 +477,7 @@ type DeleteDataConnectionHttpError = {
  * @param query an object with query parameters
  * @throws GetDataConnectionHttpError
  */
-declare const getDataConnection: (qID: string, query: {
+declare function getDataConnection(qID: string, query: {
     /** If set to true, credentialId in the query will be interpreted as credential's name */
     byCredentialName?: boolean;
     /** Credential ID */
@@ -492,7 +492,7 @@ declare const getDataConnection: (qID: string, query: {
     spaceId?: string;
     /** Connection / credential ID defined in path become connection / credential name when this query parameter is set */
     type?: "connectionname" | "credentialname";
-}, options?: ApiCallOptions) => Promise<GetDataConnectionHttpResponse>;
+}, options?: ApiCallOptions): Promise<GetDataConnectionHttpResponse>;
 type GetDataConnectionHttpResponse = {
     data: ConnectionGet;
     headers: Headers;
@@ -511,10 +511,10 @@ type GetDataConnectionHttpError = {
  * @param body an object with the body content
  * @throws PatchDataConnectionHttpError
  */
-declare const patchDataConnection: (qID: string, query: {
+declare function patchDataConnection(qID: string, query: {
     /** Connection / credential ID defined in path become connection / credential name when this query parameter is set */
     type?: "connectionname" | "credentialname";
-}, body: PatchRequest, options?: ApiCallOptions) => Promise<PatchDataConnectionHttpResponse>;
+}, body: PatchRequest, options?: ApiCallOptions): Promise<PatchDataConnectionHttpResponse>;
 type PatchDataConnectionHttpResponse = {
     data: void;
     headers: Headers;
@@ -533,12 +533,12 @@ type PatchDataConnectionHttpError = {
  * @param body an object with the body content
  * @throws UpdateDataConnectionHttpError
  */
-declare const updateDataConnection: (qID: string, query: {
+declare function updateDataConnection(qID: string, query: {
     /** Filtering on connections by space ID */
     spaceId?: string;
     /** Connection / credential ID defined in path become connection / credential name when this query parameter is set */
     type?: "connectionname" | "credentialname";
-}, body: ConnectionUpdate, options?: ApiCallOptions) => Promise<UpdateDataConnectionHttpResponse>;
+}, body: ConnectionUpdate, options?: ApiCallOptions): Promise<UpdateDataConnectionHttpResponse>;
 type UpdateDataConnectionHttpResponse = {
     data: void;
     headers: Headers;

package/data-connections.js

@@ -1,77 +1,95 @@
 import {
   clearApiCache,
   invokeFetch
-} from "./chunks/YKZ2QYHN.js";
-import "./chunks/DLKLPD7T.js";
-import "./chunks/2ZQ3ZX7F.js";
+} from "./chunks/LIEZG7IM.js";
+import "./chunks/GPRUNZV4.js";
+import "./chunks/7MMXU6EL.js";
 
 // src/public/rest/data-connections.ts
-var getDataConnections = async (query, options) => invokeFetch("data-connections", {
-  method: "get",
-  pathTemplate: "/api/v1/data-connections",
-  query,
-  options
-});
-var createDataConnection = async (body, options) => invokeFetch("data-connections", {
-  method: "post",
-  pathTemplate: "/api/v1/data-connections",
-  body,
-  contentType: "application/json",
-  options
-});
-var deleteDataConnections = async (body, options) => invokeFetch("data-connections", {
-  method: "post",
-  pathTemplate: "/api/v1/data-connections/actions/delete",
-  body,
-  contentType: "application/json",
-  options
-});
-var duplicateDataAConnection = async (body, options) => invokeFetch("data-connections", {
-  method: "post",
-  pathTemplate: "/api/v1/data-connections/actions/duplicate",
-  body,
-  contentType: "application/json",
-  options
-});
-var updateDataConnections = async (body, options) => invokeFetch("data-connections", {
-  method: "post",
-  pathTemplate: "/api/v1/data-connections/actions/update",
-  body,
-  contentType: "application/json",
-  options
-});
-var deleteDataConnection = async (qID, query, options) => invokeFetch("data-connections", {
-  method: "delete",
-  pathTemplate: "/api/v1/data-connections/{qID}",
-  pathVariables: { qID },
-  query,
-  options
-});
-var getDataConnection = async (qID, query, options) => invokeFetch("data-connections", {
-  method: "get",
-  pathTemplate: "/api/v1/data-connections/{qID}",
-  pathVariables: { qID },
-  query,
-  options
-});
-var patchDataConnection = async (qID, query, body, options) => invokeFetch("data-connections", {
-  method: "patch",
-  pathTemplate: "/api/v1/data-connections/{qID}",
-  pathVariables: { qID },
-  query,
-  body,
-  contentType: "application/json",
-  options
-});
-var updateDataConnection = async (qID, query, body, options) => invokeFetch("data-connections", {
-  method: "put",
-  pathTemplate: "/api/v1/data-connections/{qID}",
-  pathVariables: { qID },
-  query,
-  body,
-  contentType: "application/json",
-  options
-});
+async function getDataConnections(query, options) {
+  return invokeFetch("data-connections", {
+    method: "get",
+    pathTemplate: "/api/v1/data-connections",
+    query,
+    options
+  });
+}
+async function createDataConnection(body, options) {
+  return invokeFetch("data-connections", {
+    method: "post",
+    pathTemplate: "/api/v1/data-connections",
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function deleteDataConnections(body, options) {
+  return invokeFetch("data-connections", {
+    method: "post",
+    pathTemplate: "/api/v1/data-connections/actions/delete",
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function duplicateDataAConnection(body, options) {
+  return invokeFetch("data-connections", {
+    method: "post",
+    pathTemplate: "/api/v1/data-connections/actions/duplicate",
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function updateDataConnections(body, options) {
+  return invokeFetch("data-connections", {
+    method: "post",
+    pathTemplate: "/api/v1/data-connections/actions/update",
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function deleteDataConnection(qID, query, options) {
+  return invokeFetch("data-connections", {
+    method: "delete",
+    pathTemplate: "/api/v1/data-connections/{qID}",
+    pathVariables: { qID },
+    query,
+    options
+  });
+}
+async function getDataConnection(qID, query, options) {
+  return invokeFetch("data-connections", {
+    method: "get",
+    pathTemplate: "/api/v1/data-connections/{qID}",
+    pathVariables: { qID },
+    query,
+    options
+  });
+}
+async function patchDataConnection(qID, query, body, options) {
+  return invokeFetch("data-connections", {
+    method: "patch",
+    pathTemplate: "/api/v1/data-connections/{qID}",
+    pathVariables: { qID },
+    query,
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function updateDataConnection(qID, query, body, options) {
+  return invokeFetch("data-connections", {
+    method: "put",
+    pathTemplate: "/api/v1/data-connections/{qID}",
+    pathVariables: { qID },
+    query,
+    body,
+    contentType: "application/json",
+    options
+  });
+}
 function clearCache() {
   return clearApiCache("data-connections");
 }