@qlik/api 1.32.0 → 1.34.0

package/glossaries.js

@@ -1,181 +1,229 @@
 import {
   clearApiCache,
   invokeFetch
-} from "./chunks/VVD2DPKQ.js";
-import "./chunks/LTNGXTXG.js";
-import "./chunks/2ZQ3ZX7F.js";
+} from "./chunks/6WNP7HZQ.js";
+import "./chunks/QAOVZB27.js";
+import "./chunks/7MMXU6EL.js";
 
 // src/public/rest/glossaries.ts
-var getGlossaries = async (query, options) => invokeFetch("glossaries", {
-  method: "get",
-  pathTemplate: "/api/v1/glossaries",
-  query,
-  options
-});
-var createGlossary = async (body, options) => invokeFetch("glossaries", {
-  method: "post",
-  pathTemplate: "/api/v1/glossaries",
-  body,
-  contentType: "application/json",
-  options
-});
-var importGlossary = async (query, body, options) => invokeFetch("glossaries", {
-  method: "post",
-  pathTemplate: "/api/v1/glossaries/actions/import",
-  query,
-  body,
-  contentType: "application/json",
-  options
-});
-var deleteGlossary = async (id, options) => invokeFetch("glossaries", {
-  method: "delete",
-  pathTemplate: "/api/v1/glossaries/{id}",
-  pathVariables: { id },
-  options
-});
-var getGlossary = async (id, options) => invokeFetch("glossaries", {
-  method: "get",
-  pathTemplate: "/api/v1/glossaries/{id}",
-  pathVariables: { id },
-  options
-});
-var patchGlossary = async (id, body, options) => invokeFetch("glossaries", {
-  method: "patch",
-  pathTemplate: "/api/v1/glossaries/{id}",
-  pathVariables: { id },
-  body,
-  contentType: "application/json",
-  options
-});
-var updateGlossary = async (id, body, options) => invokeFetch("glossaries", {
-  method: "put",
-  pathTemplate: "/api/v1/glossaries/{id}",
-  pathVariables: { id },
-  body,
-  contentType: "application/json",
-  options
-});
-var exportGlossary = async (id, options) => invokeFetch("glossaries", {
-  method: "get",
-  pathTemplate: "/api/v1/glossaries/{id}/actions/export",
-  pathVariables: { id },
-  options
-});
-var getGlossaryCategories = async (id, query, options) => invokeFetch("glossaries", {
-  method: "get",
-  pathTemplate: "/api/v1/glossaries/{id}/categories",
-  pathVariables: { id },
-  query,
-  options
-});
-var createGlossaryCategory = async (id, body, options) => invokeFetch("glossaries", {
-  method: "post",
-  pathTemplate: "/api/v1/glossaries/{id}/categories",
-  pathVariables: { id },
-  body,
-  contentType: "application/json",
-  options
-});
-var deleteGlossaryCategory = async (id, categoryId, options) => invokeFetch("glossaries", {
-  method: "delete",
-  pathTemplate: "/api/v1/glossaries/{id}/categories/{categoryId}",
-  pathVariables: { id, categoryId },
-  options
-});
-var getGlossaryCategory = async (id, categoryId, options) => invokeFetch("glossaries", {
-  method: "get",
-  pathTemplate: "/api/v1/glossaries/{id}/categories/{categoryId}",
-  pathVariables: { id, categoryId },
-  options
-});
-var patchGlossaryCategory = async (id, categoryId, body, options) => invokeFetch("glossaries", {
-  method: "patch",
-  pathTemplate: "/api/v1/glossaries/{id}/categories/{categoryId}",
-  pathVariables: { id, categoryId },
-  body,
-  contentType: "application/json",
-  options
-});
-var updateGlossaryCategory = async (id, categoryId, body, options) => invokeFetch("glossaries", {
-  method: "put",
-  pathTemplate: "/api/v1/glossaries/{id}/categories/{categoryId}",
-  pathVariables: { id, categoryId },
-  body,
-  contentType: "application/json",
-  options
-});
-var getGlossaryTerms = async (id, query, options) => invokeFetch("glossaries", {
-  method: "get",
-  pathTemplate: "/api/v1/glossaries/{id}/terms",
-  pathVariables: { id },
-  query,
-  options
-});
-var createGlossaryTerm = async (id, body, options) => invokeFetch("glossaries", {
-  method: "post",
-  pathTemplate: "/api/v1/glossaries/{id}/terms",
-  pathVariables: { id },
-  body,
-  contentType: "application/json",
-  options
-});
-var deleteGlossaryTerm = async (id, termId, options) => invokeFetch("glossaries", {
-  method: "delete",
-  pathTemplate: "/api/v1/glossaries/{id}/terms/{termId}",
-  pathVariables: { id, termId },
-  options
-});
-var getGlossaryTerm = async (id, termId, options) => invokeFetch("glossaries", {
-  method: "get",
-  pathTemplate: "/api/v1/glossaries/{id}/terms/{termId}",
-  pathVariables: { id, termId },
-  options
-});
-var patchGlossaryTerm = async (id, termId, body, options) => invokeFetch("glossaries", {
-  method: "patch",
-  pathTemplate: "/api/v1/glossaries/{id}/terms/{termId}",
-  pathVariables: { id, termId },
-  body,
-  contentType: "application/json",
-  options
-});
-var updateGlossaryTerm = async (id, termId, body, options) => invokeFetch("glossaries", {
-  method: "put",
-  pathTemplate: "/api/v1/glossaries/{id}/terms/{termId}",
-  pathVariables: { id, termId },
-  body,
-  contentType: "application/json",
-  options
-});
-var changeGlossaryTermStatus = async (id, termId, query, options) => invokeFetch("glossaries", {
-  method: "post",
-  pathTemplate: "/api/v1/glossaries/{id}/terms/{termId}/actions/change-status",
-  pathVariables: { id, termId },
-  query,
-  options
-});
-var getGlossaryTermLinks = async (id, termId, query, options) => invokeFetch("glossaries", {
-  method: "get",
-  pathTemplate: "/api/v1/glossaries/{id}/terms/{termId}/links",
-  pathVariables: { id, termId },
-  query,
-  options
-});
-var createGlossaryTermLink = async (id, termId, body, options) => invokeFetch("glossaries", {
-  method: "post",
-  pathTemplate: "/api/v1/glossaries/{id}/terms/{termId}/links",
-  pathVariables: { id, termId },
-  body,
-  contentType: "application/json",
-  options
-});
-var getGlossaryTermRevisions = async (id, termId, query, options) => invokeFetch("glossaries", {
-  method: "get",
-  pathTemplate: "/api/v1/glossaries/{id}/terms/{termId}/revisions",
-  pathVariables: { id, termId },
-  query,
-  options
-});
+async function getGlossaries(query, options) {
+  return invokeFetch("glossaries", {
+    method: "get",
+    pathTemplate: "/api/v1/glossaries",
+    query,
+    options
+  });
+}
+async function createGlossary(body, options) {
+  return invokeFetch("glossaries", {
+    method: "post",
+    pathTemplate: "/api/v1/glossaries",
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function importGlossary(query, body, options) {
+  return invokeFetch("glossaries", {
+    method: "post",
+    pathTemplate: "/api/v1/glossaries/actions/import",
+    query,
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function deleteGlossary(id, options) {
+  return invokeFetch("glossaries", {
+    method: "delete",
+    pathTemplate: "/api/v1/glossaries/{id}",
+    pathVariables: { id },
+    options
+  });
+}
+async function getGlossary(id, options) {
+  return invokeFetch("glossaries", {
+    method: "get",
+    pathTemplate: "/api/v1/glossaries/{id}",
+    pathVariables: { id },
+    options
+  });
+}
+async function patchGlossary(id, body, options) {
+  return invokeFetch("glossaries", {
+    method: "patch",
+    pathTemplate: "/api/v1/glossaries/{id}",
+    pathVariables: { id },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function updateGlossary(id, body, options) {
+  return invokeFetch("glossaries", {
+    method: "put",
+    pathTemplate: "/api/v1/glossaries/{id}",
+    pathVariables: { id },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function exportGlossary(id, options) {
+  return invokeFetch("glossaries", {
+    method: "get",
+    pathTemplate: "/api/v1/glossaries/{id}/actions/export",
+    pathVariables: { id },
+    options
+  });
+}
+async function getGlossaryCategories(id, query, options) {
+  return invokeFetch("glossaries", {
+    method: "get",
+    pathTemplate: "/api/v1/glossaries/{id}/categories",
+    pathVariables: { id },
+    query,
+    options
+  });
+}
+async function createGlossaryCategory(id, body, options) {
+  return invokeFetch("glossaries", {
+    method: "post",
+    pathTemplate: "/api/v1/glossaries/{id}/categories",
+    pathVariables: { id },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function deleteGlossaryCategory(id, categoryId, options) {
+  return invokeFetch("glossaries", {
+    method: "delete",
+    pathTemplate: "/api/v1/glossaries/{id}/categories/{categoryId}",
+    pathVariables: { id, categoryId },
+    options
+  });
+}
+async function getGlossaryCategory(id, categoryId, options) {
+  return invokeFetch("glossaries", {
+    method: "get",
+    pathTemplate: "/api/v1/glossaries/{id}/categories/{categoryId}",
+    pathVariables: { id, categoryId },
+    options
+  });
+}
+async function patchGlossaryCategory(id, categoryId, body, options) {
+  return invokeFetch("glossaries", {
+    method: "patch",
+    pathTemplate: "/api/v1/glossaries/{id}/categories/{categoryId}",
+    pathVariables: { id, categoryId },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function updateGlossaryCategory(id, categoryId, body, options) {
+  return invokeFetch("glossaries", {
+    method: "put",
+    pathTemplate: "/api/v1/glossaries/{id}/categories/{categoryId}",
+    pathVariables: { id, categoryId },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function getGlossaryTerms(id, query, options) {
+  return invokeFetch("glossaries", {
+    method: "get",
+    pathTemplate: "/api/v1/glossaries/{id}/terms",
+    pathVariables: { id },
+    query,
+    options
+  });
+}
+async function createGlossaryTerm(id, body, options) {
+  return invokeFetch("glossaries", {
+    method: "post",
+    pathTemplate: "/api/v1/glossaries/{id}/terms",
+    pathVariables: { id },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function deleteGlossaryTerm(id, termId, options) {
+  return invokeFetch("glossaries", {
+    method: "delete",
+    pathTemplate: "/api/v1/glossaries/{id}/terms/{termId}",
+    pathVariables: { id, termId },
+    options
+  });
+}
+async function getGlossaryTerm(id, termId, options) {
+  return invokeFetch("glossaries", {
+    method: "get",
+    pathTemplate: "/api/v1/glossaries/{id}/terms/{termId}",
+    pathVariables: { id, termId },
+    options
+  });
+}
+async function patchGlossaryTerm(id, termId, body, options) {
+  return invokeFetch("glossaries", {
+    method: "patch",
+    pathTemplate: "/api/v1/glossaries/{id}/terms/{termId}",
+    pathVariables: { id, termId },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function updateGlossaryTerm(id, termId, body, options) {
+  return invokeFetch("glossaries", {
+    method: "put",
+    pathTemplate: "/api/v1/glossaries/{id}/terms/{termId}",
+    pathVariables: { id, termId },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function changeGlossaryTermStatus(id, termId, query, options) {
+  return invokeFetch("glossaries", {
+    method: "post",
+    pathTemplate: "/api/v1/glossaries/{id}/terms/{termId}/actions/change-status",
+    pathVariables: { id, termId },
+    query,
+    options
+  });
+}
+async function getGlossaryTermLinks(id, termId, query, options) {
+  return invokeFetch("glossaries", {
+    method: "get",
+    pathTemplate: "/api/v1/glossaries/{id}/terms/{termId}/links",
+    pathVariables: { id, termId },
+    query,
+    options
+  });
+}
+async function createGlossaryTermLink(id, termId, body, options) {
+  return invokeFetch("glossaries", {
+    method: "post",
+    pathTemplate: "/api/v1/glossaries/{id}/terms/{termId}/links",
+    pathVariables: { id, termId },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function getGlossaryTermRevisions(id, termId, query, options) {
+  return invokeFetch("glossaries", {
+    method: "get",
+    pathTemplate: "/api/v1/glossaries/{id}/terms/{termId}/revisions",
+    pathVariables: { id, termId },
+    query,
+    options
+  });
+}
 function clearCache() {
   return clearApiCache("glossaries");
 }

package/groups.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';
 
 /**
  * An array of role references. Visibility dependant on access level. Must have access to roles to view other users' assigned roles.
@@ -276,7 +276,7 @@ type SettingsPatchSchema = SettingsPatch[];
  * @param query an object with query parameters
  * @throws GetGroupsHttpError
  */
-declare const getGroups: (query: {
+declare function getGroups(query: {
     /** The advanced filtering to use for the query. Refer to [RFC 7644](https://datatracker.ietf.org/doc/rfc7644/) for the syntax. Cannot be combined with any of the fields marked as deprecated. All conditional statements within this query parameter are case insensitive. */
     filter?: string;
     /** The number of groups to retrieve. */
@@ -291,7 +291,7 @@ declare const getGroups: (query: {
     systemGroups?: boolean;
     /** Whether to return a total match count in the result. Defaults to false. */
     totalResults?: boolean;
-}, options?: ApiCallOptions) => Promise<GetGroupsHttpResponse>;
+}, options?: ApiCallOptions): Promise<GetGroupsHttpResponse>;
 type GetGroupsHttpResponse = {
     data: Groups;
     headers: Headers;
@@ -310,7 +310,7 @@ type GetGroupsHttpError = {
  * @param body an object with the body content
  * @throws CreateGroupHttpError
  */
-declare const createGroup: (body: GroupPostSchema, options?: ApiCallOptions) => Promise<CreateGroupHttpResponse>;
+declare function createGroup(body: GroupPostSchema, options?: ApiCallOptions): Promise<CreateGroupHttpResponse>;
 type CreateGroupHttpResponse = {
     data: Group;
     headers: Headers;
@@ -328,7 +328,7 @@ type CreateGroupHttpError = {
  * @param body an object with the body content
  * @throws FilterGroupsHttpError
  */
-declare const filterGroups: (query: {
+declare function filterGroups(query: {
     /** The number of user entries to retrieve. */
     limit?: number;
     /** Get users with IDs that are higher than the target user ID. Cannot be used in conjunction with prev. */
@@ -337,7 +337,7 @@ declare const filterGroups: (query: {
     prev?: string;
     /** The field to sort by, with +/- prefix indicating sort order */
     sort?: "name" | "+name" | "-name";
-}, body: Filter, options?: ApiCallOptions) => Promise<FilterGroupsHttpResponse>;
+}, body: Filter, options?: ApiCallOptions): Promise<FilterGroupsHttpResponse>;
 type FilterGroupsHttpResponse = {
     data: Groups;
     headers: Headers;
@@ -355,7 +355,7 @@ type FilterGroupsHttpError = {
  *
  * @throws GetGroupsSettingsHttpError
  */
-declare const getGroupsSettings: (options?: ApiCallOptions) => Promise<GetGroupsSettingsHttpResponse>;
+declare function getGroupsSettings(options?: ApiCallOptions): Promise<GetGroupsSettingsHttpResponse>;
 type GetGroupsSettingsHttpResponse = {
     data: GroupSettings;
     headers: Headers;
@@ -372,7 +372,7 @@ type GetGroupsSettingsHttpError = {
  * @param body an object with the body content
  * @throws PatchGroupsSettingsHttpError
  */
-declare const patchGroupsSettings: (body: SettingsPatchSchema, options?: ApiCallOptions) => Promise<PatchGroupsSettingsHttpResponse>;
+declare function patchGroupsSettings(body: SettingsPatchSchema, options?: ApiCallOptions): Promise<PatchGroupsSettingsHttpResponse>;
 type PatchGroupsSettingsHttpResponse = {
     data: void;
     headers: Headers;
@@ -389,7 +389,7 @@ type PatchGroupsSettingsHttpError = {
  * @param groupId The ID of the group to delete.
  * @throws DeleteGroupHttpError
  */
-declare const deleteGroup: (groupId: string, options?: ApiCallOptions) => Promise<DeleteGroupHttpResponse>;
+declare function deleteGroup(groupId: string, options?: ApiCallOptions): Promise<DeleteGroupHttpResponse>;
 type DeleteGroupHttpResponse = {
     data: void;
     headers: Headers;
@@ -406,7 +406,7 @@ type DeleteGroupHttpError = {
  * @param groupId The group's unique identifier
  * @throws GetGroupHttpError
  */
-declare const getGroup: (groupId: string, options?: ApiCallOptions) => Promise<GetGroupHttpResponse>;
+declare function getGroup(groupId: string, options?: ApiCallOptions): Promise<GetGroupHttpResponse>;
 type GetGroupHttpResponse = {
     data: Group;
     headers: Headers;
@@ -424,7 +424,7 @@ type GetGroupHttpError = {
  * @param body an object with the body content
  * @throws PatchGroupHttpError
  */
-declare const patchGroup: (groupId: string, body: GroupPatchSchema, options?: ApiCallOptions) => Promise<PatchGroupHttpResponse>;
+declare function patchGroup(groupId: string, body: GroupPatchSchema, options?: ApiCallOptions): Promise<PatchGroupHttpResponse>;
 type PatchGroupHttpResponse = {
     data: void;
     headers: Headers;

package/groups.js

@@ -1,64 +1,80 @@
 import {
   clearApiCache,
   invokeFetch
-} from "./chunks/VVD2DPKQ.js";
-import "./chunks/LTNGXTXG.js";
-import "./chunks/2ZQ3ZX7F.js";
+} from "./chunks/6WNP7HZQ.js";
+import "./chunks/QAOVZB27.js";
+import "./chunks/7MMXU6EL.js";
 
 // src/public/rest/groups.ts
-var getGroups = async (query, options) => invokeFetch("groups", {
-  method: "get",
-  pathTemplate: "/api/v1/groups",
-  query,
-  options
-});
-var createGroup = async (body, options) => invokeFetch("groups", {
-  method: "post",
-  pathTemplate: "/api/v1/groups",
-  body,
-  contentType: "application/json",
-  options
-});
-var filterGroups = async (query, body, options) => invokeFetch("groups", {
-  method: "post",
-  pathTemplate: "/api/v1/groups/actions/filter",
-  query,
-  body,
-  contentType: "application/json",
-  options
-});
-var getGroupsSettings = async (options) => invokeFetch("groups", {
-  method: "get",
-  pathTemplate: "/api/v1/groups/settings",
-  options
-});
-var patchGroupsSettings = async (body, options) => invokeFetch("groups", {
-  method: "patch",
-  pathTemplate: "/api/v1/groups/settings",
-  body,
-  contentType: "application/json",
-  options
-});
-var deleteGroup = async (groupId, options) => invokeFetch("groups", {
-  method: "delete",
-  pathTemplate: "/api/v1/groups/{groupId}",
-  pathVariables: { groupId },
-  options
-});
-var getGroup = async (groupId, options) => invokeFetch("groups", {
-  method: "get",
-  pathTemplate: "/api/v1/groups/{groupId}",
-  pathVariables: { groupId },
-  options
-});
-var patchGroup = async (groupId, body, options) => invokeFetch("groups", {
-  method: "patch",
-  pathTemplate: "/api/v1/groups/{groupId}",
-  pathVariables: { groupId },
-  body,
-  contentType: "application/json",
-  options
-});
+async function getGroups(query, options) {
+  return invokeFetch("groups", {
+    method: "get",
+    pathTemplate: "/api/v1/groups",
+    query,
+    options
+  });
+}
+async function createGroup(body, options) {
+  return invokeFetch("groups", {
+    method: "post",
+    pathTemplate: "/api/v1/groups",
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function filterGroups(query, body, options) {
+  return invokeFetch("groups", {
+    method: "post",
+    pathTemplate: "/api/v1/groups/actions/filter",
+    query,
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function getGroupsSettings(options) {
+  return invokeFetch("groups", {
+    method: "get",
+    pathTemplate: "/api/v1/groups/settings",
+    options
+  });
+}
+async function patchGroupsSettings(body, options) {
+  return invokeFetch("groups", {
+    method: "patch",
+    pathTemplate: "/api/v1/groups/settings",
+    body,
+    contentType: "application/json",
+    options
+  });
+}
+async function deleteGroup(groupId, options) {
+  return invokeFetch("groups", {
+    method: "delete",
+    pathTemplate: "/api/v1/groups/{groupId}",
+    pathVariables: { groupId },
+    options
+  });
+}
+async function getGroup(groupId, options) {
+  return invokeFetch("groups", {
+    method: "get",
+    pathTemplate: "/api/v1/groups/{groupId}",
+    pathVariables: { groupId },
+    options
+  });
+}
+async function patchGroup(groupId, body, options) {
+  return invokeFetch("groups", {
+    method: "patch",
+    pathTemplate: "/api/v1/groups/{groupId}",
+    pathVariables: { groupId },
+    body,
+    contentType: "application/json",
+    options
+  });
+}
 function clearCache() {
   return clearApiCache("groups");
 }