@scm-manager/ui-api 2.36.1 → 2.36.2-20220522-120507

package/build/index.mjs

@@ -0,0 +1,3031 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/urls.ts
+var urls_exports = {};
+__export(urls_exports, {
+  concat: () => concat,
+  contextPath: () => contextPath,
+  escapeUrlForRoute: () => escapeUrlForRoute,
+  getNamespaceAndPageFromMatch: () => getNamespaceAndPageFromMatch,
+  getPageFromMatch: () => getPageFromMatch,
+  getQueryStringFromLocation: () => getQueryStringFromLocation,
+  matchedUrl: () => matchedUrl,
+  matchedUrlFromMatch: () => matchedUrlFromMatch,
+  stripEndingSlash: () => stripEndingSlash,
+  unescapeUrlForRoute: () => unescapeUrlForRoute,
+  withContextPath: () => withContextPath,
+  withEndingSlash: () => withEndingSlash,
+  withStartingSlash: () => withStartingSlash
+});
+import queryString from "query-string";
+var contextPath = window.ctxPath || "";
+function withContextPath(path) {
+  return contextPath + path;
+}
+function withEndingSlash(url) {
+  if (url.endsWith("/")) {
+    return url;
+  }
+  return url + "/";
+}
+function withStartingSlash(url) {
+  if (url.startsWith("/")) {
+    return url;
+  }
+  return "/" + url;
+}
+function concat(base, ...parts) {
+  let url = base;
+  for (const p of parts) {
+    url = withEndingSlash(url) + p;
+  }
+  return url;
+}
+function getNamespaceAndPageFromMatch(match) {
+  const namespaceFromMatch = match.params.namespace;
+  const pageFromMatch = match.params.page;
+  if (!namespaceFromMatch && !pageFromMatch) {
+    return { namespace: void 0, page: 1 };
+  }
+  if (!pageFromMatch) {
+    if (namespaceFromMatch.match(/^\d{1,3}$/)) {
+      return { namespace: void 0, page: parsePageNumber(namespaceFromMatch) };
+    } else {
+      return { namespace: namespaceFromMatch, page: 1 };
+    }
+  }
+  return { namespace: namespaceFromMatch, page: parsePageNumber(pageFromMatch) };
+}
+function getPageFromMatch(match) {
+  return parsePageNumber(match.params.page);
+}
+function parsePageNumber(pageAsString) {
+  const page = parseInt(pageAsString, 10);
+  if (isNaN(page) || !page) {
+    return 1;
+  }
+  return page;
+}
+function getQueryStringFromLocation(location) {
+  if (location.search) {
+    const query = queryString.parse(location.search).q;
+    if (query && !Array.isArray(query)) {
+      return query;
+    }
+  }
+}
+function stripEndingSlash(url) {
+  if (url.endsWith("/")) {
+    return url.substring(0, url.length - 1);
+  }
+  return url;
+}
+function matchedUrlFromMatch(match) {
+  return stripEndingSlash(match.url);
+}
+function matchedUrl(props) {
+  const match = props.match;
+  return matchedUrlFromMatch(match);
+}
+function escapeUrlForRoute(url) {
+  return url.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+}
+function unescapeUrlForRoute(url) {
+  return url.replace(/\\/g, "");
+}
+
+// src/errors.ts
+var BackendError = class extends Error {
+  constructor(content, name, statusCode) {
+    super(content.message);
+    this.context = [];
+    this.name = name;
+    this.transactionId = content.transactionId;
+    this.errorCode = content.errorCode;
+    this.url = content.url;
+    this.context = content.context;
+    this.statusCode = statusCode;
+    this.violations = content.violations;
+    this.additionalMessages = content.additionalMessages;
+  }
+};
+var UnauthorizedError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+  }
+};
+var BadGatewayError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+  }
+};
+var TokenExpiredError = class extends UnauthorizedError {
+};
+var ForbiddenError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+  }
+};
+var NotFoundError = class extends BackendError {
+  constructor(content, statusCode) {
+    super(content, "NotFoundError", statusCode);
+  }
+};
+var ConflictError = class extends BackendError {
+  constructor(content, statusCode) {
+    super(content, "ConflictError", statusCode);
+  }
+};
+var MissingLinkError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "MissingLinkError";
+  }
+};
+function createBackendError(content, statusCode) {
+  switch (statusCode) {
+    case 404:
+      return new NotFoundError(content, statusCode);
+    case 409:
+      return new ConflictError(content, statusCode);
+    default:
+      return new BackendError(content, "BackendError", statusCode);
+  }
+}
+function isBackendError(response) {
+  return response.headers.get("Content-Type") === "application/vnd.scmm-error+json;v=2";
+}
+var TOKEN_EXPIRED_ERROR_CODE = "DDS8D8unr1";
+
+// src/apiclient.ts
+var sessionId = (Date.now().toString(36) + Math.random().toString(36).substr(2, 5)).toUpperCase();
+var extractXsrfTokenFromJwt = (jwt) => {
+  const parts = jwt.split(".");
+  if (parts.length === 3) {
+    return JSON.parse(atob(parts[1])).xsrf;
+  }
+};
+var extractXsrfTokenFromCookie = (cookieString) => {
+  if (cookieString) {
+    const cookies = cookieString.split(";");
+    for (const c of cookies) {
+      const parts = c.trim().split("=");
+      if (parts[0] === "X-Bearer-Token" || parts[0] === "X-SCM-Init-Token") {
+        return extractXsrfTokenFromJwt(parts[1]);
+      }
+    }
+  }
+};
+var extractXsrfToken = () => {
+  return extractXsrfTokenFromCookie(document.cookie);
+};
+var createRequestHeaders = () => {
+  const headers = {
+    Cache: "no-cache",
+    "X-Requested-With": "XMLHttpRequest",
+    "X-SCM-Client": "WUI",
+    "X-SCM-Session-ID": sessionId
+  };
+  const xsrf = extractXsrfToken();
+  if (xsrf) {
+    headers["X-XSRF-Token"] = xsrf;
+  }
+  return headers;
+};
+var applyFetchOptions = (o) => {
+  if (o.headers) {
+    o.headers = __spreadValues({}, createRequestHeaders());
+  } else {
+    o.headers = createRequestHeaders();
+  }
+  o.credentials = "same-origin";
+  return o;
+};
+function handleFailure(response) {
+  if (!response.ok) {
+    if (response.status === 401) {
+      if (isBackendError(response)) {
+        return response.json().then((content) => {
+          if (content.errorCode === TOKEN_EXPIRED_ERROR_CODE) {
+            throw new TokenExpiredError("Token expired", 401);
+          } else {
+            throw new UnauthorizedError("Unauthorized", 401);
+          }
+        });
+      }
+      throw new UnauthorizedError("Unauthorized", 401);
+    } else if (response.status === 403) {
+      throw new ForbiddenError("Forbidden", 403);
+    } else if (response.status === 502) {
+      throw new BadGatewayError("Bad Gateway", 502);
+    } else if (isBackendError(response)) {
+      return response.json().then((content) => {
+        throw createBackendError(content, response.status);
+      });
+    } else {
+      throw new Error("server returned status code " + response.status);
+    }
+  }
+  return response;
+}
+function createUrl(url) {
+  if (url.includes("://")) {
+    return url;
+  }
+  let urlWithStartingSlash = url;
+  if (url.indexOf("/") !== 0) {
+    urlWithStartingSlash = "/" + urlWithStartingSlash;
+  }
+  return `${contextPath}/api/v2${urlWithStartingSlash}`;
+}
+function createUrlWithIdentifiers(url) {
+  return createUrl(url) + "?X-SCM-Client=WUI&X-SCM-Session-ID=" + sessionId;
+}
+var ApiClient = class {
+  constructor() {
+    this.errorListeners = [];
+    this.requestListeners = [];
+    this.get = (url) => {
+      return this.request(url, applyFetchOptions({})).then(handleFailure).catch(this.notifyAndRethrow);
+    };
+    this.post = (url, payload, contentType = "application/json", additionalHeaders = {}) => {
+      return this.httpRequestWithJSONBody("POST", url, contentType, additionalHeaders, payload);
+    };
+    this.postText = (url, payload, additionalHeaders = {}) => {
+      return this.httpRequestWithTextBody("POST", url, additionalHeaders, payload);
+    };
+    this.putText = (url, payload, additionalHeaders = {}) => {
+      return this.httpRequestWithTextBody("PUT", url, additionalHeaders, payload);
+    };
+    this.postBinary = (url, fileAppender, additionalHeaders = {}) => {
+      const formData = new FormData();
+      fileAppender(formData);
+      const options = {
+        method: "POST",
+        body: formData,
+        headers: additionalHeaders
+      };
+      return this.httpRequestWithBinaryBody(options, url);
+    };
+    this.head = (url) => {
+      let options = {
+        method: "HEAD"
+      };
+      options = applyFetchOptions(options);
+      return this.request(url, options).then(handleFailure).catch(this.notifyAndRethrow);
+    };
+    this.delete = (url) => {
+      let options = {
+        method: "DELETE"
+      };
+      options = applyFetchOptions(options);
+      return this.request(url, options).then(handleFailure).catch(this.notifyAndRethrow);
+    };
+    this.httpRequestWithJSONBody = (method, url, contentType, additionalHeaders, payload) => {
+      const options = {
+        method,
+        headers: additionalHeaders
+      };
+      if (payload) {
+        options.body = JSON.stringify(payload);
+      }
+      return this.httpRequestWithBinaryBody(options, url, contentType);
+    };
+    this.httpRequestWithTextBody = (method, url, additionalHeaders = {}, payload) => {
+      const options = {
+        method,
+        headers: additionalHeaders
+      };
+      options.body = payload;
+      return this.httpRequestWithBinaryBody(options, url, "text/plain");
+    };
+    this.httpRequestWithBinaryBody = (options, url, contentType) => {
+      options = applyFetchOptions(options);
+      if (contentType) {
+        if (!options.headers) {
+          options.headers = {};
+        }
+        options.headers["Content-Type"] = contentType;
+      }
+      return this.request(url, options).then(handleFailure).catch(this.notifyAndRethrow);
+    };
+    this.onRequest = (requestListener) => {
+      this.requestListeners.push(requestListener);
+    };
+    this.onError = (errorListener) => {
+      this.errorListeners.push(errorListener);
+    };
+    this.request = (url, options) => {
+      this.notifyRequestListeners(url, options);
+      return fetch(createUrl(url), options);
+    };
+    this.notifyRequestListeners = (url, options) => {
+      this.requestListeners.forEach((requestListener) => requestListener(url, options));
+    };
+    this.notifyAndRethrow = (error) => {
+      this.errorListeners.forEach((errorListener) => errorListener(error));
+      throw error;
+    };
+  }
+  put(url, payload, contentType = "application/json", additionalHeaders = {}) {
+    return this.httpRequestWithJSONBody("PUT", url, contentType, additionalHeaders, payload);
+  }
+  subscribe(url, argument) {
+    const es = new EventSource(createUrlWithIdentifiers(url), {
+      withCredentials: true
+    });
+    let listeners;
+    if ("onMessage" in argument) {
+      listeners = argument.onMessage;
+      if (argument.onError) {
+        es.onerror = argument.onError;
+      }
+      if (argument.onOpen) {
+        es.onopen = argument.onOpen;
+      }
+    } else {
+      listeners = argument;
+    }
+    for (const type in listeners) {
+      es.addEventListener(type, listeners[type]);
+    }
+    return () => es.close();
+  }
+};
+var apiClient = new ApiClient();
+
+// src/base.ts
+import { useQuery } from "react-query";
+
+// src/LegacyContext.tsx
+import React, { createContext, useContext } from "react";
+import { useQueryClient } from "react-query";
+var Context = createContext(void 0);
+var useLegacyContext = () => {
+  const context = useContext(Context);
+  if (!context) {
+    throw new Error("useLegacyContext can't be used outside of ApiProvider");
+  }
+  return context;
+};
+var createInitialContext = (queryClient2, base) => {
+  const ctx = __spreadProps(__spreadValues({}, base), {
+    initialize: () => {
+      if (ctx.onIndexFetched) {
+        const index = queryClient2.getQueryData("index");
+        if (index) {
+          ctx.onIndexFetched(index);
+        }
+      }
+      if (ctx.onMeFetched) {
+        const me = queryClient2.getQueryData("me");
+        if (me) {
+          ctx.onMeFetched(me);
+        }
+      }
+    }
+  });
+  return ctx;
+};
+var LegacyContextProvider = ({ onIndexFetched, onMeFetched, children }) => {
+  const queryClient2 = useQueryClient();
+  const ctx = createInitialContext(queryClient2, { onIndexFetched, onMeFetched });
+  return /* @__PURE__ */ React.createElement(Context.Provider, {
+    value: ctx
+  }, children);
+};
+
+// src/links.ts
+var requiredLink = (object, name, subName) => {
+  const link = object._links[name];
+  if (!link) {
+    throw new MissingLinkError(`could not find link with name ${name}`);
+  }
+  if (Array.isArray(link)) {
+    if (subName) {
+      const subLink = link.find((l) => l.name === subName);
+      if (subLink) {
+        return subLink.href;
+      }
+      throw new Error(`could not return href, sub-link ${subName} in ${name} does not exist`);
+    }
+    throw new Error(`could not return href, link ${name} is a multi link`);
+  }
+  return link.href;
+};
+var objectLink = (object, name) => {
+  const link = object._links[name];
+  if (!link) {
+    return null;
+  }
+  if (Array.isArray(link)) {
+    throw new Error(`could not return href, link ${name} is a multi link`);
+  }
+  return link.href;
+};
+
+// src/base.ts
+var useIndex = () => {
+  const legacy = useLegacyContext();
+  return useQuery("index", () => apiClient.get("/").then((response) => response.json()), {
+    onSuccess: (index) => {
+      if (legacy.onIndexFetched) {
+        legacy.onIndexFetched(index);
+      }
+    },
+    refetchOnMount: false,
+    retry: (failureCount, error) => {
+      return error instanceof UnauthorizedError && failureCount === 0;
+    }
+  });
+};
+var useIndexLink = (name) => {
+  const { data } = useIndex();
+  if (!data) {
+    throw new Error("could not find index data");
+  }
+  const linkObject = data._links[name];
+  if (linkObject && linkObject.href) {
+    return linkObject.href;
+  }
+};
+var useIndexLinks = () => {
+  const { data } = useIndex();
+  if (!data) {
+    throw new Error("could not find index data");
+  }
+  return data._links;
+};
+var useRequiredIndexLink = (name) => {
+  const link = useIndexLink(name);
+  if (!link) {
+    throw new MissingLinkError(`Could not find link ${name} in index resource`);
+  }
+  return link;
+};
+var useVersion = () => {
+  const { data } = useIndex();
+  if (!data) {
+    throw new Error("could not find index data");
+  }
+  const { version } = data;
+  if (!version) {
+    throw new Error("could not find version in index data");
+  }
+  return version;
+};
+var useIndexJsonResource = (name) => {
+  const link = useIndexLink(name);
+  return useQuery(name, () => apiClient.get(link).then((response) => response.json()), {
+    enabled: !!link
+  });
+};
+var useJsonResource = (entity, name, key) => useQuery(key, () => apiClient.get(requiredLink(entity, name)).then((response) => response.json()));
+function fetchResourceFromLocationHeader(response) {
+  const location = response.headers.get("Location");
+  if (!location) {
+    throw new Error("Server does not return required Location header");
+  }
+  return apiClient.get(location);
+}
+var getResponseJson = (response) => response.json();
+
+// src/login.ts
+import { useMutation, useQuery as useQuery2 } from "react-query";
+
+// src/reset.ts
+import { useQueryClient as useQueryClient2 } from "react-query";
+var reset = (queryClient2) => {
+  queryClient2.removeQueries({
+    predicate: ({ queryKey }) => queryKey !== "index"
+  });
+  return queryClient2.invalidateQueries("index");
+};
+var useReset = () => {
+  const queryClient2 = useQueryClient2();
+  return () => reset(queryClient2);
+};
+
+// src/login.ts
+import { useCallback } from "react";
+var useMe = () => {
+  const legacy = useLegacyContext();
+  const link = useIndexLink("me");
+  return useQuery2("me", () => apiClient.get(link).then((response) => response.json()), {
+    enabled: !!link,
+    onSuccess: (me) => {
+      if (legacy.onMeFetched) {
+        legacy.onMeFetched(me);
+      }
+    }
+  });
+};
+var useRequiredMe = () => {
+  const { data } = useMe();
+  if (!data) {
+    throw new Error("Could not find 'me' in cache");
+  }
+  return data;
+};
+var useSubject = () => {
+  const link = useIndexLink("login");
+  const { isLoading, error, data: me } = useMe();
+  const isAnonymous = (me == null ? void 0 : me.name) === "_anonymous";
+  const isAuthenticated = !isAnonymous && !!me && !link;
+  return {
+    isAuthenticated,
+    isAnonymous,
+    isLoading,
+    error,
+    me
+  };
+};
+var useLogin = () => {
+  const link = useIndexLink("login");
+  const reset2 = useReset();
+  const { mutate, isLoading, error } = useMutation((credentials) => apiClient.post(link, credentials), {
+    onSuccess: reset2
+  });
+  const login = (username, password) => {
+    mutate({ cookie: true, grant_type: "password", username, password });
+  };
+  return {
+    login: link ? login : void 0,
+    isLoading,
+    error
+  };
+};
+var useLogout = () => {
+  const link = useIndexLink("logout");
+  const reset2 = useReset();
+  const { mutate, isLoading, error, data } = useMutation(() => apiClient.delete(link).then((r) => r.status === 200 ? r.json() : {}), {
+    onSuccess: (response) => {
+      if (response == null ? void 0 : response.logoutRedirect) {
+        window.location.assign(response.logoutRedirect);
+      }
+      return reset2();
+    }
+  });
+  const logout = useCallback(() => {
+    mutate({});
+  }, [mutate]);
+  return {
+    logout: link && !data ? logout : void 0,
+    isLoading,
+    error
+  };
+};
+
+// src/groups.ts
+import { useMutation as useMutation2, useQuery as useQuery3, useQueryClient as useQueryClient3 } from "react-query";
+
+// src/utils.ts
+var createQueryString = (params) => {
+  return Object.keys(params).map((k) => encodeURIComponent(k) + "=" + encodeURIComponent(params[k])).join("&");
+};
+
+// src/groups.ts
+var useGroups = (request) => {
+  const queryClient2 = useQueryClient3();
+  const indexLink = useRequiredIndexLink("groups");
+  const queryParams = {};
+  if (request == null ? void 0 : request.search) {
+    queryParams.q = request.search;
+  }
+  if (request == null ? void 0 : request.page) {
+    queryParams.page = request.page.toString();
+  }
+  return useQuery3(["groups", (request == null ? void 0 : request.search) || "", (request == null ? void 0 : request.page) || 0], () => apiClient.get(`${indexLink}?${createQueryString(queryParams)}`).then((response) => response.json()), {
+    onSuccess: (groups) => {
+      groups._embedded.groups.forEach((group) => queryClient2.setQueryData(["group", group.name], group));
+    }
+  });
+};
+var useGroup = (name) => {
+  const indexLink = useRequiredIndexLink("groups");
+  return useQuery3(["group", name], () => apiClient.get(concat(indexLink, name)).then((response) => response.json()));
+};
+var createGroup = (link) => {
+  return (group) => {
+    return apiClient.post(link, group, "application/vnd.scmm-group+json;v=2").then((response) => {
+      const location = response.headers.get("Location");
+      if (!location) {
+        throw new Error("Server does not return required Location header");
+      }
+      return apiClient.get(location);
+    }).then((response) => response.json());
+  };
+};
+var useCreateGroup = () => {
+  const queryClient2 = useQueryClient3();
+  const link = useRequiredIndexLink("groups");
+  const { mutate, data, isLoading, error } = useMutation2(createGroup(link), {
+    onSuccess: (group) => {
+      queryClient2.setQueryData(["group", group.name], group);
+      return queryClient2.invalidateQueries(["groups"]);
+    }
+  });
+  return {
+    create: (group) => mutate(group),
+    isLoading,
+    error,
+    group: data
+  };
+};
+var useUpdateGroup = () => {
+  const queryClient2 = useQueryClient3();
+  const { mutate, isLoading, error, data } = useMutation2((group) => {
+    const updateUrl = group._links.update.href;
+    return apiClient.put(updateUrl, group, "application/vnd.scmm-group+json;v=2");
+  }, {
+    onSuccess: async (_, group) => {
+      await queryClient2.invalidateQueries(["group", group.name]);
+      await queryClient2.invalidateQueries(["groups"]);
+    }
+  });
+  return {
+    update: (group) => mutate(group),
+    isLoading,
+    error,
+    isUpdated: !!data
+  };
+};
+var useDeleteGroup = () => {
+  const queryClient2 = useQueryClient3();
+  const { mutate, isLoading, error, data } = useMutation2((group) => {
+    const deleteUrl = group._links.delete.href;
+    return apiClient.delete(deleteUrl);
+  }, {
+    onSuccess: async (_, name) => {
+      await queryClient2.removeQueries(["group", name]);
+      await queryClient2.invalidateQueries(["groups"]);
+    }
+  });
+  return {
+    remove: (group) => mutate(group),
+    isLoading,
+    error,
+    isDeleted: !!data
+  };
+};
+
+// src/users.ts
+import { useMutation as useMutation3, useQuery as useQuery4, useQueryClient as useQueryClient4 } from "react-query";
+var useUsers = (request) => {
+  const queryClient2 = useQueryClient4();
+  const indexLink = useRequiredIndexLink("users");
+  const queryParams = {};
+  if (request == null ? void 0 : request.search) {
+    queryParams.q = request.search;
+  }
+  if (request == null ? void 0 : request.page) {
+    queryParams.page = request.page.toString();
+  }
+  return useQuery4(["users", (request == null ? void 0 : request.search) || "", (request == null ? void 0 : request.page) || 0], () => apiClient.get(`${indexLink}?${createQueryString(queryParams)}`).then((response) => response.json()), {
+    onSuccess: (users) => {
+      var _a;
+      (_a = users._embedded) == null ? void 0 : _a.users.forEach((user) => queryClient2.setQueryData(["user", user.name], user));
+    }
+  });
+};
+var useUser = (name) => {
+  const indexLink = useRequiredIndexLink("users");
+  return useQuery4(["user", name], () => apiClient.get(concat(indexLink, name)).then((response) => response.json()));
+};
+var createUser = (link) => {
+  return (user) => {
+    return apiClient.post(link, user, "application/vnd.scmm-user+json;v=2").then((response) => {
+      const location = response.headers.get("Location");
+      if (!location) {
+        throw new Error("Server does not return required Location header");
+      }
+      return apiClient.get(location);
+    }).then((response) => response.json());
+  };
+};
+var useCreateUser = () => {
+  const queryClient2 = useQueryClient4();
+  const link = useRequiredIndexLink("users");
+  const { mutate, data, isLoading, error } = useMutation3(createUser(link), {
+    onSuccess: (user) => {
+      queryClient2.setQueryData(["user", user.name], user);
+      return queryClient2.invalidateQueries(["users"]);
+    }
+  });
+  return {
+    create: (user) => mutate(user),
+    isLoading,
+    error,
+    user: data
+  };
+};
+var useUpdateUser = () => {
+  const queryClient2 = useQueryClient4();
+  const { mutate, isLoading, error, data } = useMutation3((user) => {
+    const updateUrl = user._links.update.href;
+    return apiClient.put(updateUrl, user, "application/vnd.scmm-user+json;v=2");
+  }, {
+    onSuccess: async (_, user) => {
+      await queryClient2.invalidateQueries(["user", user.name]);
+      await queryClient2.invalidateQueries(["users"]);
+    }
+  });
+  return {
+    update: (user) => mutate(user),
+    isLoading,
+    error,
+    isUpdated: !!data
+  };
+};
+var useDeleteUser = () => {
+  const queryClient2 = useQueryClient4();
+  const { mutate, isLoading, error, data } = useMutation3((user) => {
+    const deleteUrl = user._links.delete.href;
+    return apiClient.delete(deleteUrl);
+  }, {
+    onSuccess: async (_, name) => {
+      await queryClient2.removeQueries(["user", name]);
+      await queryClient2.invalidateQueries(["users"]);
+    }
+  });
+  return {
+    remove: (user) => mutate(user),
+    isLoading,
+    error,
+    isDeleted: !!data
+  };
+};
+var convertToInternal = (url, newPassword) => {
+  return apiClient.put(url, {
+    newPassword
+  }, "application/vnd.scmm-user+json;v=2");
+};
+var convertToExternal = (url) => {
+  return apiClient.put(url, {}, "application/vnd.scmm-user+json;v=2");
+};
+var useConvertToInternal = () => {
+  const queryClient2 = useQueryClient4();
+  const { mutate, isLoading, error, data } = useMutation3(({ user, password }) => convertToInternal(user._links.convertToInternal.href, password), {
+    onSuccess: async (_, { user }) => {
+      await queryClient2.invalidateQueries(["user", user.name]);
+      await queryClient2.invalidateQueries(["users"]);
+    }
+  });
+  return {
+    convertToInternal: (user, password) => mutate({ user, password }),
+    isLoading,
+    error,
+    isConverted: !!data
+  };
+};
+var useConvertToExternal = () => {
+  const queryClient2 = useQueryClient4();
+  const { mutate, isLoading, error, data } = useMutation3((user) => convertToExternal(user._links.convertToExternal.href), {
+    onSuccess: async (_, user) => {
+      await queryClient2.invalidateQueries(["user", user.name]);
+      await queryClient2.invalidateQueries(["users"]);
+    }
+  });
+  return {
+    convertToExternal: (user) => mutate(user),
+    isLoading,
+    error,
+    isConverted: !!data
+  };
+};
+var CONTENT_TYPE_PASSWORD_OVERWRITE = "application/vnd.scmm-passwordOverwrite+json;v=2";
+var useSetUserPassword = (user) => {
+  const { data, isLoading, error, mutate, reset: reset2 } = useMutation3((password) => apiClient.put(requiredLink(user, "password"), {
+    newPassword: password
+  }, CONTENT_TYPE_PASSWORD_OVERWRITE));
+  return {
+    setPassword: (newPassword) => mutate(newPassword),
+    passwordOverwritten: !!data,
+    isLoading,
+    error,
+    reset: reset2
+  };
+};
+var CONTENT_TYPE_PASSWORD_CHANGE = "application/vnd.scmm-passwordChange+json;v=2";
+var useChangeUserPassword = (user) => {
+  const { data, isLoading, error, mutate, reset: reset2 } = useMutation3((request) => apiClient.put(requiredLink(user, "password"), request, CONTENT_TYPE_PASSWORD_CHANGE));
+  return {
+    changePassword: (oldPassword, newPassword) => mutate({ oldPassword, newPassword }),
+    passwordChanged: !!data,
+    isLoading,
+    error,
+    reset: reset2
+  };
+};
+
+// src/suggestions.ts
+var useSuggestions = (link) => {
+  if (!link) {
+    return () => Promise.resolve([]);
+  }
+  const url = link + "?q=";
+  return (inputValue) => {
+    if (inputValue.length < 2) {
+      return Promise.resolve([]);
+    }
+    return apiClient.get(url + inputValue).then((response) => response.json()).then((json) => json.map((element) => ({
+      value: element,
+      label: element.displayName ? `${element.displayName} (${element.id})` : element.id
+    })));
+  };
+};
+
+// src/userSuggestions.ts
+var useUserSuggestions = () => {
+  const indexLinks = useIndexLinks();
+  const autocompleteLink = indexLinks.autocomplete.find((i) => i.name === "users");
+  return useSuggestions(autocompleteLink == null ? void 0 : autocompleteLink.href);
+};
+
+// src/groupSuggestions.ts
+var useGroupSuggestions = () => {
+  const indexLinks = useIndexLinks();
+  const autocompleteLink = indexLinks.autocomplete.find((i) => i.name === "groups");
+  return useSuggestions(autocompleteLink == null ? void 0 : autocompleteLink.href);
+};
+
+// src/namespaceSuggestions.ts
+var useNamespaceSuggestions = () => {
+  const indexLinks = useIndexLinks();
+  const autocompleteLink = indexLinks.autocomplete.find((i) => i.name === "namespaces");
+  return useSuggestions(autocompleteLink == null ? void 0 : autocompleteLink.href);
+};
+
+// src/repositories.ts
+import { useMutation as useMutation4, useQuery as useQuery5, useQueryClient as useQueryClient5 } from "react-query";
+
+// src/keys.ts
+var repoQueryKey = (repository, ...values) => {
+  return ["repository", repository.namespace, repository.name, ...values];
+};
+var isBranch = (branch) => {
+  return branch.name !== void 0;
+};
+var branchQueryKey = (repository, branch, ...values) => {
+  let branchName;
+  if (!branch) {
+    branchName = "_";
+  } else if (isBranch(branch)) {
+    branchName = branch.name;
+  } else {
+    branchName = branch;
+  }
+  return [...repoQueryKey(repository), "branch", branchName, ...values];
+};
+
+// src/repositories.ts
+import { useEffect, useState } from "react";
+var useRepositories = (request) => {
+  var _a, _b, _c;
+  const queryClient2 = useQueryClient5();
+  const indexLink = useRequiredIndexLink("repositories");
+  const namespaceLink = (_b = (_a = request == null ? void 0 : request.namespace) == null ? void 0 : _a._links.repositories) == null ? void 0 : _b.href;
+  const link = namespaceLink || indexLink;
+  const queryParams = {};
+  if (request == null ? void 0 : request.search) {
+    queryParams.q = request.search;
+  }
+  if (request == null ? void 0 : request.page) {
+    queryParams.page = request.page.toString();
+  }
+  return useQuery5(["repositories", (_c = request == null ? void 0 : request.namespace) == null ? void 0 : _c.namespace, (request == null ? void 0 : request.search) || "", (request == null ? void 0 : request.page) || 0], () => apiClient.get(`${link}?${createQueryString(queryParams)}`).then((response) => response.json()), {
+    enabled: !(request == null ? void 0 : request.disabled),
+    onSuccess: (repositories) => {
+      var _a2;
+      (_a2 = repositories._embedded) == null ? void 0 : _a2.repositories.forEach((repository) => {
+        queryClient2.setQueryData(["repository", repository.namespace, repository.name], repository);
+      });
+    }
+  });
+};
+var createRepository = (link) => {
+  return (request) => {
+    let createLink = link;
+    if (request.initialize) {
+      createLink += "?initialize=true";
+    }
+    return apiClient.post(createLink, request.repository, "application/vnd.scmm-repository+json;v=2").then((response) => {
+      const location = response.headers.get("Location");
+      if (!location) {
+        throw new Error("Server does not return required Location header");
+      }
+      return apiClient.get(location);
+    }).then((response) => response.json());
+  };
+};
+var useCreateRepository = () => {
+  const queryClient2 = useQueryClient5();
+  const link = useRequiredIndexLink("repositories");
+  const { mutate, data, isLoading, error } = useMutation4(createRepository(link), {
+    onSuccess: (repository) => {
+      queryClient2.setQueryData(["repository", repository.namespace, repository.name], repository);
+      return queryClient2.invalidateQueries(["repositories"]);
+    }
+  });
+  return {
+    create: (repository, initialize) => {
+      mutate({ repository, initialize });
+    },
+    isLoading,
+    error,
+    repository: data
+  };
+};
+var useRepositoryTypes = () => useIndexJsonResource("repositoryTypes");
+var useRepository = (namespace, name) => {
+  const link = useRequiredIndexLink("repositories");
+  return useQuery5(["repository", namespace, name], () => apiClient.get(concat(link, namespace, name)).then((response) => response.json()));
+};
+var useDeleteRepository = (options) => {
+  const queryClient2 = useQueryClient5();
+  const { mutate, isLoading, error, data } = useMutation4((repository) => {
+    const link = requiredLink(repository, "delete");
+    return apiClient.delete(link);
+  }, {
+    onSuccess: async (_, repository) => {
+      if (options == null ? void 0 : options.onSuccess) {
+        options.onSuccess(repository);
+      }
+      queryClient2.removeQueries(repoQueryKey(repository));
+      await queryClient2.invalidateQueries(["repositories"]);
+    }
+  });
+  return {
+    remove: (repository) => mutate(repository),
+    isLoading,
+    error,
+    isDeleted: !!data
+  };
+};
+var useUpdateRepository = () => {
+  const queryClient2 = useQueryClient5();
+  const { mutate, isLoading, error, data } = useMutation4((repository) => {
+    const link = requiredLink(repository, "update");
+    return apiClient.put(link, repository, "application/vnd.scmm-repository+json;v=2");
+  }, {
+    onSuccess: async (_, repository) => {
+      await queryClient2.invalidateQueries(repoQueryKey(repository));
+      await queryClient2.invalidateQueries(["repositories"]);
+    }
+  });
+  return {
+    update: (repository) => mutate(repository),
+    isLoading,
+    error,
+    isUpdated: !!data
+  };
+};
+var useArchiveRepository = () => {
+  const queryClient2 = useQueryClient5();
+  const { mutate, isLoading, error, data } = useMutation4((repository) => {
+    const link = requiredLink(repository, "archive");
+    return apiClient.post(link);
+  }, {
+    onSuccess: async (_, repository) => {
+      await queryClient2.invalidateQueries(repoQueryKey(repository));
+      await queryClient2.invalidateQueries(["repositories"]);
+    }
+  });
+  return {
+    archive: (repository) => mutate(repository),
+    isLoading,
+    error,
+    isArchived: !!data
+  };
+};
+var useUnarchiveRepository = () => {
+  const queryClient2 = useQueryClient5();
+  const { mutate, isLoading, error, data } = useMutation4((repository) => {
+    const link = requiredLink(repository, "unarchive");
+    return apiClient.post(link);
+  }, {
+    onSuccess: async (_, repository) => {
+      await queryClient2.invalidateQueries(repoQueryKey(repository));
+      await queryClient2.invalidateQueries(["repositories"]);
+    }
+  });
+  return {
+    unarchive: (repository) => mutate(repository),
+    isLoading,
+    error,
+    isUnarchived: !!data
+  };
+};
+var useRunHealthCheck = () => {
+  const queryClient2 = useQueryClient5();
+  const { mutate, isLoading, error, data } = useMutation4((repository) => {
+    const link = requiredLink(repository, "runHealthCheck");
+    return apiClient.post(link);
+  }, {
+    onSuccess: async (_, repository) => {
+      await queryClient2.invalidateQueries(repoQueryKey(repository));
+    }
+  });
+  return {
+    runHealthCheck: (repository) => mutate(repository),
+    isLoading,
+    error,
+    isRunning: !!data
+  };
+};
+var useExportInfo = (repository) => {
+  const link = requiredLink(repository, "exportInfo");
+  const { isLoading, isFetching, error, data } = useQuery5(["repository", repository.namespace, repository.name, "exportInfo"], () => apiClient.get(link).then((response) => response.json()), {});
+  return {
+    isLoading,
+    isFetching,
+    error: error instanceof NotFoundError ? null : error,
+    data
+  };
+};
+var EXPORT_MEDIA_TYPE = "application/vnd.scmm-repositoryExport+json;v=2";
+var useExportRepository = () => {
+  const queryClient2 = useQueryClient5();
+  const [intervalId, setIntervalId] = useState();
+  useEffect(() => {
+    return () => {
+      if (intervalId) {
+        clearInterval(intervalId);
+      }
+    };
+  }, [intervalId]);
+  const { mutate, isLoading, error, data } = useMutation4(({ repository, options }) => {
+    const infolink = requiredLink(repository, "exportInfo");
+    let link = requiredLink(repository, options.withMetadata ? "fullExport" : "export");
+    if (options.compressed) {
+      link += "?compressed=true";
+    }
+    return apiClient.post(link, { password: options.password, async: true }, EXPORT_MEDIA_TYPE).then(() => queryClient2.invalidateQueries(repoQueryKey(repository))).then(() => queryClient2.invalidateQueries(["repositories"])).then(() => {
+      return new Promise((resolve, reject) => {
+        const id = setInterval(() => {
+          apiClient.get(infolink).then((r) => r.json()).then((info) => {
+            if (info._links.download) {
+              clearInterval(id);
+              resolve(info);
+            }
+          }).catch((e) => {
+            clearInterval(id);
+            reject(e);
+          });
+        }, 1e3);
+        setIntervalId(id);
+      });
+    });
+  }, {
+    onSuccess: async (_, { repository }) => {
+      await queryClient2.invalidateQueries(repoQueryKey(repository));
+      await queryClient2.invalidateQueries(["repositories"]);
+    }
+  });
+  return {
+    exportRepository: (repository, options) => mutate({ repository, options }),
+    isLoading,
+    error,
+    data
+  };
+};
+var usePaths = (repository, revision) => {
+  const link = requiredLink(repository, "paths").replace("{revision}", revision);
+  return useQuery5(repoQueryKey(repository, "paths", revision), () => apiClient.get(link).then((response) => response.json()));
+};
+var useRenameRepository = (repository) => {
+  const queryClient2 = useQueryClient5();
+  const url = objectLink(repository, "renameWithNamespace") || objectLink(repository, "rename");
+  if (!url) {
+    throw new MissingLinkError(`could not find rename link on repository ${repository.namespace}/${repository.name}`);
+  }
+  const { mutate, isLoading, error, data } = useMutation4(({ name, namespace }) => apiClient.post(url, { namespace, name }, "application/vnd.scmm-repository+json;v=2"), {
+    onSuccess: () => queryClient2.removeQueries(repoQueryKey(repository))
+  });
+  return {
+    renameRepository: (namespace, name) => mutate({ namespace, name }),
+    isLoading,
+    error,
+    isRenamed: !!data
+  };
+};
+
+// src/namespaces.ts
+import { useQuery as useQuery6 } from "react-query";
+var useNamespaces = () => {
+  return useIndexJsonResource("namespaces");
+};
+var useNamespace = (name) => {
+  const namespacesLink = useRequiredIndexLink("namespaces");
+  return useQuery6(["namespace", name], () => apiClient.get(concat(namespacesLink, name)).then((response) => response.json()));
+};
+var useNamespaceStrategies = () => {
+  return useIndexJsonResource("namespaceStrategies");
+};
+
+// src/branches.ts
+import { useInfiniteQuery, useMutation as useMutation5, useQuery as useQuery7, useQueryClient as useQueryClient6 } from "react-query";
+import { useEffect as useEffect2 } from "react";
+var useBranches = (repository) => {
+  const queryClient2 = useQueryClient6();
+  const link = requiredLink(repository, "branches");
+  return useQuery7(repoQueryKey(repository, "branches"), () => apiClient.get(link).then((response) => response.json()), {
+    onSuccess: () => {
+      return queryClient2.invalidateQueries(branchDetailsQueryKey(repository));
+    }
+  });
+};
+var useBranch = (repository, name) => {
+  const link = requiredLink(repository, "branches");
+  return useQuery7(branchQueryKey(repository, name), () => apiClient.get(concat(link, encodeURIComponent(name))).then((response) => response.json()));
+};
+function chunkBranches(branches) {
+  const chunks = [];
+  const chunkSize = 5;
+  let chunkIndex = 0;
+  for (const branch of branches) {
+    if (!chunks[chunkIndex]) {
+      chunks[chunkIndex] = [];
+    }
+    chunks[chunkIndex].push(branch);
+    if (chunks[chunkIndex].length >= chunkSize) {
+      chunkIndex = chunkIndex + 1;
+    }
+  }
+  return chunks;
+}
+var branchDetailsQueryKey = (repository, branch = void 0) => {
+  let branchName;
+  if (!branch) {
+    branchName = "_";
+  } else {
+    branchName = branch;
+  }
+  return [...repoQueryKey(repository), "branch-details", branchName];
+};
+var useBranchDetailsCollection = (repository, branches) => {
+  var _a;
+  const link = requiredLink(repository, "branchDetailsCollection");
+  const chunks = chunkBranches(branches);
+  const queryClient2 = useQueryClient6();
+  const { data, isLoading, error, fetchNextPage } = useInfiniteQuery(branchDetailsQueryKey(repository), ({ pageParam = 0 }) => {
+    var _a2;
+    const encodedBranches = (_a2 = chunks[pageParam]) == null ? void 0 : _a2.map((b) => encodeURIComponent(b.name)).join("&branches=");
+    return apiClient.get(concat(link, `?branches=${encodedBranches}`)).then((response) => response.json());
+  }, {
+    getNextPageParam: (lastPage, allPages) => {
+      if (allPages.length >= chunks.length) {
+        return void 0;
+      }
+      return allPages.length;
+    },
+    onSuccess: (newData) => {
+      newData.pages.flatMap((d) => {
+        var _a2;
+        return (_a2 = d._embedded) == null ? void 0 : _a2.branchDetails;
+      }).filter((d) => !!d).forEach((d) => queryClient2.setQueryData(branchDetailsQueryKey(repository, d.branchName), () => d));
+    }
+  });
+  useEffect2(() => {
+    fetchNextPage();
+  }, [data, fetchNextPage]);
+  return {
+    data: (_a = data == null ? void 0 : data.pages) == null ? void 0 : _a.map((d) => {
+      var _a2;
+      return (_a2 = d._embedded) == null ? void 0 : _a2.branchDetails;
+    }).flat(1),
+    isLoading,
+    error
+  };
+};
+var useBranchDetails = (repository, branch) => {
+  const link = branch._links.details.href;
+  const queryKey = branchDetailsQueryKey(repository, branch.name);
+  return useQuery7(queryKey, () => apiClient.get(link).then((response) => response.json()));
+};
+var createBranch = (link) => {
+  return (branch) => {
+    return apiClient.post(link, branch, "application/vnd.scmm-branchRequest+json;v=2").then((response) => {
+      const location = response.headers.get("Location");
+      if (!location) {
+        throw new Error("Server does not return required Location header");
+      }
+      return apiClient.get(location);
+    }).then((response) => response.json());
+  };
+};
+var useCreateBranch = (repository) => {
+  const queryClient2 = useQueryClient6();
+  const link = requiredLink(repository, "branches");
+  const { mutate, isLoading, error, data } = useMutation5(createBranch(link), {
+    onSuccess: async (branch) => {
+      queryClient2.setQueryData(branchQueryKey(repository, branch), branch);
+      await queryClient2.invalidateQueries(repoQueryKey(repository, "branches"));
+    }
+  });
+  return {
+    create: (branch) => mutate(branch),
+    isLoading,
+    error,
+    branch: data
+  };
+};
+var useDeleteBranch = (repository) => {
+  const queryClient2 = useQueryClient6();
+  const { mutate, isLoading, error, data } = useMutation5((branch) => {
+    const deleteUrl = branch._links.delete.href;
+    return apiClient.delete(deleteUrl);
+  }, {
+    onSuccess: async (_, branch) => {
+      queryClient2.removeQueries(branchQueryKey(repository, branch));
+      await queryClient2.invalidateQueries(repoQueryKey(repository, "branches"));
+    }
+  });
+  return {
+    remove: (branch) => mutate(branch),
+    isLoading,
+    error,
+    isDeleted: !!data
+  };
+};
+var useDefaultBranch = (repository) => {
+  const link = requiredLink(repository, "defaultBranch");
+  return useQuery7(branchQueryKey(repository, "__default-branch"), () => apiClient.get(link).then((response) => response.json()));
+};
+
+// src/changesets.ts
+import { useQuery as useQuery8, useQueryClient as useQueryClient7 } from "react-query";
+var changesetQueryKey = (repository, id) => {
+  return repoQueryKey(repository, "changeset", id);
+};
+var useChangesets = (repository, request) => {
+  const queryClient2 = useQueryClient7();
+  let link;
+  let branch = "_";
+  if (request == null ? void 0 : request.branch) {
+    link = requiredLink(request.branch, "history");
+    branch = request.branch.name;
+  } else {
+    link = requiredLink(repository, "changesets");
+  }
+  if ((request == null ? void 0 : request.page) || (request == null ? void 0 : request.limit)) {
+    if ((request == null ? void 0 : request.page) && (request == null ? void 0 : request.limit)) {
+      link = `${link}?page=${request.page}&pageSize=${request.limit}`;
+    } else if (request.page) {
+      link = `${link}?page=${request.page}`;
+    } else if (request.limit) {
+      link = `${link}?pageSize=${request.limit}`;
+    }
+  }
+  const key = branchQueryKey(repository, branch, "changesets", (request == null ? void 0 : request.page) || 0);
+  return useQuery8(key, () => apiClient.get(link).then((response) => response.json()), {
+    onSuccess: (changesetCollection) => {
+      var _a;
+      (_a = changesetCollection._embedded) == null ? void 0 : _a.changesets.forEach((changeset) => {
+        queryClient2.setQueryData(changesetQueryKey(repository, changeset.id), changeset);
+      });
+    }
+  });
+};
+var useChangeset = (repository, id) => {
+  const changesetsLink = requiredLink(repository, "changesets");
+  return useQuery8(changesetQueryKey(repository, id), () => apiClient.get(concat(changesetsLink, id)).then((response) => response.json()));
+};
+
+// src/tags.ts
+import { useMutation as useMutation6, useQuery as useQuery9, useQueryClient as useQueryClient8 } from "react-query";
+var tagQueryKey = (repository, tag) => {
+  return repoQueryKey(repository, "tag", tag);
+};
+var useTags = (repository) => {
+  const link = requiredLink(repository, "tags");
+  return useQuery9(repoQueryKey(repository, "tags"), () => apiClient.get(link).then((response) => response.json()));
+};
+var useTag = (repository, name) => {
+  const link = requiredLink(repository, "tags");
+  return useQuery9(tagQueryKey(repository, name), () => apiClient.get(concat(link, name)).then((response) => response.json()));
+};
+var invalidateCacheForTag = (queryClient2, repository, tag) => {
+  return Promise.all([
+    queryClient2.invalidateQueries(repoQueryKey(repository, "tags")),
+    queryClient2.invalidateQueries(repoQueryKey(repository, "changesets")),
+    queryClient2.invalidateQueries(repoQueryKey(repository, "changeset", tag.revision))
+  ]);
+};
+var createTag = (changeset, link) => {
+  return (name) => {
+    return apiClient.post(link, {
+      name,
+      revision: changeset.id
+    }).then((response) => {
+      const location = response.headers.get("Location");
+      if (!location) {
+        throw new Error("Server does not return required Location header");
+      }
+      return apiClient.get(location);
+    }).then((response) => response.json());
+  };
+};
+var useCreateTag = (repository, changeset) => {
+  const queryClient2 = useQueryClient8();
+  const link = requiredLink(changeset, "tag");
+  const { isLoading, error, mutate, data } = useMutation6(createTag(changeset, link), {
+    onSuccess: async (tag) => {
+      queryClient2.setQueryData(tagQueryKey(repository, tag.name), tag);
+      await queryClient2.invalidateQueries(tagQueryKey(repository, tag.name));
+      await invalidateCacheForTag(queryClient2, repository, tag);
+    }
+  });
+  return {
+    isLoading,
+    error,
+    create: (name) => mutate(name),
+    tag: data
+  };
+};
+var useDeleteTag = (repository) => {
+  const queryClient2 = useQueryClient8();
+  const { mutate, isLoading, error, data } = useMutation6((tag) => {
+    const deleteUrl = tag._links.delete.href;
+    return apiClient.delete(deleteUrl);
+  }, {
+    onSuccess: async (_, tag) => {
+      queryClient2.removeQueries(tagQueryKey(repository, tag.name));
+      await invalidateCacheForTag(queryClient2, repository, tag);
+    }
+  });
+  return {
+    remove: (tag) => mutate(tag),
+    isLoading,
+    error,
+    isDeleted: !!data
+  };
+};
+
+// src/config.ts
+import { useMutation as useMutation7, useQuery as useQuery10, useQueryClient as useQueryClient9 } from "react-query";
+var useConfig = () => {
+  const indexLink = useIndexLink("config");
+  return useQuery10("config", () => apiClient.get(indexLink).then((response) => response.json()), {
+    enabled: !!indexLink
+  });
+};
+var useUpdateConfig = () => {
+  const queryClient2 = useQueryClient9();
+  const { mutate, isLoading, error, data, reset: reset2 } = useMutation7((config) => {
+    const updateUrl = requiredLink(config, "update");
+    return apiClient.put(updateUrl, config, "application/vnd.scmm-config+json;v=2");
+  }, {
+    onSuccess: async () => {
+      await queryClient2.invalidateQueries("config");
+      await queryClient2.invalidateQueries("index");
+      await queryClient2.invalidateQueries("pluginCenterAuth");
+    }
+  });
+  return {
+    update: (config) => mutate(config),
+    isLoading,
+    error,
+    isUpdated: !!data,
+    reset: reset2
+  };
+};
+
+// src/admin.ts
+import { useQuery as useQuery11 } from "react-query";
+var useUpdateInfo = () => {
+  const indexLink = useIndexLink("updateInfo");
+  return useQuery11("updateInfo", () => {
+    if (!indexLink) {
+      throw new Error("could not find index data");
+    }
+    return apiClient.get(indexLink).then((response) => response.status === 204 ? null : response.json());
+  }, { enabled: !!indexLink });
+};
+
+// src/plugins.ts
+import { isPluginCollection } from "@scm-manager/ui-types";
+import { useMutation as useMutation8, useQuery as useQuery12, useQueryClient as useQueryClient10 } from "react-query";
+var waitForRestartAfter = (promise, { initialDelay = 1e3, timeout = 500 } = {}) => {
+  const endTime = Number(new Date()) + 4 * 60 * 1e3;
+  let started = false;
+  const executor = (data) => (resolve, reject) => {
+    if (!started) {
+      started = true;
+      setTimeout(executor(data), initialDelay, resolve, reject);
+    } else {
+      apiClient.get("").then(() => resolve(data)).catch(() => {
+        if (Number(new Date()) < endTime) {
+          setTimeout(executor(data), timeout, resolve, reject);
+        } else {
+          reject(new Error("timeout reached"));
+        }
+      });
+    }
+  };
+  return promise.catch((err) => {
+    if (err instanceof BadGatewayError) {
+      return "ok";
+    }
+    throw err;
+  }).then((data) => new Promise(executor(data)));
+};
+var useAvailablePlugins = ({ enabled } = {}) => {
+  const indexLink = useRequiredIndexLink("availablePlugins");
+  return useQuery12(["plugins", "available"], () => apiClient.get(indexLink).then((response) => response.json()), {
+    enabled,
+    retry: 3
+  });
+};
+var useInstalledPlugins = ({ enabled } = {}) => {
+  const indexLink = useRequiredIndexLink("installedPlugins");
+  return useQuery12(["plugins", "installed"], () => apiClient.get(indexLink).then((response) => response.json()), {
+    enabled,
+    retry: 3
+  });
+};
+var usePendingPlugins = () => {
+  const indexLink = useIndexLink("pendingPlugins");
+  return useQuery12(["plugins", "pending"], () => apiClient.get(indexLink).then((response) => response.json()), {
+    enabled: !!indexLink,
+    retry: 3
+  });
+};
+var linkWithRestart = (link, restart) => {
+  if (restart) {
+    return link + "WithRestart";
+  }
+  return link;
+};
+var useInstallPlugin = () => {
+  const queryClient2 = useQueryClient10();
+  const { mutate, isLoading, error, data } = useMutation8((_a) => {
+    var { plugin, restartOptions: _b } = _a, _c = _b, { restart } = _c, waitForRestartOptions = __objRest(_c, ["restart"]);
+    const promise = apiClient.post(requiredLink(plugin, linkWithRestart("install", restart)));
+    if (restart) {
+      return waitForRestartAfter(promise, waitForRestartOptions);
+    }
+    return promise;
+  }, {
+    onSuccess: () => queryClient2.invalidateQueries("plugins")
+  });
+  return {
+    install: (plugin, restartOptions = {}) => mutate({
+      plugin,
+      restartOptions
+    }),
+    isLoading,
+    error,
+    data,
+    isInstalled: !!data
+  };
+};
+var useUninstallPlugin = () => {
+  const queryClient2 = useQueryClient10();
+  const { mutate, isLoading, error, data } = useMutation8((_a) => {
+    var { plugin, restartOptions: _b } = _a, _c = _b, { restart } = _c, waitForRestartOptions = __objRest(_c, ["restart"]);
+    const promise = apiClient.post(requiredLink(plugin, linkWithRestart("uninstall", restart)));
+    if (restart) {
+      return waitForRestartAfter(promise, waitForRestartOptions);
+    }
+    return promise;
+  }, {
+    onSuccess: () => queryClient2.invalidateQueries("plugins")
+  });
+  return {
+    uninstall: (plugin, restartOptions = {}) => mutate({
+      plugin,
+      restartOptions
+    }),
+    isLoading,
+    error,
+    isUninstalled: !!data
+  };
+};
+var useUpdatePlugins = () => {
+  const queryClient2 = useQueryClient10();
+  const { mutate, isLoading, error, data } = useMutation8((_a) => {
+    var { plugins, restartOptions: _b } = _a, _c = _b, { restart } = _c, waitForRestartOptions = __objRest(_c, ["restart"]);
+    const isCollection = isPluginCollection(plugins);
+    const promise = apiClient.post(requiredLink(plugins, isCollection ? "update" : linkWithRestart("update", restart)));
+    if (restart && !isCollection) {
+      return waitForRestartAfter(promise, waitForRestartOptions);
+    }
+    return promise;
+  }, {
+    onSuccess: () => queryClient2.invalidateQueries("plugins")
+  });
+  return {
+    update: (plugin, restartOptions = {}) => mutate({
+      plugins: plugin,
+      restartOptions
+    }),
+    isLoading,
+    error,
+    isUpdated: !!data
+  };
+};
+var useExecutePendingPlugins = () => {
+  const queryClient2 = useQueryClient10();
+  const { mutate, isLoading, error, data } = useMutation8(({ pending, restartOptions }) => waitForRestartAfter(apiClient.post(requiredLink(pending, "execute")), restartOptions), {
+    onSuccess: () => queryClient2.invalidateQueries("plugins")
+  });
+  return {
+    update: (pending, restartOptions = {}) => mutate({ pending, restartOptions }),
+    isLoading,
+    error,
+    isExecuted: !!data
+  };
+};
+var useCancelPendingPlugins = () => {
+  const queryClient2 = useQueryClient10();
+  const { mutate, isLoading, error, data } = useMutation8((pending) => apiClient.post(requiredLink(pending, "cancel")), {
+    onSuccess: () => queryClient2.invalidateQueries("plugins")
+  });
+  return {
+    update: (pending) => mutate(pending),
+    isLoading,
+    error,
+    isCancelled: !!data
+  };
+};
+
+// src/repository-roles.ts
+import { useMutation as useMutation9, useQuery as useQuery13, useQueryClient as useQueryClient11 } from "react-query";
+var useRepositoryRoles = (request) => {
+  const queryClient2 = useQueryClient11();
+  const indexLink = useRequiredIndexLink("repositoryRoles");
+  const queryParams = {};
+  if (request == null ? void 0 : request.page) {
+    queryParams.page = request.page.toString();
+  }
+  return useQuery13(["repositoryRoles", (request == null ? void 0 : request.page) || 0], () => apiClient.get(`${indexLink}?${createQueryString(queryParams)}`).then((response) => response.json()), {
+    onSuccess: (repositoryRoles) => {
+      var _a;
+      (_a = repositoryRoles._embedded) == null ? void 0 : _a.repositoryRoles.forEach((repositoryRole) => queryClient2.setQueryData(["repositoryRole", repositoryRole.name], repositoryRole));
+    }
+  });
+};
+var useRepositoryRole = (name) => {
+  const indexLink = useRequiredIndexLink("repositoryRoles");
+  return useQuery13(["repositoryRole", name], () => apiClient.get(concat(indexLink, name)).then((response) => response.json()));
+};
+var createRepositoryRole = (link) => {
+  return (repositoryRole) => {
+    return apiClient.post(link, repositoryRole, "application/vnd.scmm-repositoryRole+json;v=2").then((response) => {
+      const location = response.headers.get("Location");
+      if (!location) {
+        throw new Error("Server does not return required Location header");
+      }
+      return apiClient.get(location);
+    }).then((response) => response.json());
+  };
+};
+var useCreateRepositoryRole = () => {
+  const queryClient2 = useQueryClient11();
+  const link = useRequiredIndexLink("repositoryRoles");
+  const { mutate, data, isLoading, error } = useMutation9(createRepositoryRole(link), {
+    onSuccess: (repositoryRole) => {
+      queryClient2.setQueryData(["repositoryRole", repositoryRole.name], repositoryRole);
+      return queryClient2.invalidateQueries(["repositoryRoles"]);
+    }
+  });
+  return {
+    create: (repositoryRole) => mutate(repositoryRole),
+    isLoading,
+    error,
+    repositoryRole: data
+  };
+};
+var useUpdateRepositoryRole = () => {
+  const queryClient2 = useQueryClient11();
+  const { mutate, isLoading, error, data } = useMutation9((repositoryRole) => {
+    const updateUrl = requiredLink(repositoryRole, "update");
+    return apiClient.put(updateUrl, repositoryRole, "application/vnd.scmm-repositoryRole+json;v=2");
+  }, {
+    onSuccess: async (_, repositoryRole) => {
+      await queryClient2.invalidateQueries(["repositoryRole", repositoryRole.name]);
+      await queryClient2.invalidateQueries(["repositoryRoles"]);
+    }
+  });
+  return {
+    update: (repositoryRole) => mutate(repositoryRole),
+    isLoading,
+    error,
+    isUpdated: !!data
+  };
+};
+var useDeleteRepositoryRole = () => {
+  const queryClient2 = useQueryClient11();
+  const { mutate, isLoading, error, data } = useMutation9((repositoryRole) => {
+    const deleteUrl = requiredLink(repositoryRole, "delete");
+    return apiClient.delete(deleteUrl);
+  }, {
+    onSuccess: async (_, name) => {
+      await queryClient2.removeQueries(["repositoryRole", name]);
+      await queryClient2.invalidateQueries(["repositoryRoles"]);
+    }
+  });
+  return {
+    remove: (repositoryRole) => mutate(repositoryRole),
+    isLoading,
+    error,
+    isDeleted: !!data
+  };
+};
+
+// src/permissions.ts
+import { useMutation as useMutation10, useQuery as useQuery14, useQueryClient as useQueryClient12 } from "react-query";
+var useRepositoryVerbs = () => {
+  return useIndexJsonResource("repositoryVerbs");
+};
+var useAvailablePermissions = () => {
+  var _a;
+  const roles = useRepositoryRoles();
+  const verbs = useRepositoryVerbs();
+  let data;
+  if (roles.data && verbs.data) {
+    data = {
+      repositoryVerbs: verbs.data.verbs,
+      repositoryRoles: ((_a = roles.data._embedded) == null ? void 0 : _a.repositoryRoles) || []
+    };
+  }
+  return {
+    isLoading: roles.isLoading || verbs.isLoading,
+    error: roles.error || verbs.error,
+    data
+  };
+};
+var isRepository = (namespaceOrRepository) => {
+  return namespaceOrRepository.name !== void 0;
+};
+var createQueryKey = (namespaceOrRepository) => {
+  if (isRepository(namespaceOrRepository)) {
+    return repoQueryKey(namespaceOrRepository, "permissions");
+  } else {
+    return ["namespace", namespaceOrRepository.namespace, "permissions"];
+  }
+};
+var usePermissions = (namespaceOrRepository) => {
+  const link = requiredLink(namespaceOrRepository, "permissions");
+  const queryKey = createQueryKey(namespaceOrRepository);
+  return useQuery14(queryKey, () => apiClient.get(link).then((response) => response.json()));
+};
+var createPermission = (link) => {
+  return (permission) => {
+    return apiClient.post(link, permission, "application/vnd.scmm-repositoryPermission+json").then((response) => {
+      const location = response.headers.get("Location");
+      if (!location) {
+        throw new Error("Server does not return required Location header");
+      }
+      return apiClient.get(location);
+    }).then((response) => response.json());
+  };
+};
+var useCreatePermission = (namespaceOrRepository) => {
+  const queryClient2 = useQueryClient12();
+  const link = requiredLink(namespaceOrRepository, "permissions");
+  const { isLoading, error, mutate, data } = useMutation10(createPermission(link), {
+    onSuccess: () => {
+      const queryKey = createQueryKey(namespaceOrRepository);
+      return queryClient2.invalidateQueries(queryKey);
+    }
+  });
+  return {
+    isLoading,
+    error,
+    create: (permission) => mutate(permission),
+    permission: data
+  };
+};
+var useUpdatePermission = (namespaceOrRepository) => {
+  const queryClient2 = useQueryClient12();
+  const { isLoading, error, mutate, data } = useMutation10((permission) => {
+    const link = requiredLink(permission, "update");
+    return apiClient.put(link, permission, "application/vnd.scmm-repositoryPermission+json");
+  }, {
+    onSuccess: () => {
+      const queryKey = createQueryKey(namespaceOrRepository);
+      return queryClient2.invalidateQueries(queryKey);
+    }
+  });
+  return {
+    isLoading,
+    error,
+    update: (permission) => mutate(permission),
+    isUpdated: !!data
+  };
+};
+var useDeletePermission = (namespaceOrRepository) => {
+  const queryClient2 = useQueryClient12();
+  const { isLoading, error, mutate, data } = useMutation10((permission) => {
+    const link = requiredLink(permission, "delete");
+    return apiClient.delete(link);
+  }, {
+    onSuccess: () => {
+      const queryKey = createQueryKey(namespaceOrRepository);
+      return queryClient2.invalidateQueries(queryKey);
+    }
+  });
+  return {
+    isLoading,
+    error,
+    remove: (permission) => mutate(permission),
+    isDeleted: !!data
+  };
+};
+var userPermissionsKey = (user) => ["user", user.name, "permissions"];
+var groupPermissionsKey = (group) => ["group", group.name, "permissions"];
+var useGroupPermissions = (group) => useJsonResource(group, "permissions", groupPermissionsKey(group));
+var useUserPermissions = (user) => useJsonResource(user, "permissions", userPermissionsKey(user));
+var useAvailableGlobalPermissions = () => useIndexJsonResource("permissions");
+var useSetEntityPermissions = (permissionCollection, key) => {
+  const queryClient2 = useQueryClient12();
+  const url = permissionCollection ? objectLink(permissionCollection, "overwrite") : null;
+  const { isLoading, error, mutate, data } = useMutation10((permissions) => apiClient.put(url, {
+    permissions
+  }, "application/vnd.scmm-permissionCollection+json;v=2"), {
+    onSuccess: () => queryClient2.invalidateQueries(key)
+  });
+  const setPermissions = (permissions) => mutate(permissions);
+  return {
+    isLoading,
+    error,
+    setPermissions: url ? setPermissions : void 0,
+    isUpdated: !!data
+  };
+};
+var useSetUserPermissions = (user, permissions) => useSetEntityPermissions(permissions, userPermissionsKey(user));
+var useSetGroupPermissions = (group, permissions) => useSetEntityPermissions(permissions, groupPermissionsKey(group));
+
+// src/sources.ts
+import { useInfiniteQuery as useInfiniteQuery2 } from "react-query";
+import { useEffect as useEffect3 } from "react";
+var UseSourcesDefaultOptions = {
+  enabled: true,
+  refetchPartialInterval: 3e3,
+  collapse: true
+};
+var useSources = (repository, opts = UseSourcesDefaultOptions) => {
+  const options = __spreadValues(__spreadValues({}, UseSourcesDefaultOptions), opts);
+  const link = createSourcesLink(repository, options);
+  const { isLoading, error, data, isFetchingNextPage, fetchNextPage, refetch } = useInfiniteQuery2(repoQueryKey(repository, "sources", options.revision || "", options.path || "", options.collapse ? "collapse" : ""), ({ pageParam }) => {
+    return apiClient.get(pageParam || link).then((response) => response.json());
+  }, {
+    enabled: options.enabled,
+    getNextPageParam: (lastPage) => {
+      var _a;
+      return (_a = lastPage._links.proceed) == null ? void 0 : _a.href;
+    }
+  });
+  const file = merge(data == null ? void 0 : data.pages);
+  useEffect3(() => {
+    const intervalId = setInterval(() => {
+      if (isPartial(file)) {
+        refetch({
+          throwOnError: true
+        });
+      }
+    }, options.refetchPartialInterval);
+    return () => clearInterval(intervalId);
+  }, [options.refetchPartialInterval, file, refetch]);
+  return {
+    isLoading,
+    error,
+    data: file,
+    isFetchingNextPage,
+    fetchNextPage: () => {
+      fetchNextPage();
+    }
+  };
+};
+var createSourcesLink = (repository, options) => {
+  let link = requiredLink(repository, "sources");
+  if (options.revision) {
+    link = concat(link, encodeURIComponent(options.revision));
+    if (options.path) {
+      link = concat(link, options.path);
+    }
+  }
+  if (options.collapse) {
+    return `${link}?${createQueryString({ collapse: "true" })}`;
+  }
+  return link;
+};
+var merge = (files) => {
+  var _a;
+  if (!files || files.length === 0) {
+    return;
+  }
+  const children = [];
+  for (const page of files) {
+    children.push(...((_a = page._embedded) == null ? void 0 : _a.children) || []);
+  }
+  const lastPage = files[files.length - 1];
+  return __spreadProps(__spreadValues({}, lastPage), {
+    _embedded: __spreadProps(__spreadValues({}, lastPage._embedded), {
+      children
+    })
+  });
+};
+var isFilePartial = (f) => {
+  return f.partialResult && !f.computationAborted;
+};
+var isPartial = (file) => {
+  var _a, _b;
+  if (!file) {
+    return false;
+  }
+  if (isFilePartial(file)) {
+    return true;
+  }
+  return (_b = (_a = file._embedded) == null ? void 0 : _a.children) == null ? void 0 : _b.some(isFilePartial);
+};
+
+// src/import.ts
+import { useMutation as useMutation11, useQuery as useQuery15 } from "react-query";
+var useImportLog = (logId) => {
+  const link = useRequiredIndexLink("importLog").replace("{logId}", logId);
+  return useQuery15(["importLog", logId], () => apiClient.get(link).then((response) => response.text()));
+};
+var useImportRepositoryFromUrl = (repositoryType) => {
+  const url = requiredLink(repositoryType, "import", "url");
+  const { isLoading, error, data, mutate } = useMutation11((repo) => apiClient.post(url, repo, "application/vnd.scmm-repository+json;v=2").then(fetchResourceFromLocationHeader).then(getResponseJson));
+  return {
+    isLoading,
+    error,
+    importRepositoryFromUrl: (repository) => mutate(repository),
+    importedRepository: data
+  };
+};
+var importRepository = (url, repository, file, password) => {
+  return apiClient.postBinary(url, (formData) => {
+    formData.append("bundle", file, file.name);
+    formData.append("repository", JSON.stringify(__spreadProps(__spreadValues({}, repository), { password })));
+  }).then(fetchResourceFromLocationHeader).then(getResponseJson);
+};
+var useImportRepositoryFromBundle = (repositoryType) => {
+  const url = requiredLink(repositoryType, "import", "bundle");
+  const { isLoading, error, data, mutate } = useMutation11(({ repository, file, compressed, password }) => importRepository(compressed ? url + "?compressed=true" : url, repository, file, password));
+  return {
+    isLoading,
+    error,
+    importRepositoryFromBundle: (repository, file, compressed, password) => mutate({
+      repository,
+      file,
+      compressed,
+      password
+    }),
+    importedRepository: data
+  };
+};
+var useImportFullRepository = (repositoryType) => {
+  const { isLoading, error, data, mutate } = useMutation11(({ repository, file, password }) => importRepository(requiredLink(repositoryType, "import", "fullImport"), repository, file, password));
+  return {
+    isLoading,
+    error,
+    importFullRepository: (repository, file, password) => mutate({
+      repository,
+      file,
+      password
+    }),
+    importedRepository: data
+  };
+};
+
+// src/diff.ts
+import parser from "gitdiff-parser";
+import { useInfiniteQuery as useInfiniteQuery3 } from "react-query";
+var defaultOptions = {
+  refetchOnWindowFocus: true
+};
+var useDiff = (link, options = defaultOptions) => {
+  let initialLink = link;
+  if (options.limit) {
+    const separator = initialLink.includes("?") ? "&" : "?";
+    initialLink = `${initialLink}${separator}limit=${options.limit}`;
+  }
+  const { isLoading, error, data, isFetchingNextPage, fetchNextPage } = useInfiniteQuery3(["link", link], ({ pageParam }) => {
+    return apiClient.get(pageParam || initialLink).then((response) => {
+      const contentType = response.headers.get("Content-Type");
+      if (contentType && contentType.toLowerCase() === "application/vnd.scmm-diffparsed+json;v=2") {
+        return response.json();
+      } else {
+        return response.text().then(parser.parse).then((parsedGit) => {
+          return {
+            files: parsedGit,
+            partial: false,
+            _links: {}
+          };
+        });
+      }
+    });
+  }, {
+    getNextPageParam: (lastPage) => {
+      var _a;
+      return (_a = lastPage._links.next) == null ? void 0 : _a.href;
+    },
+    refetchOnWindowFocus: options.refetchOnWindowFocus
+  });
+  return {
+    isLoading,
+    error,
+    isFetchingNextPage,
+    fetchNextPage: () => {
+      fetchNextPage();
+    },
+    data: merge2(data == null ? void 0 : data.pages)
+  };
+};
+var merge2 = (diffs) => {
+  if (!diffs || diffs.length === 0) {
+    return;
+  }
+  const joinedFiles = diffs.flatMap((diff) => diff.files);
+  return __spreadProps(__spreadValues({}, diffs[diffs.length - 1]), {
+    files: joinedFiles
+  });
+};
+
+// src/notifications.ts
+import { useMutation as useMutation12, useQuery as useQuery16, useQueryClient as useQueryClient13 } from "react-query";
+import { useCallback as useCallback2, useEffect as useEffect4, useState as useState2 } from "react";
+var useNotifications = () => {
+  var _a;
+  const { data: me } = useMe();
+  const link = (_a = me == null ? void 0 : me._links["notifications"]) == null ? void 0 : _a.href;
+  const { data, error, isLoading, refetch } = useQuery16("notifications", () => apiClient.get(link).then((response) => response.json()), {
+    enabled: !!link
+  });
+  const memoizedRefetch = useCallback2(() => {
+    return refetch().then((r) => r.data);
+  }, [refetch]);
+  return {
+    data,
+    error,
+    isLoading,
+    refetch: memoizedRefetch
+  };
+};
+var useDismissNotification = (notification) => {
+  const queryClient2 = useQueryClient13();
+  const link = requiredLink(notification, "dismiss");
+  const { data, isLoading, error, mutate } = useMutation12(() => apiClient.delete(link), {
+    onSuccess: () => {
+      queryClient2.invalidateQueries("notifications");
+    }
+  });
+  return {
+    isLoading,
+    error,
+    dismiss: () => mutate(),
+    isCleared: !!data
+  };
+};
+var useClearNotifications = (notificationCollection) => {
+  const queryClient2 = useQueryClient13();
+  const link = requiredLink(notificationCollection, "clear");
+  const { data, isLoading, error, mutate } = useMutation12(() => apiClient.delete(link), {
+    onSuccess: () => {
+      queryClient2.invalidateQueries("notifications");
+    }
+  });
+  return {
+    isLoading,
+    error,
+    clear: () => mutate(),
+    isCleared: !!data
+  };
+};
+var isEqual = (left, right) => {
+  return left === right || left.message === right.message && left.createdAt === right.createdAt;
+};
+var useNotificationSubscription = (refetch, notificationCollection) => {
+  var _a;
+  const [notifications, setNotifications] = useState2([]);
+  const [disconnectedAt, setDisconnectedAt] = useState2();
+  const link = (_a = notificationCollection == null ? void 0 : notificationCollection._links.subscribe) == null ? void 0 : _a.href;
+  const onVisible = useCallback2(() => {
+    refetch().then((collection) => {
+      var _a2;
+      if (collection) {
+        const newNotifications = (_a2 = collection._embedded) == null ? void 0 : _a2.notifications.filter((n) => {
+          return disconnectedAt && disconnectedAt < new Date(n.createdAt);
+        });
+        if (newNotifications && newNotifications.length > 0) {
+          setNotifications((previous) => [...previous, ...newNotifications]);
+        }
+        setDisconnectedAt(void 0);
+      }
+    });
+  }, [disconnectedAt, refetch]);
+  const onHide = useCallback2(() => {
+    setDisconnectedAt(new Date());
+  }, []);
+  const received = useCallback2((notification) => {
+    setNotifications((previous) => [...previous, notification]);
+    refetch();
+  }, [refetch]);
+  useEffect4(() => {
+    if (link) {
+      let cancel;
+      const disconnect = () => {
+        if (cancel) {
+          cancel();
+        }
+      };
+      const connect = () => {
+        disconnect();
+        cancel = apiClient.subscribe(link, {
+          notification: (event) => {
+            received(JSON.parse(event.data));
+          }
+        });
+      };
+      const handleVisibilityChange = () => {
+        if (document.visibilityState === "visible") {
+          onVisible();
+        } else {
+          onHide();
+        }
+      };
+      if (document.visibilityState === "visible") {
+        connect();
+      }
+      document.addEventListener("visibilitychange", handleVisibilityChange);
+      return () => {
+        disconnect();
+        document.removeEventListener("visibilitychange", handleVisibilityChange);
+      };
+    }
+  }, [link, onVisible, onHide, received]);
+  const remove = useCallback2((notification) => {
+    setNotifications((oldNotifications) => [...oldNotifications.filter((n) => !isEqual(n, notification))]);
+  }, [setNotifications]);
+  const clear = useCallback2(() => {
+    setNotifications([]);
+  }, [setNotifications]);
+  return {
+    notifications,
+    remove,
+    clear
+  };
+};
+
+// src/alerts.ts
+import { useQuery as useQuery17 } from "react-query";
+var alertsFromStorage = () => {
+  const item = localStorage.getItem("alerts");
+  if (item) {
+    return JSON.parse(item);
+  }
+};
+var fetchAlerts = (request) => {
+  var _a;
+  const url = (_a = request._links["alerts"]) == null ? void 0 : _a.href;
+  if (!url) {
+    throw new Error("no alerts link defined");
+  }
+  return fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(request.body)
+  }).then((response) => {
+    if (!response.ok) {
+      throw new Error("Failed to fetch alerts");
+    }
+    return response;
+  }).then((response) => response.json()).then((data) => {
+    const storageItem = __spreadProps(__spreadValues({}, data), {
+      checksum: request.checksum
+    });
+    localStorage.setItem("alerts", JSON.stringify(storageItem));
+    return data;
+  });
+};
+var restoreOrFetch = (request) => {
+  const storedAlerts = alertsFromStorage();
+  if (!storedAlerts || storedAlerts.checksum !== request.checksum) {
+    return fetchAlerts(request);
+  }
+  return Promise.resolve(storedAlerts);
+};
+var useAlerts = () => {
+  const link = useIndexLink("alerts");
+  const { data, error, isLoading } = useQuery17("alerts", () => {
+    if (!link) {
+      throw new Error("Could not find alert link");
+    }
+    return apiClient.get(link).then((response) => response.json()).then(restoreOrFetch);
+  }, {
+    enabled: !!link,
+    staleTime: Infinity
+  });
+  return {
+    data,
+    error,
+    isLoading
+  };
+};
+
+// src/configLink.ts
+import { useMutation as useMutation13, useQuery as useQuery18, useQueryClient as useQueryClient14 } from "react-query";
+import { useCallback as useCallback3 } from "react";
+var useConfigLink = (link) => {
+  const queryClient2 = useQueryClient14();
+  const queryKey = ["configLink", link];
+  const { isLoading, error, data } = useQuery18(queryKey, () => apiClient.get(link).then((response) => {
+    const contentType = response.headers.get("Content-Type") || "application/json";
+    return response.json().then((configuration) => ({ configuration, contentType }));
+  }));
+  const {
+    isLoading: isUpdating,
+    error: mutationError,
+    mutate,
+    data: updateResponse
+  } = useMutation13((vars) => apiClient.put(vars.link, vars.configuration, vars.contentType), {
+    onSuccess: async () => {
+      await queryClient2.invalidateQueries(queryKey);
+    }
+  });
+  const isReadOnly = !(data == null ? void 0 : data.configuration._links.update);
+  const update = useCallback3((configuration) => {
+    if (data && !isReadOnly) {
+      mutate({
+        configuration,
+        contentType: data.contentType,
+        link: data.configuration._links.update.href
+      });
+    }
+  }, [mutate, data, isReadOnly]);
+  return {
+    isLoading,
+    isUpdating,
+    isReadOnly,
+    error: error || mutationError,
+    initialConfiguration: data == null ? void 0 : data.configuration,
+    update,
+    isUpdated: !!updateResponse
+  };
+};
+
+// src/apiKeys.ts
+import { useMutation as useMutation14, useQuery as useQuery19, useQueryClient as useQueryClient15 } from "react-query";
+var CONTENT_TYPE_API_KEY = "application/vnd.scmm-apiKey+json;v=2";
+var useApiKeys = (user) => useQuery19(["user", user.name, "apiKeys"], () => apiClient.get(requiredLink(user, "apiKeys")).then((r) => r.json()));
+var createApiKey = (link) => async (key) => {
+  const creationResponse = await apiClient.post(link, key, CONTENT_TYPE_API_KEY);
+  const location = creationResponse.headers.get("Location");
+  if (!location) {
+    throw new Error("Server does not return required Location header");
+  }
+  const locationResponse = await apiClient.get(location);
+  const [apiKey, token] = await Promise.all([locationResponse.json(), creationResponse.text()]);
+  return __spreadProps(__spreadValues({}, apiKey), { token });
+};
+var useCreateApiKey = (user, apiKeys) => {
+  const queryClient2 = useQueryClient15();
+  const { mutate, data, isLoading, error, reset: reset2 } = useMutation14(createApiKey(requiredLink(apiKeys, "create")), {
+    onSuccess: () => queryClient2.invalidateQueries(["user", user.name, "apiKeys"])
+  });
+  return {
+    create: (key) => mutate(key),
+    isLoading,
+    error,
+    apiKey: data,
+    reset: reset2
+  };
+};
+var useDeleteApiKey = (user) => {
+  const queryClient2 = useQueryClient15();
+  const { mutate, isLoading, error, data } = useMutation14((apiKey) => {
+    const deleteUrl = requiredLink(apiKey, "delete");
+    return apiClient.delete(deleteUrl);
+  }, {
+    onSuccess: () => queryClient2.invalidateQueries(["user", user.name, "apiKeys"])
+  });
+  return {
+    remove: (apiKey) => mutate(apiKey),
+    isLoading,
+    error,
+    isDeleted: !!data
+  };
+};
+
+// src/publicKeys.ts
+import { useMutation as useMutation15, useQuery as useQuery20, useQueryClient as useQueryClient16 } from "react-query";
+var CONTENT_TYPE_PUBLIC_KEY = "application/vnd.scmm-publicKey+json;v=2";
+var usePublicKeys = (user) => useQuery20(["user", user.name, "publicKeys"], () => apiClient.get(requiredLink(user, "publicKeys")).then((r) => r.json()));
+var createPublicKey = (link) => async (key) => {
+  const creationResponse = await apiClient.post(link, key, CONTENT_TYPE_PUBLIC_KEY);
+  const location = creationResponse.headers.get("Location");
+  if (!location) {
+    throw new Error("Server does not return required Location header");
+  }
+  const apiKeyResponse = await apiClient.get(location);
+  return apiKeyResponse.json();
+};
+var useCreatePublicKey = (user, publicKeys) => {
+  const queryClient2 = useQueryClient16();
+  const { mutate, data, isLoading, error, reset: reset2 } = useMutation15(createPublicKey(requiredLink(publicKeys, "create")), {
+    onSuccess: () => queryClient2.invalidateQueries(["user", user.name, "publicKeys"])
+  });
+  return {
+    create: (key) => mutate(key),
+    isLoading,
+    error,
+    apiKey: data,
+    reset: reset2
+  };
+};
+var useDeletePublicKey = (user) => {
+  const queryClient2 = useQueryClient16();
+  const { mutate, isLoading, error, data } = useMutation15((publicKey) => {
+    const deleteUrl = requiredLink(publicKey, "delete");
+    return apiClient.delete(deleteUrl);
+  }, {
+    onSuccess: () => queryClient2.invalidateQueries(["user", user.name, "publicKeys"])
+  });
+  return {
+    remove: (publicKey) => mutate(publicKey),
+    isLoading,
+    error,
+    isDeleted: !!data
+  };
+};
+
+// src/fileContent.ts
+import { useQuery as useQuery21 } from "react-query";
+var useFileContent = (file) => {
+  const selfLink = requiredLink(file, "self");
+  return useQuery21(["fileContent", selfLink], () => apiClient.get(selfLink).then((response) => response.text()));
+};
+
+// src/history.ts
+import { useQuery as useQuery22, useQueryClient as useQueryClient17 } from "react-query";
+var useHistory = (repository, revision, file, request) => {
+  const queryClient2 = useQueryClient17();
+  const link = file._links.history.href;
+  const queryParams = {};
+  if (request == null ? void 0 : request.page) {
+    queryParams.page = request.page.toString();
+  }
+  return useQuery22(repoQueryKey(repository, "history", revision, file.path, (request == null ? void 0 : request.page) || 0), () => apiClient.get(`${link}?${createQueryString(queryParams)}`).then((response) => response.json()), {
+    keepPreviousData: true,
+    onSuccess: (changesets) => {
+      var _a;
+      (_a = changesets._embedded) == null ? void 0 : _a.changesets.forEach((changeset) => queryClient2.setQueryData(changesetQueryKey(repository, changeset.id), changeset));
+    }
+  });
+};
+
+// src/contentType.ts
+import { useQuery as useQuery23 } from "react-query";
+function getContentType(url) {
+  return apiClient.head(url).then((response) => {
+    return {
+      type: response.headers.get("Content-Type") || "application/octet-stream",
+      language: response.headers.get("X-Programming-Language") || void 0,
+      aceMode: response.headers.get("X-Syntax-Mode-Ace") || void 0,
+      codemirrorMode: response.headers.get("X-Syntax-Mode-Codemirror") || void 0,
+      prismMode: response.headers.get("X-Syntax-Mode-Prism") || void 0
+    };
+  });
+}
+var useContentType = (url) => {
+  const { isLoading, isFetching, error, data } = useQuery23(["contentType", url], () => getContentType(url));
+  return {
+    isLoading,
+    isFetching,
+    error,
+    data
+  };
+};
+
+// src/annotations.ts
+import { useQuery as useQuery24 } from "react-query";
+var useAnnotations = (repository, revision, file) => {
+  const { isLoading, isFetching, error, data } = useQuery24(repoQueryKey(repository, "annotations", revision, file.path), () => apiClient.get(file._links.annotate.href).then((response) => response.json()));
+  return {
+    isLoading,
+    isFetching,
+    error,
+    data
+  };
+};
+
+// src/search.ts
+import { useQueries, useQuery as useQuery25 } from "react-query";
+import { useEffect as useEffect5, useState as useState3 } from "react";
+
+// src/help/search/syntax.en.ts
+var syntax_en_default = `### Modifiers
+
+Note: You can not use wildcards as the first character of a search.
+
+<table>
+  <tr>
+    <th>Definition</th>
+    <th>Example</th>
+  </tr>
+  <tr>
+    <td>? - single character Wildcard</td>
+    <td>Ultimate?Repo \u2013 finds e.g. Ultimate-Repo, Ultimate Repo, Ultimate+Repo</td>
+  </tr>
+  <tr>
+    <td>* - multiple character Wildcard</td>
+    <td>Ultimat*y - finds e.g. Ultimate Repository, Ultimate-Special-Repository, Ultimately</td>
+  </tr>
+</table>
+
+
+### Ranges
+
+Range Queries allow one to match documents whose field(s) values are between the lower and upper bound specified by the Range Query. Range Queries can be inclusive or exclusive of the upper and lower bounds. Sorting is done lexicographically.
+
+Ranges are not reserved to numerical fields. 
+
+<table>
+  <tr>
+    <th>Definition</th>
+    <th>Example</th>
+  </tr>
+  <tr>
+    <td>[ \u2026 TO \u2026 ] - inclusive range</td>
+    <td>creationDate:[1609459200000 TO 1612137600000] \u2013 finds e.G. repositories created between 2021-01-01 and 2021-02-01 </td>
+  </tr>
+  <tr>
+    <td>{\u2026 TO \u2026} - exclusive range</td>
+    <td>name:{Aida TO Carmen} \u2013 finds e.G. repositories with names between Aida and Carmen, excluding these to values.</td>
+  </tr>
+</table>
+
+
+### Boosting
+
+Boosting allows you to control the relevance of a document by boosting its term. 
+
+<table>
+  <tr>
+    <th>Definition</th>
+    <th>Example</th>
+  </tr>
+  <tr>
+    <td>term^number</td>
+    <td>ultimate^2 repository \u2013 makes the term "ultimate" more relevant. </td>
+  </tr>
+</table>
+
+
+By default, the boost factor is 1. Although the boost factor must be positive, it can be less than 1 (e.g. 0.2)
+
+By default Repository names are boosted by 1.5, namespace by 1.25.
+
+## Boolean Operators
+
+Note: Logical Operators must be entered in upper case (e.g. "AND").
+
+<table>
+  <tr>
+    <th>Definition</th>
+    <th>Example</th>
+  </tr>
+  <tr>
+    <td>AND \u2013 both terms must be included</td>
+    <td>Ultimate AND Repository \u2013 finds e.g. Ultimate Repository, Ultimate Special Repository</td>
+  </tr>
+  <tr>
+    <td>OR \u2013 at least one of the terms must be included</td>
+    <td>Ultimate OR Repository \u2013 finds e.g. Ultimate Repository, Ultimate User, Special Repository</td>
+  </tr>
+  <tr>
+    <td>NOT \u2013 following term may not be included, "!" may be used alternatively</td>
+    <td>Ultimate NOT Repository \u2013 finds e.g. Ultimate user, excludes e.g. Ultimate Repository</td>
+  </tr>
+  <tr>
+    <td>\u2013 excludes following term from search</td>
+    <td>Ultimate Repository -Special \u2013 finds e.g. Ultimate Repository, excludes e.g. Ultimate Special Repository</td>
+  </tr>
+  <tr>
+    <td>\u2013 following term must be included</td>
+    <td>Ultimate +Repository \u2013 finds e.g. my Repository, Ultimate Repository</td>
+  </tr>
+</table>
+
+
+## Grouping
+
+Search supports using parentheses to group clauses to form sub queries. This can be very useful if you want to control the boolean logic for a query.
+
+<table>
+  <tr>
+    <th>Definition</th>
+    <th>Example</th>
+  </tr>
+  <tr>
+    <td>() \u2013 terms inside parentheses are grouped together</td>
+    <td>(Ultimate OR my) AND Repository \u2013 finds e.g. Ultimate Repository, my Repository, excludes e.g. Super Repository. Either "Ultimate" or \u201CMy\u201D must exist, \u201CRepository\u201D must always exist.
+ </td>
+  </tr>
+</table>
+
+
+## Escaping Special Characters
+
+The search supports escaping special characters that are part of the query syntax. The current list special characters are
+
+&plus; &minus; && || ! ( ) { } [ ] ^ " ~ * ? : &bsol; /
+
+To escape these characters use the "&bsol;" before the character. For example to search for (1+1):2 use the query:
+
+&bsol;(1&bsol;+1&bsol;)&bsol;:2
+
+Source: [https://javadoc.io/static/org.apache.lucene/lucene-queryparser/8.9.0/org/apache/lucene/queryparser/classic/package-summary.html#package.description](https://javadoc.io/static/org.apache.lucene/lucene-queryparser/8.9.0/org/apache/lucene/queryparser/classic/package-summary.html#package.description)`;
+
+// src/help/search/syntax.de.ts
+var syntax_de_default = `## Modifikatoren
+
+Hinweis: Sie k\xF6nnen keine Wildcards als erstes Zeichen einer Suche verwenden.
+
+<table>
+  <tr>
+    <th>Definition</th>
+    <th>Beispiel</th>
+  </tr>
+  <tr>
+    <td>? - Einzelzeichen-Wildcard</td>
+    <td>Ultimate?Repo - findet z.B. Ultimate-Repo, Ultimate Repo, Ultimate+Repo</td>
+  </tr>
+  <tr>
+    <td>* - mehrstelliger Platzhalter</td>
+    <td>Ultimat*y - findet z.B. Ultimate Repository, Ultimates-Spezial-Repository, Ultimate</td>
+  </tr>
+</table>
+
+
+### Bereiche
+
+Bereichsabfragen erm\xF6glichen den Abgleich von Dokumenten, deren Feldwerte zwischen der unteren und der oberen Grenze liegen, die in der Bereichsabfrage angegeben sind. Bereichsabfragen k\xF6nnen die obere und untere Grenze einschlie\xDFen oder ausschlie\xDFen. Die Sortierung erfolgt lexikografisch.
+
+Bereiche sind nicht auf numerische Felder beschr\xE4nkt. 
+
+<table>
+  <tr>
+    <th>Definition</th>
+    <th>Beispiel</th>
+  </tr>
+  <tr>
+    <td>[ \u2026 TO \u2026 ] - inklusiver Bereich</td>
+    <td>creationDate:[1609459200000 TO 1612137600000] \u2013 findet z.B. Repositories, die zwischen dem 01.01.2021 und dem 01.02.2021 angelegt wurden.</td>
+  </tr>
+  <tr>
+    <td>{\u2026 TO \u2026} - ausschlie\xDFender Bereich</td>
+    <td>name:{Aida TO Carmen} \u2013 findet Namen zwischen Aida und Carmen, jedoch ohne die beiden Namen einzuschlie\xDFen.</td>
+  </tr>
+</table>
+
+
+## Boosten
+
+Mit dem Boosting k\xF6nnen Sie die Relevanz eines Dokuments steuern, indem Sie seinen Term verst\xE4rken.
+
+<table>
+  <tr>
+    <th>Definition</th>
+    <th>Beispiel</th>
+  </tr>
+  <tr>
+    <td>term^Zahl</td>
+    <td>ultimate^2 repository \u2013 erh\xF6ht die Relevanz von \u201Eultimate"</td>
+  </tr>
+</table>
+
+
+Standardm\xE4\xDFig ist der Boost-Faktor 1. Obwohl der Boost-Faktor positiv sein muss, kann er kleiner als 1 sein (z. B. 0,2)
+
+Standardm\xE4\xDFig werden Repository-Namen um 1,5 und Namespace-Namen um 1,25 geboostet.
+
+## Boolesche Operatoren
+
+Hinweis: Logische Operatoren m\xFCssen in Gro\xDFbuchstaben eingegeben werden (z. B. \u201EAND").
+
+<table>
+  <tr>
+    <th>Definition</th>
+    <th>Beispiel</th>
+  </tr>
+  <tr>
+    <td>AND \u2013 beide Terme m\xFCssen enthalten sein</td>
+    <td>Ultimate AND Repository \u2013 findet z.B. Ultimate Repository, Ultimate Special Repository
+ </td>
+  </tr>
+  <tr>
+    <td>OR \u2013 mindestens einer der Terme muss enthalten sein</td>
+    <td>Ultimate OR Repository \u2013 findet z.B.. Ultimate Repository, Ultimate User, Special Repository</td>
+  </tr>
+  <tr>
+    <td>NOT \u2013 der nachfolgende Term darf nicht enthalten sein. \u201E!" kann alternativ verwendet werden.</td>
+    <td>Ultimate NOT Repository \u2013 findet z.B.. Ultimate user, nicht jedoch z.B. Ultimate Repository</td>
+  </tr>
+  <tr>
+    <td>\u2013 schlie\xDFt den folgenden Term von der Suche aus</td>
+    <td>Ultimate Repository -Special \u2013 findet z.B. Ultimate Repository, schlie\xDFt z.B. Ultimate Special Repository aus</td>
+  </tr>
+  <tr>
+    <td>\u2013 der folgende Term muss enthalten sein</td>
+    <td>Ultimate +Repository \u2013 findet z.B. my Repository, Ultimate Repository</td>
+  </tr>
+</table>
+
+
+## Gruppieren
+
+Die Suche unterst\xFCtzt die Verwendung von Klammern zur Gruppierung von Begriffen, um Teilabfragen zu bilden. Dies kann sehr n\xFCtzlich sein, wenn Sie die boolesche Logik f\xFCr eine Abfrage steuern m\xF6chten.
+
+<table>
+  <tr>
+    <th>Definition</th>
+    <th>Beispiel</th>
+  </tr>
+  <tr>
+    <td>() \u2013 Terme zwischen den Klammern werden gruppiert</td>
+    <td>(Ultimate OR my) AND Repository \u2013 findet z.B.. Ultimate Repository, my Repository, schlie\xDFt z.B. Super Repository. Entweder "Ultimate" oder \u201CMy\u201D m\xFCssen im Ergebnis existieren, \u201CRepository\u201D muss immer enthalten sein.
+ </td>
+  </tr>
+</table>
+
+
+## Umgang mit Sonderzeichen
+
+Die Suche unterst\xFCtzt Sonderzeichen, die Teil der Abfragesyntax sind. Die aktuellen Sonderzeichen der Liste sind
+
+&plus; &minus; && || ! ( ) { } [ ] ^ " ~ * ? : &bsol; /
+
+Um diese Zeichen zu nutzen, verwenden Sie \u201E&bsol;" vor dem jeweiligen Zeichen. Um zum Beispiel nach (1+1):2 zu suchen, verwenden Sie diese Abfrage:
+
+&bsol;(1&bsol;+1&bsol;)&bsol;:2
+
+Partiell \xFCbersetzt mit www.DeepL.com/Translator (kostenlose Version)
+
+Quelle [https://javadoc.io/static/org.apache.lucene/lucene-queryparser/8.9.0/org/apache/lucene/queryparser/classic/package-summary.html#package.description](https://javadoc.io/static/org.apache.lucene/lucene-queryparser/8.9.0/org/apache/lucene/queryparser/classic/package-summary.html#package.description)`;
+
+// src/help/search/syntax.ts
+var syntax_default = {
+  de: syntax_de_default,
+  en: syntax_en_default
+};
+
+// src/help/search/modal.en.ts
+var modal_en_default = `Our search uses Lucene and you may use the [full syntax](http://lucene.apache.org/core/8_9_0/index.html).
+
+To learn about advanced search read our [Expert Search Site](/help/search-syntax).
+
+### Basic Search
+
+- The most relevant repositories are shown in the quick results.
+- Press "enter" or click the "Show all results" button to find more results for all entities like users or groups.
+- A multi-character wildcard (*) is added to your search by default.
+- Do not enter Wildcards in front of the search!`;
+
+// src/help/search/modal.de.ts
+var modal_de_default = `Unsere Suche basiert auf Lucene. Sie k\xF6nnen die [vollst\xE4ndige Syntax](http://lucene.apache.org/core/8_9_0/index.html) nutzen.
+
+Um mehr \xFCber die fortgeschrittene Suche zu erfahren, lesen sie unsere [Expertenseite](/help/search-syntax).
+
+### Einfache Suche
+
+- Die relevantesten Repositories werden in den Quick Results angezeigt.
+- \xDCber die Eingabe-Taste oder den Button "Alle Ergebnisse anzeigen" bekommen Sie Ergebnisse aller durchsuchten Entit\xE4ten wie Nutzern oder Gruppen.
+- Eine Wildcard f\xFCr eine beliebige Anzahl an beliebigen Zeichen wird Ihrer Suche standardm\xE4\xDFig angeh\xE4ngt.
+- Geben Sie keine Wildcards vor dem Suchbegriff ein!`;
+
+// src/help/search/modal.ts
+var modal_default = {
+  de: modal_de_default,
+  en: modal_en_default
+};
+
+// src/search.ts
+var defaultSearchOptions = {
+  type: "repository"
+};
+var isString = (str) => !!str;
+var useSearchTypes = () => {
+  return useSearchLinks().map((link) => link.name).filter(isString);
+};
+var useSearchableTypes = () => useIndexJsonResource("searchableTypes");
+var useSearchCounts = (types, query) => {
+  const searchLinks = useSearchLinks();
+  const queries = useQueries(types.map((type) => ({
+    queryKey: ["search", type, query, "count"],
+    queryFn: () => apiClient.get(`${findLink(searchLinks, type)}?q=${query}&countOnly=true`).then((response) => response.json())
+  })));
+  const result = {};
+  queries.forEach((q, i) => {
+    var _a;
+    result[types[i]] = {
+      isLoading: q.isLoading,
+      isFetching: q.isFetching,
+      error: q.error,
+      data: (_a = q.data) == null ? void 0 : _a.totalHits
+    };
+  });
+  return result;
+};
+var findLink = (links, name) => {
+  for (const l of links) {
+    if (l.name === name) {
+      return l.href;
+    }
+  }
+  throw new Error(`could not find search link for ${name}`);
+};
+var useSearchLinks = () => {
+  const links = useIndexLinks();
+  const searchLinks = links["search"];
+  if (!searchLinks) {
+    throw new Error("could not find search links in index");
+  }
+  if (!Array.isArray(searchLinks)) {
+    throw new Error("search links returned in wrong format, array is expected");
+  }
+  return searchLinks;
+};
+var useSearchLink = (name) => {
+  const searchLinks = useSearchLinks();
+  return findLink(searchLinks, name);
+};
+var useSearch = (query, optionParam = defaultSearchOptions) => {
+  const options = __spreadValues(__spreadValues({}, defaultSearchOptions), optionParam);
+  const link = useSearchLink(options.type);
+  const queryParams = {};
+  queryParams.q = query;
+  if (options.page) {
+    queryParams.page = options.page.toString();
+  }
+  if (options.pageSize) {
+    queryParams.pageSize = options.pageSize.toString();
+  }
+  return useQuery25(["search", options.type, queryParams], () => apiClient.get(`${link}?${createQueryString(queryParams)}`).then((response) => response.json()), {
+    enabled: (query == null ? void 0 : query.length) > 1
+  });
+};
+var useObserveAsync = (fn, deps) => {
+  const [data, setData] = useState3();
+  const [isLoading, setLoading] = useState3(false);
+  const [error, setError] = useState3();
+  useEffect5(() => {
+    setLoading(true);
+    fn(...deps).then(setData).catch(setError).finally(() => setLoading(false));
+  }, deps);
+  return { data, isLoading, error };
+};
+var getTypedKeys = (input) => Object.keys(input);
+var isSupportedLanguage = (input, supportedLanguages) => supportedLanguages.includes(input);
+var pickLang = (language, supportedLanguages, fallback) => isSupportedLanguage(language, supportedLanguages) ? language : fallback;
+var SUPPORTED_MODAL_LANGUAGES = getTypedKeys(modal_default);
+var SUPPORTED_SYNTAX_LANGUAGES = getTypedKeys(syntax_default);
+var FALLBACK_LANGUAGE = "en";
+var useSearchHelpContent = (language) => useObserveAsync((lang) => Promise.resolve(modal_default[pickLang(lang, SUPPORTED_MODAL_LANGUAGES, FALLBACK_LANGUAGE)]), [language]);
+var useSearchSyntaxContent = (language) => useObserveAsync((lang) => Promise.resolve(syntax_default[pickLang(lang, SUPPORTED_SYNTAX_LANGUAGES, FALLBACK_LANGUAGE)]), [language]);
+
+// src/loginInfo.ts
+import { useQuery as useQuery26 } from "react-query";
+var useLoginInfo = (disabled = false) => {
+  const loginInfoLink = useIndexLink("loginInfo");
+  const { error, isLoading, data } = useQuery26(["loginInfo"], () => fetch(loginInfoLink).then((response) => response.json()), {
+    enabled: !disabled && !!loginInfoLink,
+    refetchOnWindowFocus: false
+  });
+  return {
+    data,
+    error,
+    isLoading
+  };
+};
+
+// src/usePluginCenterAuthInfo.ts
+import { useMutation as useMutation16, useQuery as useQuery27, useQueryClient as useQueryClient18 } from "react-query";
+import { useLocation } from "react-router-dom";
+var appendQueryParam = (link, name, value) => {
+  let href = link.href;
+  if (href.includes("?")) {
+    href += "&";
+  } else {
+    href += "?";
+  }
+  link.href = href + name + "=" + value;
+};
+var usePluginCenterAuthInfo = () => {
+  const link = useIndexLink("pluginCenterAuth");
+  const location = useLocation();
+  return useQuery27(["pluginCenterAuth"], () => {
+    if (!link) {
+      throw new Error("no such plugin center auth link");
+    }
+    return apiClient.get(link).then((response) => response.json()).then((result) => {
+      var _a, _b;
+      if ((_a = result._links) == null ? void 0 : _a.login) {
+        appendQueryParam(result._links.login, "source", location.pathname);
+      }
+      if ((_b = result._links) == null ? void 0 : _b.reconnect) {
+        appendQueryParam(result._links.reconnect, "source", location.pathname);
+      }
+      return result;
+    });
+  }, {
+    enabled: !!link
+  });
+};
+var usePluginCenterLogout = (authenticationInfo) => {
+  const queryClient2 = useQueryClient18();
+  const { mutate, isLoading, error } = useMutation16(() => {
+    if (!authenticationInfo._links.logout) {
+      throw new Error("authenticationInfo has no logout link");
+    }
+    const logout = authenticationInfo._links.logout;
+    return apiClient.delete(logout.href);
+  }, {
+    onSuccess: () => queryClient2.invalidateQueries("pluginCenterAuth")
+  });
+  return {
+    logout: () => {
+      mutate();
+    },
+    isLoading,
+    error
+  };
+};
+
+// src/compare.ts
+import { useQuery as useQuery28, useQueryClient as useQueryClient19 } from "react-query";
+function createIncomingUrl(repository, linkName, source, target) {
+  const link = repository._links[linkName];
+  if (link == null ? void 0 : link.templated) {
+    return link.href.replace("{source}", encodeURIComponent(source)).replace("{target}", encodeURIComponent(target));
+  } else {
+    return link.href;
+  }
+}
+function createChangesetUrl(repository, source, target) {
+  return createIncomingUrl(repository, "incomingChangesets", source, target);
+}
+function createDiffUrl(repository, source, target) {
+  if (repository._links.incomingDiffParsed) {
+    return createIncomingUrl(repository, "incomingDiffParsed", source, target);
+  } else {
+    return createIncomingUrl(repository, "incomingDiff", source, target);
+  }
+}
+var useIncomingChangesets = (repository, source, target, request) => {
+  const queryClient2 = useQueryClient19();
+  let link = createChangesetUrl(repository, source, target);
+  if ((request == null ? void 0 : request.page) || (request == null ? void 0 : request.limit)) {
+    if ((request == null ? void 0 : request.page) && (request == null ? void 0 : request.limit)) {
+      link = `${link}?page=${request.page}&pageSize=${request.limit}`;
+    } else if (request.page) {
+      link = `${link}?page=${request.page}`;
+    } else if (request.limit) {
+      link = `${link}?pageSize=${request.limit}`;
+    }
+  }
+  return useQuery28(["repository", repository.namespace, repository.name, "compare", source, target, "changesets", (request == null ? void 0 : request.page) || 0], () => apiClient.get(link).then((response) => response.json()), {
+    onSuccess: (changesetCollection) => {
+      var _a;
+      (_a = changesetCollection._embedded) == null ? void 0 : _a.changesets.forEach((changeset) => {
+        queryClient2.setQueryData(changesetQueryKey(repository, changeset.id), changeset);
+      });
+    }
+  });
+};
+
+// src/ApiProvider.tsx
+import React2, { useEffect as useEffect6 } from "react";
+import { QueryClient as QueryClient4, QueryClientProvider } from "react-query";
+import { ReactQueryDevtools } from "react-query/devtools";
+var queryClient = new QueryClient4({
+  defaultOptions: {
+    queries: {
+      retry: false
+    }
+  }
+});
+var ApiProvider = ({ children, index, me, onMeFetched, onIndexFetched, devtools = true }) => {
+  useEffect6(() => {
+    if (index) {
+      queryClient.setQueryData("index", index);
+      if (onIndexFetched) {
+        onIndexFetched(index);
+      }
+    }
+  }, [index, onIndexFetched]);
+  useEffect6(() => {
+    if (me) {
+      queryClient.setQueryData("me", me);
+      if (onMeFetched) {
+        onMeFetched(me);
+      }
+    }
+  }, [me, onMeFetched]);
+  return /* @__PURE__ */ React2.createElement(QueryClientProvider, {
+    client: queryClient
+  }, /* @__PURE__ */ React2.createElement(LegacyContextProvider, {
+    onIndexFetched,
+    onMeFetched
+  }, children), devtools ? /* @__PURE__ */ React2.createElement(ReactQueryDevtools, {
+    initialIsOpen: false
+  }) : null);
+};
+var clearCache = () => {
+  return reset(queryClient);
+};
+var ApiProvider_default = ApiProvider;
+export {
+  ApiProvider_default as ApiProvider,
+  BackendError,
+  BadGatewayError,
+  CONTENT_TYPE_PUBLIC_KEY,
+  ConflictError,
+  ForbiddenError,
+  LegacyContextProvider,
+  MissingLinkError,
+  NotFoundError,
+  TOKEN_EXPIRED_ERROR_CODE,
+  TokenExpiredError,
+  UnauthorizedError,
+  apiClient,
+  changesetQueryKey,
+  clearCache,
+  createBackendError,
+  createChangesetUrl,
+  createDiffUrl,
+  createQueryString,
+  createUrl,
+  createUrlWithIdentifiers,
+  extractXsrfTokenFromCookie,
+  fetchResourceFromLocationHeader,
+  getResponseJson,
+  isBackendError,
+  objectLink,
+  requiredLink,
+  urls_exports as urls,
+  useAlerts,
+  useAnnotations,
+  useApiKeys,
+  useArchiveRepository,
+  useAvailableGlobalPermissions,
+  useAvailablePermissions,
+  useAvailablePlugins,
+  useBranch,
+  useBranchDetails,
+  useBranchDetailsCollection,
+  useBranches,
+  useCancelPendingPlugins,
+  useChangeUserPassword,
+  useChangeset,
+  useChangesets,
+  useClearNotifications,
+  useConfig,
+  useConfigLink,
+  useContentType,
+  useConvertToExternal,
+  useConvertToInternal,
+  useCreateApiKey,
+  useCreateBranch,
+  useCreateGroup,
+  useCreatePermission,
+  useCreatePublicKey,
+  useCreateRepository,
+  useCreateRepositoryRole,
+  useCreateTag,
+  useCreateUser,
+  useDefaultBranch,
+  useDeleteApiKey,
+  useDeleteBranch,
+  useDeleteGroup,
+  useDeletePermission,
+  useDeletePublicKey,
+  useDeleteRepository,
+  useDeleteRepositoryRole,
+  useDeleteTag,
+  useDeleteUser,
+  useDiff,
+  useDismissNotification,
+  useExecutePendingPlugins,
+  useExportInfo,
+  useExportRepository,
+  useFileContent,
+  useGroup,
+  useGroupPermissions,
+  useGroupSuggestions,
+  useGroups,
+  useHistory,
+  useImportFullRepository,
+  useImportLog,
+  useImportRepositoryFromBundle,
+  useImportRepositoryFromUrl,
+  useIncomingChangesets,
+  useIndex,
+  useIndexJsonResource,
+  useIndexLink,
+  useIndexLinks,
+  useInstallPlugin,
+  useInstalledPlugins,
+  useJsonResource,
+  useLegacyContext,
+  useLogin,
+  useLoginInfo,
+  useLogout,
+  useMe,
+  useNamespace,
+  useNamespaceStrategies,
+  useNamespaceSuggestions,
+  useNamespaces,
+  useNotificationSubscription,
+  useNotifications,
+  usePaths,
+  usePendingPlugins,
+  usePermissions,
+  usePluginCenterAuthInfo,
+  usePluginCenterLogout,
+  usePublicKeys,
+  useRenameRepository,
+  useRepositories,
+  useRepository,
+  useRepositoryRole,
+  useRepositoryRoles,
+  useRepositoryTypes,
+  useRepositoryVerbs,
+  useRequiredIndexLink,
+  useRequiredMe,
+  useRunHealthCheck,
+  useSearch,
+  useSearchCounts,
+  useSearchHelpContent,
+  useSearchSyntaxContent,
+  useSearchTypes,
+  useSearchableTypes,
+  useSetGroupPermissions,
+  useSetUserPassword,
+  useSetUserPermissions,
+  useSources,
+  useSubject,
+  useSuggestions,
+  useTag,
+  useTags,
+  useUnarchiveRepository,
+  useUninstallPlugin,
+  useUpdateConfig,
+  useUpdateGroup,
+  useUpdateInfo,
+  useUpdatePermission,
+  useUpdatePlugins,
+  useUpdateRepository,
+  useUpdateRepositoryRole,
+  useUpdateUser,
+  useUser,
+  useUserPermissions,
+  useUserSuggestions,
+  useUsers,
+  useVersion,
+  waitForRestartAfter
+};