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

package/build/index.js

@@ -0,0 +1,3200 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+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 });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ApiProvider: () => ApiProvider_default,
+  BackendError: () => BackendError,
+  BadGatewayError: () => BadGatewayError,
+  CONTENT_TYPE_PUBLIC_KEY: () => CONTENT_TYPE_PUBLIC_KEY,
+  ConflictError: () => ConflictError,
+  ForbiddenError: () => ForbiddenError,
+  LegacyContextProvider: () => LegacyContextProvider,
+  MissingLinkError: () => MissingLinkError,
+  NotFoundError: () => NotFoundError,
+  TOKEN_EXPIRED_ERROR_CODE: () => TOKEN_EXPIRED_ERROR_CODE,
+  TokenExpiredError: () => TokenExpiredError,
+  UnauthorizedError: () => UnauthorizedError,
+  apiClient: () => apiClient,
+  changesetQueryKey: () => changesetQueryKey,
+  clearCache: () => clearCache,
+  createBackendError: () => createBackendError,
+  createChangesetUrl: () => createChangesetUrl,
+  createDiffUrl: () => createDiffUrl,
+  createQueryString: () => createQueryString,
+  createUrl: () => createUrl,
+  createUrlWithIdentifiers: () => createUrlWithIdentifiers,
+  extractXsrfTokenFromCookie: () => extractXsrfTokenFromCookie,
+  fetchResourceFromLocationHeader: () => fetchResourceFromLocationHeader,
+  getResponseJson: () => getResponseJson,
+  isBackendError: () => isBackendError,
+  objectLink: () => objectLink,
+  requiredLink: () => requiredLink,
+  urls: () => urls_exports,
+  useAlerts: () => useAlerts,
+  useAnnotations: () => useAnnotations,
+  useApiKeys: () => useApiKeys,
+  useArchiveRepository: () => useArchiveRepository,
+  useAvailableGlobalPermissions: () => useAvailableGlobalPermissions,
+  useAvailablePermissions: () => useAvailablePermissions,
+  useAvailablePlugins: () => useAvailablePlugins,
+  useBranch: () => useBranch,
+  useBranchDetails: () => useBranchDetails,
+  useBranchDetailsCollection: () => useBranchDetailsCollection,
+  useBranches: () => useBranches,
+  useCancelPendingPlugins: () => useCancelPendingPlugins,
+  useChangeUserPassword: () => useChangeUserPassword,
+  useChangeset: () => useChangeset,
+  useChangesets: () => useChangesets,
+  useClearNotifications: () => useClearNotifications,
+  useConfig: () => useConfig,
+  useConfigLink: () => useConfigLink,
+  useContentType: () => useContentType,
+  useConvertToExternal: () => useConvertToExternal,
+  useConvertToInternal: () => useConvertToInternal,
+  useCreateApiKey: () => useCreateApiKey,
+  useCreateBranch: () => useCreateBranch,
+  useCreateGroup: () => useCreateGroup,
+  useCreatePermission: () => useCreatePermission,
+  useCreatePublicKey: () => useCreatePublicKey,
+  useCreateRepository: () => useCreateRepository,
+  useCreateRepositoryRole: () => useCreateRepositoryRole,
+  useCreateTag: () => useCreateTag,
+  useCreateUser: () => useCreateUser,
+  useDefaultBranch: () => useDefaultBranch,
+  useDeleteApiKey: () => useDeleteApiKey,
+  useDeleteBranch: () => useDeleteBranch,
+  useDeleteGroup: () => useDeleteGroup,
+  useDeletePermission: () => useDeletePermission,
+  useDeletePublicKey: () => useDeletePublicKey,
+  useDeleteRepository: () => useDeleteRepository,
+  useDeleteRepositoryRole: () => useDeleteRepositoryRole,
+  useDeleteTag: () => useDeleteTag,
+  useDeleteUser: () => useDeleteUser,
+  useDiff: () => useDiff,
+  useDismissNotification: () => useDismissNotification,
+  useExecutePendingPlugins: () => useExecutePendingPlugins,
+  useExportInfo: () => useExportInfo,
+  useExportRepository: () => useExportRepository,
+  useFileContent: () => useFileContent,
+  useGroup: () => useGroup,
+  useGroupPermissions: () => useGroupPermissions,
+  useGroupSuggestions: () => useGroupSuggestions,
+  useGroups: () => useGroups,
+  useHistory: () => useHistory,
+  useImportFullRepository: () => useImportFullRepository,
+  useImportLog: () => useImportLog,
+  useImportRepositoryFromBundle: () => useImportRepositoryFromBundle,
+  useImportRepositoryFromUrl: () => useImportRepositoryFromUrl,
+  useIncomingChangesets: () => useIncomingChangesets,
+  useIndex: () => useIndex,
+  useIndexJsonResource: () => useIndexJsonResource,
+  useIndexLink: () => useIndexLink,
+  useIndexLinks: () => useIndexLinks,
+  useInstallPlugin: () => useInstallPlugin,
+  useInstalledPlugins: () => useInstalledPlugins,
+  useJsonResource: () => useJsonResource,
+  useLegacyContext: () => useLegacyContext,
+  useLogin: () => useLogin,
+  useLoginInfo: () => useLoginInfo,
+  useLogout: () => useLogout,
+  useMe: () => useMe,
+  useNamespace: () => useNamespace,
+  useNamespaceStrategies: () => useNamespaceStrategies,
+  useNamespaceSuggestions: () => useNamespaceSuggestions,
+  useNamespaces: () => useNamespaces,
+  useNotificationSubscription: () => useNotificationSubscription,
+  useNotifications: () => useNotifications,
+  usePaths: () => usePaths,
+  usePendingPlugins: () => usePendingPlugins,
+  usePermissions: () => usePermissions,
+  usePluginCenterAuthInfo: () => usePluginCenterAuthInfo,
+  usePluginCenterLogout: () => usePluginCenterLogout,
+  usePublicKeys: () => usePublicKeys,
+  useRenameRepository: () => useRenameRepository,
+  useRepositories: () => useRepositories,
+  useRepository: () => useRepository,
+  useRepositoryRole: () => useRepositoryRole,
+  useRepositoryRoles: () => useRepositoryRoles,
+  useRepositoryTypes: () => useRepositoryTypes,
+  useRepositoryVerbs: () => useRepositoryVerbs,
+  useRequiredIndexLink: () => useRequiredIndexLink,
+  useRequiredMe: () => useRequiredMe,
+  useRunHealthCheck: () => useRunHealthCheck,
+  useSearch: () => useSearch,
+  useSearchCounts: () => useSearchCounts,
+  useSearchHelpContent: () => useSearchHelpContent,
+  useSearchSyntaxContent: () => useSearchSyntaxContent,
+  useSearchTypes: () => useSearchTypes,
+  useSearchableTypes: () => useSearchableTypes,
+  useSetGroupPermissions: () => useSetGroupPermissions,
+  useSetUserPassword: () => useSetUserPassword,
+  useSetUserPermissions: () => useSetUserPermissions,
+  useSources: () => useSources,
+  useSubject: () => useSubject,
+  useSuggestions: () => useSuggestions,
+  useTag: () => useTag,
+  useTags: () => useTags,
+  useUnarchiveRepository: () => useUnarchiveRepository,
+  useUninstallPlugin: () => useUninstallPlugin,
+  useUpdateConfig: () => useUpdateConfig,
+  useUpdateGroup: () => useUpdateGroup,
+  useUpdateInfo: () => useUpdateInfo,
+  useUpdatePermission: () => useUpdatePermission,
+  useUpdatePlugins: () => useUpdatePlugins,
+  useUpdateRepository: () => useUpdateRepository,
+  useUpdateRepositoryRole: () => useUpdateRepositoryRole,
+  useUpdateUser: () => useUpdateUser,
+  useUser: () => useUser,
+  useUserPermissions: () => useUserPermissions,
+  useUserSuggestions: () => useUserSuggestions,
+  useUsers: () => useUsers,
+  useVersion: () => useVersion,
+  waitForRestartAfter: () => waitForRestartAfter
+});
+module.exports = __toCommonJS(src_exports);
+
+// 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
+});
+var import_query_string = __toESM(require("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 = import_query_string.default.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
+var import_react_query2 = require("react-query");
+
+// src/LegacyContext.tsx
+var import_react = __toESM(require("react"));
+var import_react_query = require("react-query");
+var Context = (0, import_react.createContext)(void 0);
+var useLegacyContext = () => {
+  const context = (0, import_react.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 = (0, import_react_query.useQueryClient)();
+  const ctx = createInitialContext(queryClient2, { onIndexFetched, onMeFetched });
+  return /* @__PURE__ */ import_react.default.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 (0, import_react_query2.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 (0, import_react_query2.useQuery)(name, () => apiClient.get(link).then((response) => response.json()), {
+    enabled: !!link
+  });
+};
+var useJsonResource = (entity, name, key) => (0, import_react_query2.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
+var import_react_query4 = require("react-query");
+
+// src/reset.ts
+var import_react_query3 = require("react-query");
+var reset = (queryClient2) => {
+  queryClient2.removeQueries({
+    predicate: ({ queryKey }) => queryKey !== "index"
+  });
+  return queryClient2.invalidateQueries("index");
+};
+var useReset = () => {
+  const queryClient2 = (0, import_react_query3.useQueryClient)();
+  return () => reset(queryClient2);
+};
+
+// src/login.ts
+var import_react2 = require("react");
+var useMe = () => {
+  const legacy = useLegacyContext();
+  const link = useIndexLink("me");
+  return (0, import_react_query4.useQuery)("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 } = (0, import_react_query4.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 } = (0, import_react_query4.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 = (0, import_react2.useCallback)(() => {
+    mutate({});
+  }, [mutate]);
+  return {
+    logout: link && !data ? logout : void 0,
+    isLoading,
+    error
+  };
+};
+
+// src/groups.ts
+var import_react_query5 = require("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 = (0, import_react_query5.useQueryClient)();
+  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 (0, import_react_query5.useQuery)(["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 (0, import_react_query5.useQuery)(["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 = (0, import_react_query5.useQueryClient)();
+  const link = useRequiredIndexLink("groups");
+  const { mutate, data, isLoading, error } = (0, import_react_query5.useMutation)(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 = (0, import_react_query5.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query5.useMutation)((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 = (0, import_react_query5.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query5.useMutation)((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
+var import_react_query6 = require("react-query");
+var useUsers = (request) => {
+  const queryClient2 = (0, import_react_query6.useQueryClient)();
+  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 (0, import_react_query6.useQuery)(["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 (0, import_react_query6.useQuery)(["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 = (0, import_react_query6.useQueryClient)();
+  const link = useRequiredIndexLink("users");
+  const { mutate, data, isLoading, error } = (0, import_react_query6.useMutation)(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 = (0, import_react_query6.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query6.useMutation)((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 = (0, import_react_query6.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query6.useMutation)((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 = (0, import_react_query6.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query6.useMutation)(({ 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 = (0, import_react_query6.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query6.useMutation)((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 } = (0, import_react_query6.useMutation)((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 } = (0, import_react_query6.useMutation)((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
+var import_react_query7 = require("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
+var import_react3 = require("react");
+var useRepositories = (request) => {
+  var _a, _b, _c;
+  const queryClient2 = (0, import_react_query7.useQueryClient)();
+  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 (0, import_react_query7.useQuery)(["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 = (0, import_react_query7.useQueryClient)();
+  const link = useRequiredIndexLink("repositories");
+  const { mutate, data, isLoading, error } = (0, import_react_query7.useMutation)(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 (0, import_react_query7.useQuery)(["repository", namespace, name], () => apiClient.get(concat(link, namespace, name)).then((response) => response.json()));
+};
+var useDeleteRepository = (options) => {
+  const queryClient2 = (0, import_react_query7.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query7.useMutation)((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 = (0, import_react_query7.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query7.useMutation)((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 = (0, import_react_query7.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query7.useMutation)((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 = (0, import_react_query7.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query7.useMutation)((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 = (0, import_react_query7.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query7.useMutation)((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 } = (0, import_react_query7.useQuery)(["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 = (0, import_react_query7.useQueryClient)();
+  const [intervalId, setIntervalId] = (0, import_react3.useState)();
+  (0, import_react3.useEffect)(() => {
+    return () => {
+      if (intervalId) {
+        clearInterval(intervalId);
+      }
+    };
+  }, [intervalId]);
+  const { mutate, isLoading, error, data } = (0, import_react_query7.useMutation)(({ 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 (0, import_react_query7.useQuery)(repoQueryKey(repository, "paths", revision), () => apiClient.get(link).then((response) => response.json()));
+};
+var useRenameRepository = (repository) => {
+  const queryClient2 = (0, import_react_query7.useQueryClient)();
+  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 } = (0, import_react_query7.useMutation)(({ 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
+var import_react_query8 = require("react-query");
+var useNamespaces = () => {
+  return useIndexJsonResource("namespaces");
+};
+var useNamespace = (name) => {
+  const namespacesLink = useRequiredIndexLink("namespaces");
+  return (0, import_react_query8.useQuery)(["namespace", name], () => apiClient.get(concat(namespacesLink, name)).then((response) => response.json()));
+};
+var useNamespaceStrategies = () => {
+  return useIndexJsonResource("namespaceStrategies");
+};
+
+// src/branches.ts
+var import_react_query9 = require("react-query");
+var import_react4 = require("react");
+var useBranches = (repository) => {
+  const queryClient2 = (0, import_react_query9.useQueryClient)();
+  const link = requiredLink(repository, "branches");
+  return (0, import_react_query9.useQuery)(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 (0, import_react_query9.useQuery)(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 = (0, import_react_query9.useQueryClient)();
+  const { data, isLoading, error, fetchNextPage } = (0, import_react_query9.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));
+    }
+  });
+  (0, import_react4.useEffect)(() => {
+    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 (0, import_react_query9.useQuery)(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 = (0, import_react_query9.useQueryClient)();
+  const link = requiredLink(repository, "branches");
+  const { mutate, isLoading, error, data } = (0, import_react_query9.useMutation)(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 = (0, import_react_query9.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query9.useMutation)((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 (0, import_react_query9.useQuery)(branchQueryKey(repository, "__default-branch"), () => apiClient.get(link).then((response) => response.json()));
+};
+
+// src/changesets.ts
+var import_react_query10 = require("react-query");
+var changesetQueryKey = (repository, id) => {
+  return repoQueryKey(repository, "changeset", id);
+};
+var useChangesets = (repository, request) => {
+  const queryClient2 = (0, import_react_query10.useQueryClient)();
+  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 (0, import_react_query10.useQuery)(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 (0, import_react_query10.useQuery)(changesetQueryKey(repository, id), () => apiClient.get(concat(changesetsLink, id)).then((response) => response.json()));
+};
+
+// src/tags.ts
+var import_react_query11 = require("react-query");
+var tagQueryKey = (repository, tag) => {
+  return repoQueryKey(repository, "tag", tag);
+};
+var useTags = (repository) => {
+  const link = requiredLink(repository, "tags");
+  return (0, import_react_query11.useQuery)(repoQueryKey(repository, "tags"), () => apiClient.get(link).then((response) => response.json()));
+};
+var useTag = (repository, name) => {
+  const link = requiredLink(repository, "tags");
+  return (0, import_react_query11.useQuery)(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 = (0, import_react_query11.useQueryClient)();
+  const link = requiredLink(changeset, "tag");
+  const { isLoading, error, mutate, data } = (0, import_react_query11.useMutation)(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 = (0, import_react_query11.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query11.useMutation)((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
+var import_react_query12 = require("react-query");
+var useConfig = () => {
+  const indexLink = useIndexLink("config");
+  return (0, import_react_query12.useQuery)("config", () => apiClient.get(indexLink).then((response) => response.json()), {
+    enabled: !!indexLink
+  });
+};
+var useUpdateConfig = () => {
+  const queryClient2 = (0, import_react_query12.useQueryClient)();
+  const { mutate, isLoading, error, data, reset: reset2 } = (0, import_react_query12.useMutation)((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
+var import_react_query13 = require("react-query");
+var useUpdateInfo = () => {
+  const indexLink = useIndexLink("updateInfo");
+  return (0, import_react_query13.useQuery)("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
+var import_ui_types = require("@scm-manager/ui-types");
+var import_react_query14 = require("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 (0, import_react_query14.useQuery)(["plugins", "available"], () => apiClient.get(indexLink).then((response) => response.json()), {
+    enabled,
+    retry: 3
+  });
+};
+var useInstalledPlugins = ({ enabled } = {}) => {
+  const indexLink = useRequiredIndexLink("installedPlugins");
+  return (0, import_react_query14.useQuery)(["plugins", "installed"], () => apiClient.get(indexLink).then((response) => response.json()), {
+    enabled,
+    retry: 3
+  });
+};
+var usePendingPlugins = () => {
+  const indexLink = useIndexLink("pendingPlugins");
+  return (0, import_react_query14.useQuery)(["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 = (0, import_react_query14.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query14.useMutation)((_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 = (0, import_react_query14.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query14.useMutation)((_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 = (0, import_react_query14.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query14.useMutation)((_a) => {
+    var { plugins, restartOptions: _b } = _a, _c = _b, { restart } = _c, waitForRestartOptions = __objRest(_c, ["restart"]);
+    const isCollection = (0, import_ui_types.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 = (0, import_react_query14.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query14.useMutation)(({ 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 = (0, import_react_query14.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query14.useMutation)((pending) => apiClient.post(requiredLink(pending, "cancel")), {
+    onSuccess: () => queryClient2.invalidateQueries("plugins")
+  });
+  return {
+    update: (pending) => mutate(pending),
+    isLoading,
+    error,
+    isCancelled: !!data
+  };
+};
+
+// src/repository-roles.ts
+var import_react_query15 = require("react-query");
+var useRepositoryRoles = (request) => {
+  const queryClient2 = (0, import_react_query15.useQueryClient)();
+  const indexLink = useRequiredIndexLink("repositoryRoles");
+  const queryParams = {};
+  if (request == null ? void 0 : request.page) {
+    queryParams.page = request.page.toString();
+  }
+  return (0, import_react_query15.useQuery)(["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 (0, import_react_query15.useQuery)(["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 = (0, import_react_query15.useQueryClient)();
+  const link = useRequiredIndexLink("repositoryRoles");
+  const { mutate, data, isLoading, error } = (0, import_react_query15.useMutation)(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 = (0, import_react_query15.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query15.useMutation)((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 = (0, import_react_query15.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query15.useMutation)((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
+var import_react_query16 = require("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 (0, import_react_query16.useQuery)(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 = (0, import_react_query16.useQueryClient)();
+  const link = requiredLink(namespaceOrRepository, "permissions");
+  const { isLoading, error, mutate, data } = (0, import_react_query16.useMutation)(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 = (0, import_react_query16.useQueryClient)();
+  const { isLoading, error, mutate, data } = (0, import_react_query16.useMutation)((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 = (0, import_react_query16.useQueryClient)();
+  const { isLoading, error, mutate, data } = (0, import_react_query16.useMutation)((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 = (0, import_react_query16.useQueryClient)();
+  const url = permissionCollection ? objectLink(permissionCollection, "overwrite") : null;
+  const { isLoading, error, mutate, data } = (0, import_react_query16.useMutation)((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
+var import_react_query17 = require("react-query");
+var import_react5 = require("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 } = (0, import_react_query17.useInfiniteQuery)(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);
+  (0, import_react5.useEffect)(() => {
+    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
+var import_react_query18 = require("react-query");
+var useImportLog = (logId) => {
+  const link = useRequiredIndexLink("importLog").replace("{logId}", logId);
+  return (0, import_react_query18.useQuery)(["importLog", logId], () => apiClient.get(link).then((response) => response.text()));
+};
+var useImportRepositoryFromUrl = (repositoryType) => {
+  const url = requiredLink(repositoryType, "import", "url");
+  const { isLoading, error, data, mutate } = (0, import_react_query18.useMutation)((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 } = (0, import_react_query18.useMutation)(({ 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 } = (0, import_react_query18.useMutation)(({ 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
+var import_gitdiff_parser = __toESM(require("gitdiff-parser"));
+var import_react_query19 = require("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 } = (0, import_react_query19.useInfiniteQuery)(["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(import_gitdiff_parser.default.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
+var import_react_query20 = require("react-query");
+var import_react6 = require("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 } = (0, import_react_query20.useQuery)("notifications", () => apiClient.get(link).then((response) => response.json()), {
+    enabled: !!link
+  });
+  const memoizedRefetch = (0, import_react6.useCallback)(() => {
+    return refetch().then((r) => r.data);
+  }, [refetch]);
+  return {
+    data,
+    error,
+    isLoading,
+    refetch: memoizedRefetch
+  };
+};
+var useDismissNotification = (notification) => {
+  const queryClient2 = (0, import_react_query20.useQueryClient)();
+  const link = requiredLink(notification, "dismiss");
+  const { data, isLoading, error, mutate } = (0, import_react_query20.useMutation)(() => apiClient.delete(link), {
+    onSuccess: () => {
+      queryClient2.invalidateQueries("notifications");
+    }
+  });
+  return {
+    isLoading,
+    error,
+    dismiss: () => mutate(),
+    isCleared: !!data
+  };
+};
+var useClearNotifications = (notificationCollection) => {
+  const queryClient2 = (0, import_react_query20.useQueryClient)();
+  const link = requiredLink(notificationCollection, "clear");
+  const { data, isLoading, error, mutate } = (0, import_react_query20.useMutation)(() => 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] = (0, import_react6.useState)([]);
+  const [disconnectedAt, setDisconnectedAt] = (0, import_react6.useState)();
+  const link = (_a = notificationCollection == null ? void 0 : notificationCollection._links.subscribe) == null ? void 0 : _a.href;
+  const onVisible = (0, import_react6.useCallback)(() => {
+    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 = (0, import_react6.useCallback)(() => {
+    setDisconnectedAt(new Date());
+  }, []);
+  const received = (0, import_react6.useCallback)((notification) => {
+    setNotifications((previous) => [...previous, notification]);
+    refetch();
+  }, [refetch]);
+  (0, import_react6.useEffect)(() => {
+    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 = (0, import_react6.useCallback)((notification) => {
+    setNotifications((oldNotifications) => [...oldNotifications.filter((n) => !isEqual(n, notification))]);
+  }, [setNotifications]);
+  const clear = (0, import_react6.useCallback)(() => {
+    setNotifications([]);
+  }, [setNotifications]);
+  return {
+    notifications,
+    remove,
+    clear
+  };
+};
+
+// src/alerts.ts
+var import_react_query21 = require("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 } = (0, import_react_query21.useQuery)("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
+var import_react_query22 = require("react-query");
+var import_react7 = require("react");
+var useConfigLink = (link) => {
+  const queryClient2 = (0, import_react_query22.useQueryClient)();
+  const queryKey = ["configLink", link];
+  const { isLoading, error, data } = (0, import_react_query22.useQuery)(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
+  } = (0, import_react_query22.useMutation)((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 = (0, import_react7.useCallback)((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
+var import_react_query23 = require("react-query");
+var CONTENT_TYPE_API_KEY = "application/vnd.scmm-apiKey+json;v=2";
+var useApiKeys = (user) => (0, import_react_query23.useQuery)(["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 = (0, import_react_query23.useQueryClient)();
+  const { mutate, data, isLoading, error, reset: reset2 } = (0, import_react_query23.useMutation)(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 = (0, import_react_query23.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query23.useMutation)((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
+var import_react_query24 = require("react-query");
+var CONTENT_TYPE_PUBLIC_KEY = "application/vnd.scmm-publicKey+json;v=2";
+var usePublicKeys = (user) => (0, import_react_query24.useQuery)(["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 = (0, import_react_query24.useQueryClient)();
+  const { mutate, data, isLoading, error, reset: reset2 } = (0, import_react_query24.useMutation)(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 = (0, import_react_query24.useQueryClient)();
+  const { mutate, isLoading, error, data } = (0, import_react_query24.useMutation)((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
+var import_react_query25 = require("react-query");
+var useFileContent = (file) => {
+  const selfLink = requiredLink(file, "self");
+  return (0, import_react_query25.useQuery)(["fileContent", selfLink], () => apiClient.get(selfLink).then((response) => response.text()));
+};
+
+// src/history.ts
+var import_react_query26 = require("react-query");
+var useHistory = (repository, revision, file, request) => {
+  const queryClient2 = (0, import_react_query26.useQueryClient)();
+  const link = file._links.history.href;
+  const queryParams = {};
+  if (request == null ? void 0 : request.page) {
+    queryParams.page = request.page.toString();
+  }
+  return (0, import_react_query26.useQuery)(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
+var import_react_query27 = require("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 } = (0, import_react_query27.useQuery)(["contentType", url], () => getContentType(url));
+  return {
+    isLoading,
+    isFetching,
+    error,
+    data
+  };
+};
+
+// src/annotations.ts
+var import_react_query28 = require("react-query");
+var useAnnotations = (repository, revision, file) => {
+  const { isLoading, isFetching, error, data } = (0, import_react_query28.useQuery)(repoQueryKey(repository, "annotations", revision, file.path), () => apiClient.get(file._links.annotate.href).then((response) => response.json()));
+  return {
+    isLoading,
+    isFetching,
+    error,
+    data
+  };
+};
+
+// src/search.ts
+var import_react_query29 = require("react-query");
+var import_react8 = require("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 = (0, import_react_query29.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 (0, import_react_query29.useQuery)(["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] = (0, import_react8.useState)();
+  const [isLoading, setLoading] = (0, import_react8.useState)(false);
+  const [error, setError] = (0, import_react8.useState)();
+  (0, import_react8.useEffect)(() => {
+    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
+var import_react_query30 = require("react-query");
+var useLoginInfo = (disabled = false) => {
+  const loginInfoLink = useIndexLink("loginInfo");
+  const { error, isLoading, data } = (0, import_react_query30.useQuery)(["loginInfo"], () => fetch(loginInfoLink).then((response) => response.json()), {
+    enabled: !disabled && !!loginInfoLink,
+    refetchOnWindowFocus: false
+  });
+  return {
+    data,
+    error,
+    isLoading
+  };
+};
+
+// src/usePluginCenterAuthInfo.ts
+var import_react_query31 = require("react-query");
+var import_react_router_dom = require("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 = (0, import_react_router_dom.useLocation)();
+  return (0, import_react_query31.useQuery)(["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 = (0, import_react_query31.useQueryClient)();
+  const { mutate, isLoading, error } = (0, import_react_query31.useMutation)(() => {
+    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
+var import_react_query32 = require("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 = (0, import_react_query32.useQueryClient)();
+  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 (0, import_react_query32.useQuery)(["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
+var import_react9 = __toESM(require("react"));
+var import_react_query33 = require("react-query");
+var import_devtools = require("react-query/devtools");
+var queryClient = new import_react_query33.QueryClient({
+  defaultOptions: {
+    queries: {
+      retry: false
+    }
+  }
+});
+var ApiProvider = ({ children, index, me, onMeFetched, onIndexFetched, devtools = true }) => {
+  (0, import_react9.useEffect)(() => {
+    if (index) {
+      queryClient.setQueryData("index", index);
+      if (onIndexFetched) {
+        onIndexFetched(index);
+      }
+    }
+  }, [index, onIndexFetched]);
+  (0, import_react9.useEffect)(() => {
+    if (me) {
+      queryClient.setQueryData("me", me);
+      if (onMeFetched) {
+        onMeFetched(me);
+      }
+    }
+  }, [me, onMeFetched]);
+  return /* @__PURE__ */ import_react9.default.createElement(import_react_query33.QueryClientProvider, {
+    client: queryClient
+  }, /* @__PURE__ */ import_react9.default.createElement(LegacyContextProvider, {
+    onIndexFetched,
+    onMeFetched
+  }, children), devtools ? /* @__PURE__ */ import_react9.default.createElement(import_devtools.ReactQueryDevtools, {
+    initialIsOpen: false
+  }) : null);
+};
+var clearCache = () => {
+  return reset(queryClient);
+};
+var ApiProvider_default = ApiProvider;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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,
+  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
+});