@strapi/admin 5.0.0-alpha.1 → 5.0.0-alpha.3

package/dist/admin/reducers-uDxSALD_.js

@@ -0,0 +1,4762 @@
+'use strict';
+
+const jsxRuntime = require('react/jsx-runtime');
+const React = require('react');
+const reactContext = require('@radix-ui/react-context');
+const reactIntl = require('react-intl');
+const isEqual = require('lodash/isEqual');
+const axios = require('axios');
+const defaultsDeep = require('lodash/defaultsDeep');
+const designSystem = require('@strapi/design-system');
+const reactRedux = require('react-redux');
+const styled = require('styled-components');
+const immer = require('immer');
+const reactHelmet = require('react-helmet');
+const reactRouterDom = require('react-router-dom');
+const reactDnd = require('react-dnd');
+const get = require('lodash/get');
+const set = require('lodash/set');
+const ContextSelector = require('use-context-selector');
+const Icons = require('@strapi/icons');
+const toolkit = require('@reduxjs/toolkit');
+const react = require('@reduxjs/toolkit/query/react');
+const qs = require('qs');
+const v2 = require('@strapi/design-system/v2');
+const fractionalIndexing = require('fractional-indexing');
+const pipe = require('lodash/fp/pipe');
+const reactDndHtml5Backend = require('react-dnd-html5-backend');
+const reactWindow = require('react-window');
+const clone = require('lodash/clone');
+const toPath = require('lodash/toPath');
+const yup = require('yup');
+
+const _interopDefault = e => e && e.__esModule ? e : { default: e };
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
+  if (e) {
+    for (const k in e) {
+      if (k !== 'default') {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+const React__namespace = /*#__PURE__*/_interopNamespace(React);
+const isEqual__default = /*#__PURE__*/_interopDefault(isEqual);
+const axios__default = /*#__PURE__*/_interopDefault(axios);
+const defaultsDeep__default = /*#__PURE__*/_interopDefault(defaultsDeep);
+const styled__default = /*#__PURE__*/_interopDefault(styled);
+const get__default = /*#__PURE__*/_interopDefault(get);
+const set__default = /*#__PURE__*/_interopDefault(set);
+const ContextSelector__namespace = /*#__PURE__*/_interopNamespace(ContextSelector);
+const qs__default = /*#__PURE__*/_interopDefault(qs);
+const pipe__default = /*#__PURE__*/_interopDefault(pipe);
+const clone__default = /*#__PURE__*/_interopDefault(clone);
+const toPath__default = /*#__PURE__*/_interopDefault(toPath);
+const yup__namespace = /*#__PURE__*/_interopNamespace(yup);
+
+function createContext(rootComponentName, defaultContext) {
+  const Context = ContextSelector__namespace.createContext(defaultContext);
+  const Provider = (props) => {
+    const { children, ...context } = props;
+    const value = React__namespace.useMemo(() => context, Object.values(context));
+    return /* @__PURE__ */ jsxRuntime.jsx(Context.Provider, { value, children });
+  };
+  const useContext = (consumerName, selector) => ContextSelector__namespace.useContextSelector(Context, (ctx) => {
+    if (ctx)
+      return selector(ctx);
+    throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
+  });
+  Provider.displayName = rootComponentName + "Provider";
+  return [Provider, useContext];
+}
+
+const useTypedDispatch = reactRedux.useDispatch;
+const useTypedStore = reactRedux.useStore;
+const useTypedSelector = reactRedux.useSelector;
+const createTypedSelector = (selector) => toolkit.createSelector((state) => state, selector);
+
+const THEME_LOCAL_STORAGE_KEY = "STRAPI_THEME";
+const LANGUAGE_LOCAL_STORAGE_KEY = "strapi-admin-language";
+const adminSlice = toolkit.createSlice({
+  name: "admin",
+  initialState: () => {
+    return {
+      language: {
+        locale: "en",
+        localeNames: { en: "English" }
+      },
+      permissions: {},
+      theme: {
+        availableThemes: [],
+        currentTheme: localStorage.getItem(THEME_LOCAL_STORAGE_KEY) || "system"
+      }
+    };
+  },
+  reducers: {
+    setAppTheme(state, action) {
+      state.theme.currentTheme = action.payload;
+      window.localStorage.setItem(THEME_LOCAL_STORAGE_KEY, action.payload);
+    },
+    setAvailableThemes(state, action) {
+      state.theme.availableThemes = action.payload;
+    },
+    setLocale(state, action) {
+      state.language.locale = action.payload;
+      window.localStorage.setItem(LANGUAGE_LOCAL_STORAGE_KEY, action.payload);
+      document.documentElement.setAttribute("lang", action.payload);
+    }
+  }
+});
+const reducer$5 = adminSlice.reducer;
+const { setAppTheme, setAvailableThemes, setLocale } = adminSlice.actions;
+
+const fetchClient = () => {
+  const instance2 = axios__default.default.create({
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    },
+    paramsSerializer: (params) => {
+      return qs__default.default.stringify(params, { encode: false });
+    }
+  });
+  instance2.interceptors.request.use(
+    async (config) => {
+      config.headers.Authorization = `Bearer ${getToken()}`;
+      return config;
+    },
+    (error) => Promise.reject(error)
+  );
+  instance2.interceptors.response.use(
+    (response) => response,
+    (error) => {
+      if (error?.response?.status === 401) {
+        clearItem(STORAGE_KEYS.TOKEN);
+        clearItem(STORAGE_KEYS.USER);
+        window.location.reload();
+      }
+      throw error;
+    }
+  );
+  return instance2;
+};
+const clearItem = (key) => {
+  if (window.localStorage.getItem(key)) {
+    return window.localStorage.removeItem(key);
+  }
+  if (window.sessionStorage.getItem(key)) {
+    return window.sessionStorage.removeItem(key);
+  }
+};
+const getToken = () => JSON.parse(
+  localStorage.getItem(STORAGE_KEYS.TOKEN) ?? sessionStorage.getItem(STORAGE_KEYS.TOKEN) ?? '""'
+);
+const instance = fetchClient();
+const addPrependingSlash = (url) => url.charAt(0) !== "/" ? `/${url}` : url;
+const hasProtocol = (url) => new RegExp("^(?:[a-z+]+:)?//", "i").test(url);
+const normalizeUrl = (url) => hasProtocol(url) ? url : addPrependingSlash(url);
+const getFetchClient = (defaultOptions = {}) => {
+  instance.defaults.baseURL = window.strapi.backendURL;
+  return {
+    get: (url, config) => instance.get(normalizeUrl(url), {
+      ...defaultOptions,
+      ...config
+    }),
+    put: (url, data, config) => instance.put(normalizeUrl(url), data, { ...defaultOptions, ...config }),
+    post: (url, data, config) => instance.post(normalizeUrl(url), data, { ...defaultOptions, ...config }),
+    del: (url, config) => instance.delete(normalizeUrl(url), { ...defaultOptions, ...config })
+  };
+};
+
+const axiosBaseQuery = () => async (query, { signal }) => {
+  try {
+    const { get, post, del, put } = getFetchClient();
+    if (typeof query === "string") {
+      const result = await get(query, { signal });
+      return { data: result.data };
+    } else {
+      const { url, method = "GET", data, config } = query;
+      if (method === "POST") {
+        const result2 = await post(url, data, { ...config, signal });
+        return { data: result2.data };
+      }
+      if (method === "DELETE") {
+        const result2 = await del(url, { ...config, signal });
+        return { data: result2.data };
+      }
+      if (method === "PUT") {
+        const result2 = await put(url, data, { ...config, signal });
+        return { data: result2.data };
+      }
+      const result = await get(url, { ...config, signal });
+      return { data: result.data };
+    }
+  } catch (err) {
+    if (axios.isAxiosError(err)) {
+      if (typeof err.response?.data === "object" && err.response?.data !== null && "error" in err.response?.data) {
+        return { data: void 0, error: err.response?.data.error };
+      } else {
+        return {
+          data: void 0,
+          error: {
+            name: "UnknownError",
+            message: "There was an unknown error response from the API",
+            details: err.response?.data,
+            status: err.response?.status
+          }
+        };
+      }
+    }
+    const error = err;
+    return {
+      data: void 0,
+      error: {
+        name: error.name,
+        message: error.message,
+        stack: error.stack
+      }
+    };
+  }
+};
+const isBaseQueryError = (error) => {
+  return error.name !== void 0;
+};
+
+const adminApi = react.createApi({
+  reducerPath: "adminApi",
+  baseQuery: axiosBaseQuery(),
+  tagTypes: [
+    "ApiToken",
+    "LicenseLimits",
+    "Me",
+    "ProjectSettings",
+    "ProvidersOptions",
+    "ReviewWorkflow",
+    "ReviewWorkflowStage",
+    "Role",
+    "RolePermissions",
+    "TransferToken",
+    "User",
+    "Webhook"
+  ],
+  endpoints: (builder) => ({
+    /**
+     * This is here because it's shared between the transfer-token routes & the api-tokens.
+     */
+    regenerateToken: builder.mutation({
+      query: (url) => ({
+        method: "POST",
+        url: `${url}/regenerate`
+      }),
+      transformResponse: (response) => response.data
+    })
+  })
+});
+const { useRegenerateTokenMutation } = adminApi;
+
+const authService = adminApi.injectEndpoints({
+  endpoints: (builder) => ({
+    /**
+     * ME
+     */
+    getMe: builder.query({
+      query: () => ({
+        method: "GET",
+        url: "/admin/users/me"
+      }),
+      transformResponse(res) {
+        return res.data;
+      },
+      providesTags: (res) => res ? ["Me", { type: "User", id: res.id }] : ["Me"]
+    }),
+    getMyPermissions: builder.query({
+      query: () => ({
+        method: "GET",
+        url: "/admin/users/me/permissions"
+      }),
+      transformResponse(res) {
+        return res.data;
+      }
+    }),
+    updateMe: builder.mutation({
+      query: (body) => ({
+        method: "PUT",
+        url: "/admin/users/me",
+        data: body
+      }),
+      transformResponse(res) {
+        return res.data;
+      },
+      invalidatesTags: ["Me"]
+    }),
+    /**
+     * Permissions
+     */
+    checkPermissions: builder.query({
+      query: (permissions) => ({
+        method: "POST",
+        url: "/admin/permissions/check",
+        data: permissions
+      })
+    }),
+    /**
+     * Auth methods
+     */
+    login: builder.mutation({
+      query: (body) => ({
+        method: "POST",
+        url: "/admin/login",
+        data: body
+      }),
+      transformResponse(res) {
+        return res.data;
+      },
+      invalidatesTags: ["Me"]
+    }),
+    logout: builder.mutation({
+      query: () => ({
+        method: "POST",
+        url: "/admin/logout"
+      })
+    }),
+    resetPassword: builder.mutation({
+      query: (body) => ({
+        method: "POST",
+        url: "/admin/reset-password",
+        data: body
+      }),
+      transformResponse(res) {
+        return res.data;
+      }
+    }),
+    renewToken: builder.mutation({
+      query: (body) => ({
+        method: "POST",
+        url: "/admin/renew-token",
+        data: body
+      }),
+      transformResponse(res) {
+        return res.data;
+      }
+    }),
+    getRegistrationInfo: builder.query({
+      query: (registrationToken) => ({
+        url: "/admin/registration-info",
+        method: "GET",
+        config: {
+          params: {
+            registrationToken
+          }
+        }
+      }),
+      transformResponse(res) {
+        return res.data;
+      }
+    }),
+    registerAdmin: builder.mutation({
+      query: (body) => ({
+        method: "POST",
+        url: "/admin/register-admin",
+        data: body
+      }),
+      transformResponse(res) {
+        return res.data;
+      }
+    }),
+    registerUser: builder.mutation({
+      query: (body) => ({
+        method: "POST",
+        url: "/admin/register",
+        data: body
+      }),
+      transformResponse(res) {
+        return res.data;
+      }
+    }),
+    forgotPassword: builder.mutation({
+      query: (body) => ({
+        url: "/admin/forgot-password",
+        method: "POST",
+        data: body
+      })
+    }),
+    isSSOLocked: builder.query({
+      query: () => ({
+        url: "/admin/providers/isSSOLocked",
+        method: "GET"
+      }),
+      transformResponse(res) {
+        return res.data;
+      }
+    }),
+    getProviders: builder.query({
+      query: () => ({
+        url: "/admin/providers",
+        method: "GET"
+      })
+    }),
+    getProviderOptions: builder.query({
+      query: () => ({
+        url: "/admin/providers/options",
+        method: "GET"
+      }),
+      transformResponse(res) {
+        return res.data;
+      },
+      providesTags: ["ProvidersOptions"]
+    }),
+    updateProviderOptions: builder.mutation({
+      query: (body) => ({
+        url: "/admin/providers/options",
+        method: "PUT",
+        data: body
+      }),
+      transformResponse(res) {
+        return res.data;
+      },
+      invalidatesTags: ["ProvidersOptions"]
+    })
+  }),
+  overrideExisting: false
+});
+const {
+  useCheckPermissionsQuery,
+  useLazyCheckPermissionsQuery,
+  useGetMeQuery,
+  useLoginMutation,
+  useRenewTokenMutation,
+  useLogoutMutation,
+  useUpdateMeMutation,
+  useResetPasswordMutation,
+  useRegisterAdminMutation,
+  useRegisterUserMutation,
+  useGetRegistrationInfoQuery,
+  useForgotPasswordMutation,
+  useGetMyPermissionsQuery,
+  useIsSSOLockedQuery,
+  useGetProvidersQuery,
+  useGetProviderOptionsQuery,
+  useUpdateProviderOptionsMutation
+} = authService;
+
+const [Provider, useAuth] = createContext("Auth");
+const STORAGE_KEYS = {
+  TOKEN: "jwtToken",
+  USER: "userInfo"
+};
+const AuthProvider = ({ children, _defaultPermissions = [] }) => {
+  const dispatch = useTypedDispatch();
+  const [token, setToken] = React__namespace.useState(() => {
+    const token2 = localStorage.getItem(STORAGE_KEYS.TOKEN) ?? sessionStorage.getItem(STORAGE_KEYS.TOKEN);
+    if (typeof token2 === "string") {
+      return JSON.parse(token2);
+    }
+    return null;
+  });
+  const { data: user } = useGetMeQuery(void 0, {
+    /**
+     * If there's no token, we don't try to fetch
+     * the user data because it will fail.
+     */
+    skip: !token
+  });
+  const {
+    data: userPermissions = _defaultPermissions,
+    refetch,
+    isUninitialized
+  } = useGetMyPermissionsQuery(void 0, {
+    skip: !token
+  });
+  const navigate = reactRouterDom.useNavigate();
+  const [loginMutation] = useLoginMutation();
+  const [renewTokenMutation] = useRenewTokenMutation();
+  const [logoutMutation] = useLogoutMutation();
+  const clearStorage = React__namespace.useCallback(() => {
+    localStorage.removeItem(STORAGE_KEYS.TOKEN);
+    localStorage.removeItem(STORAGE_KEYS.USER);
+    sessionStorage.removeItem(STORAGE_KEYS.TOKEN);
+    sessionStorage.removeItem(STORAGE_KEYS.USER);
+    setToken(null);
+  }, []);
+  React__namespace.useEffect(() => {
+    const token2 = localStorage.getItem(STORAGE_KEYS.TOKEN) ?? sessionStorage.getItem(STORAGE_KEYS.TOKEN);
+    if (token2) {
+      renewTokenMutation({ token: JSON.parse(token2) }).then((res) => {
+        if ("data" in res) {
+          setToken(res.data.token);
+        } else {
+          clearStorage();
+          navigate("/auth/login");
+        }
+      });
+    }
+  }, [renewTokenMutation, clearStorage, navigate]);
+  React__namespace.useEffect(() => {
+    if (user) {
+      if (user.preferedLanguage) {
+        dispatch(setLocale(user.preferedLanguage));
+      }
+    }
+  }, [dispatch, user]);
+  React__namespace.useEffect(() => {
+    if (token) {
+      storeToken(token, false);
+    }
+  }, [token]);
+  React__namespace.useEffect(() => {
+    const handleUserStorageChange = (event) => {
+      if (event.key === STORAGE_KEYS.USER && event.newValue === null) {
+        clearStorage();
+        navigate("/auth/login");
+      }
+    };
+    window.addEventListener("storage", handleUserStorageChange);
+    return () => {
+      window.removeEventListener("storage", handleUserStorageChange);
+    };
+  });
+  const login = React__namespace.useCallback(
+    async ({ rememberMe, ...body }) => {
+      const res = await loginMutation(body);
+      if ("data" in res) {
+        const { token: token2 } = res.data;
+        storeToken(token2, rememberMe);
+        setToken(token2);
+      }
+      return res;
+    },
+    [loginMutation]
+  );
+  const logout = React__namespace.useCallback(async () => {
+    await logoutMutation();
+    clearStorage();
+    navigate("/auth/login");
+  }, [clearStorage, logoutMutation, navigate]);
+  const refetchPermissions = React__namespace.useCallback(async () => {
+    if (!isUninitialized) {
+      await refetch();
+    }
+  }, [isUninitialized, refetch]);
+  const [checkPermissions] = useLazyCheckPermissionsQuery();
+  const checkUserHasPermissions = React__namespace.useCallback(
+    async (permissions, passedPermissions) => {
+      if (!permissions || !permissions.length) {
+        return true;
+      }
+      const matchingPermissions = permissions.filter(
+        (permission) => (passedPermissions || userPermissions).findIndex(
+          (perm) => perm.action === permission.action && perm.subject === permission.subject
+        ) >= 0
+      );
+      const shouldCheckConditions = matchingPermissions.some(
+        (perm) => Array.isArray(perm.conditions) && perm.conditions.length > 0
+      );
+      if (!shouldCheckConditions) {
+        return matchingPermissions.length > 0;
+      }
+      const { data, error } = await checkPermissions({
+        permissions: matchingPermissions.map((perm) => ({
+          action: perm.action,
+          subject: perm.subject
+        }))
+      });
+      if (error) {
+        throw error;
+      } else {
+        return data?.data.every((v) => v === true) ?? false;
+      }
+    },
+    [checkPermissions, userPermissions]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    Provider,
+    {
+      token,
+      user,
+      login,
+      logout,
+      permissions: userPermissions,
+      checkUserHasPermissions,
+      refetchPermissions,
+      setToken,
+      children
+    }
+  );
+};
+const storeToken = (token, persist) => {
+  if (!persist) {
+    return window.sessionStorage.setItem(STORAGE_KEYS.TOKEN, JSON.stringify(token));
+  }
+  return window.localStorage.setItem(STORAGE_KEYS.TOKEN, JSON.stringify(token));
+};
+
+const NotificationsContext = React__namespace.createContext({
+  toggleNotification: () => {
+  }
+});
+const NotificationsProvider = ({ children }) => {
+  const notificationIdRef = React__namespace.useRef(0);
+  const [notifications, setNotifications] = React__namespace.useState([]);
+  const toggleNotification = React__namespace.useCallback(
+    ({ type, message, link, timeout, blockTransition, onClose, title }) => {
+      setNotifications((s) => [
+        ...s,
+        {
+          id: notificationIdRef.current++,
+          type,
+          message,
+          link,
+          timeout,
+          blockTransition,
+          onClose,
+          title
+        }
+      ]);
+    },
+    []
+  );
+  const clearNotification = React__namespace.useCallback((id) => {
+    setNotifications((s) => s.filter((n) => n.id !== id));
+  }, []);
+  const value = React__namespace.useMemo(() => ({ toggleNotification }), [toggleNotification]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(NotificationsContext.Provider, { value, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.Flex,
+      {
+        left: "50%",
+        marginLeft: "-250px",
+        position: "fixed",
+        direction: "column",
+        alignItems: "stretch",
+        gap: 2,
+        top: `${46 / 16}rem`,
+        width: `${500 / 16}rem`,
+        zIndex: 10,
+        children: notifications.map((notification) => {
+          return /* @__PURE__ */ jsxRuntime.jsx(
+            Notification,
+            {
+              ...notification,
+              clearNotification
+            },
+            notification.id
+          );
+        })
+      }
+    ),
+    children
+  ] });
+};
+const Notification = ({
+  clearNotification,
+  blockTransition = false,
+  id,
+  link,
+  message,
+  onClose,
+  timeout = 2500,
+  title,
+  type
+}) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const onCloseCallback = designSystem.useCallbackRef(onClose);
+  const handleClose = React__namespace.useCallback(() => {
+    onCloseCallback();
+    clearNotification(id);
+  }, [clearNotification, id, onCloseCallback]);
+  React__namespace.useEffect(() => {
+    if (!blockTransition) {
+      const timeoutReference = setTimeout(() => {
+        handleClose();
+      }, timeout);
+      return () => {
+        clearTimeout(timeoutReference);
+      };
+    }
+  }, [blockTransition, handleClose, timeout]);
+  let variant;
+  let alertTitle;
+  if (type === "info") {
+    variant = "default";
+    alertTitle = formatMessage({
+      id: "notification.default.title",
+      defaultMessage: "Information:"
+    });
+  } else if (type === "danger") {
+    variant = "danger";
+    alertTitle = formatMessage({
+      id: "notification.warning.title",
+      defaultMessage: "Warning:"
+    });
+  } else if (type === "warning") {
+    variant = "warning";
+    alertTitle = formatMessage({
+      id: "notification.warning.title",
+      defaultMessage: "Warning:"
+    });
+  } else {
+    variant = "success";
+    alertTitle = formatMessage({
+      id: "notification.success.title",
+      defaultMessage: "Success:"
+    });
+  }
+  if (title) {
+    alertTitle = title;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    designSystem.Alert,
+    {
+      action: link ? /* @__PURE__ */ jsxRuntime.jsx(v2.Link, { href: link.url, isExternal: true, children: link.label }) : void 0,
+      onClose: handleClose,
+      closeLabel: formatMessage({
+        id: "global.close",
+        defaultMessage: "Close"
+      }),
+      title: alertTitle,
+      variant,
+      children: message
+    }
+  );
+};
+/**
+ * @preserve
+ * @description Returns an object to interact with the notification
+ * system. The callbacks are wrapped in `useCallback` for a stable
+ * identity.
+ *
+ * @example
+ * ```tsx
+ * import { useNotification } from '@strapi/strapi/admin';
+ *
+ * const MyComponent = () => {
+ *  const { toggleNotification } = useNotification();
+ *
+ *  return <button onClick={() => toggleNotification({ message: 'Hello world!' })}>Click me</button>;
+ */
+const useNotification = () => React__namespace.useContext(NotificationsContext);
+
+function getPrefixedId(message, callback) {
+  const prefixedMessage = `apiError.${message}`;
+  if (typeof callback === "function") {
+    return callback(prefixedMessage);
+  }
+  return prefixedMessage;
+}
+
+function normalizeError(error, { name, intlMessagePrefixCallback }) {
+  const { message } = error;
+  const normalizedError = {
+    id: getPrefixedId(message, intlMessagePrefixCallback),
+    defaultMessage: message,
+    name: error.name ?? name,
+    values: {}
+  };
+  if ("path" in error) {
+    normalizedError.values = { path: error.path.join(".") };
+  }
+  return normalizedError;
+}
+const validateErrorIsYupValidationError = (err) => typeof err.details === "object" && err.details !== null && "errors" in err.details;
+function normalizeAPIError(apiError, intlMessagePrefixCallback) {
+  const error = apiError.response?.data.error;
+  if (error) {
+    if (validateErrorIsYupValidationError(error)) {
+      return {
+        name: error.name,
+        message: error?.message || null,
+        errors: error.details.errors.map(
+          (err) => normalizeError(err, { name: error.name, intlMessagePrefixCallback })
+        )
+      };
+    }
+    return normalizeError(error, { intlMessagePrefixCallback });
+  }
+  return null;
+}
+
+function useAPIErrorHandler(intlMessagePrefixCallback) {
+  const { formatMessage } = reactIntl.useIntl();
+  const formatError = React__namespace.useCallback(
+    (error) => {
+      try {
+        const formattedErr = formatAPIError(error, { intlMessagePrefixCallback, formatMessage });
+        if (!formattedErr) {
+          return formatAxiosError(error, { intlMessagePrefixCallback, formatMessage });
+        }
+        return formattedErr;
+      } catch (_) {
+        throw new Error("formatAPIError: Unknown error:", error);
+      }
+    },
+    [formatMessage, intlMessagePrefixCallback]
+  );
+  return {
+    /**
+     * @alpha
+     * Convert ValidationErrors from the API into an object that can be used by forms.
+     */
+    _unstableFormatValidationErrors: React__namespace.useCallback(
+      (error) => {
+        if (typeof error.details === "object" && error.details !== null) {
+          if ("errors" in error.details && Array.isArray(error.details.errors)) {
+            const validationErrors = error.details.errors;
+            return validationErrors.reduce((acc, err) => {
+              const { path, message } = err;
+              return {
+                ...acc,
+                [path.join(".")]: message
+              };
+            }, {});
+          } else {
+            const details = error.details;
+            return Object.keys(details).reduce((acc, key) => {
+              const messages = details[key];
+              return {
+                ...acc,
+                [key]: messages.join(", ")
+              };
+            }, {});
+          }
+        } else {
+          return {};
+        }
+      },
+      []
+    ),
+    /**
+     * @alpha
+     * This handles the errors given from `redux-toolkit`'s axios based baseQuery function.
+     */
+    _unstableFormatAPIError: React__namespace.useCallback(
+      (error) => {
+        const err = {
+          response: {
+            data: {
+              error
+            }
+          }
+        };
+        if (!error.message) {
+          return "Unknown error occured.";
+        }
+        return formatError(err);
+      },
+      [formatError]
+    ),
+    formatAPIError: formatError
+  };
+}
+function formatAxiosError(error, { intlMessagePrefixCallback, formatMessage }) {
+  const { code, message } = error;
+  return formatMessage(
+    {
+      id: getPrefixedId(message, intlMessagePrefixCallback),
+      defaultMessage: message
+    },
+    {
+      code
+    }
+  );
+}
+function formatAPIError(error, { formatMessage, intlMessagePrefixCallback }) {
+  if (!formatMessage) {
+    throw new Error("The formatMessage callback is a mandatory argument.");
+  }
+  const normalizedError = normalizeAPIError(error, intlMessagePrefixCallback);
+  if (!normalizedError) {
+    return null;
+  }
+  if ("message" in normalizedError && normalizedError.message !== null) {
+    return normalizedError.message;
+  }
+  if ("errors" in normalizedError) {
+    return normalizedError.errors.map(({ id, defaultMessage, values }) => formatMessage({ id, defaultMessage }, values)).join("\n");
+  }
+  return formatMessage(normalizedError);
+}
+
+const PageMain = ({ children, ...restProps }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(designSystem.Main, { ...restProps, children });
+};
+const Loading = ({ children = "Loading content." }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(PageMain, { height: "100vh", "aria-busy": true, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { alignItems: "center", height: "100%", justifyContent: "center", children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Loader, { children }) }) });
+};
+const Error$1 = (props) => {
+  const { formatMessage } = reactIntl.useIntl();
+  return /* @__PURE__ */ jsxRuntime.jsx(PageMain, { height: "100%", children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { alignItems: "center", height: "100%", justifyContent: "center", children: /* @__PURE__ */ jsxRuntime.jsx(
+    designSystem.EmptyStateLayout,
+    {
+      icon: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Icon, { as: Icons.ExclamationMarkCircle, width: "10rem" }),
+      content: formatMessage({
+        id: "anErrorOccurred",
+        defaultMessage: "Woops! Something went wrong. Please, try again."
+      }),
+      ...props
+    }
+  ) }) });
+};
+const NoPermissions = (props) => {
+  const { formatMessage } = reactIntl.useIntl();
+  return /* @__PURE__ */ jsxRuntime.jsx(PageMain, { height: "100%", children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { alignItems: "center", height: "100%", justifyContent: "center", children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { minWidth: "50%", children: /* @__PURE__ */ jsxRuntime.jsx(
+    designSystem.EmptyStateLayout,
+    {
+      icon: /* @__PURE__ */ jsxRuntime.jsx(Icons.EmptyPermissions, { width: "10rem" }),
+      content: formatMessage({
+        id: "app.components.EmptyStateLayout.content-permissions",
+        defaultMessage: "You don't have the permissions to access that content"
+      }),
+      ...props
+    }
+  ) }) }) });
+};
+const NoData = (props) => {
+  const { formatMessage } = reactIntl.useIntl();
+  return /* @__PURE__ */ jsxRuntime.jsx(PageMain, { height: "100%", children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { alignItems: "center", height: "100%", width: "100%", justifyContent: "center", children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { minWidth: "50%", children: /* @__PURE__ */ jsxRuntime.jsx(
+    designSystem.EmptyStateLayout,
+    {
+      icon: /* @__PURE__ */ jsxRuntime.jsx(Icons.EmptyDocuments, { width: "10rem" }),
+      content: formatMessage({
+        id: "app.components.EmptyStateLayout.content-document",
+        defaultMessage: "No content found"
+      }),
+      ...props
+    }
+  ) }) }) });
+};
+const Protect = ({ permissions = [], children }) => {
+  const userPermissions = useAuth("Protect", (state) => state.permissions);
+  const { toggleNotification } = useNotification();
+  const { _unstableFormatAPIError: formatAPIError } = useAPIErrorHandler();
+  const matchingPermissions = userPermissions.filter(
+    (permission) => permissions.findIndex(
+      (perm) => perm.action === permission.action && perm.subject === permission.subject
+    ) >= 0
+  );
+  const shouldCheckConditions = matchingPermissions.some(
+    (perm) => Array.isArray(perm.conditions) && perm.conditions.length > 0
+  );
+  const { isLoading, error, data } = useCheckPermissionsQuery(
+    {
+      permissions: matchingPermissions.map((perm) => ({
+        action: perm.action,
+        subject: perm.subject
+      }))
+    },
+    {
+      skip: !shouldCheckConditions
+    }
+  );
+  React__namespace.useEffect(() => {
+    if (error) {
+      toggleNotification({
+        type: "danger",
+        message: formatAPIError(error)
+      });
+    }
+  }, [error, formatAPIError, toggleNotification]);
+  if (isLoading) {
+    return /* @__PURE__ */ jsxRuntime.jsx(Loading, {});
+  }
+  if (error) {
+    return /* @__PURE__ */ jsxRuntime.jsx(Error$1, {});
+  }
+  const { data: permissionsData } = data || {};
+  const canAccess = shouldCheckConditions && permissionsData ? !permissionsData.includes(false) : matchingPermissions.length > 0;
+  if (!canAccess) {
+    return /* @__PURE__ */ jsxRuntime.jsx(NoPermissions, {});
+  }
+  return typeof children === "function" ? children({ permissions: matchingPermissions }) : children;
+};
+const Page = {
+  Error: Error$1,
+  Loading,
+  NoPermissions,
+  Protect,
+  NoData,
+  Main: PageMain
+};
+
+const usePrev = (value) => {
+  const ref = React.useRef();
+  React.useEffect(() => {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+};
+
+const capitalise = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+const useRBAC = (permissionsToCheck = {}, passedPermissions) => {
+  const userPermissions = useAuth("useRBAC", (state) => state.permissions);
+  const [isLoading, setIsLoading] = React.useState(true);
+  const [error, setError] = React.useState();
+  const [data, setData] = React.useState();
+  const defaultAllowedActions = React.useMemo(
+    () => Object.keys(permissionsToCheck).reduce(
+      (acc, name) => ({
+        ...acc,
+        [name]: false
+      }),
+      {}
+    ),
+    [permissionsToCheck]
+  );
+  const checkUserHasPermissions = useAuth("useRBAC", (state) => state.checkUserHasPermissions);
+  const permssionsChecked = usePrev(permissionsToCheck);
+  React.useEffect(() => {
+    if (!isEqual__default.default(permssionsChecked, permissionsToCheck)) {
+      setIsLoading(true);
+      setData(void 0);
+      setError(void 0);
+      const permissionEntries = Object.entries(permissionsToCheck);
+      for (const [name, permissions] of permissionEntries) {
+        checkUserHasPermissions(permissions, passedPermissions).then((res) => {
+          if (res) {
+            setData((s) => ({
+              ...s,
+              [name]: res
+            }));
+          }
+        }).catch((err) => {
+          setError(err);
+        }).finally(() => {
+          setIsLoading(false);
+        });
+      }
+    }
+  }, [checkUserHasPermissions, passedPermissions, permissionsToCheck, permssionsChecked]);
+  const actions = {
+    ...defaultAllowedActions,
+    ...data
+  };
+  const allowedActions = Object.entries(actions).reduce((acc, [name, allowed]) => {
+    acc[`can${capitalise(name)}`] = allowed;
+    return acc;
+  }, {});
+  return { allowedActions, isLoading: isLoading || userPermissions.length === 0, error };
+};
+
+const prefixFileUrlWithBackendUrl = (fileURL) => {
+  return !!fileURL && fileURL.startsWith("/") ? `${window.strapi.backendURL}${fileURL}` : fileURL;
+};
+
+const admin = adminApi.injectEndpoints({
+  endpoints: (builder) => ({
+    init: builder.query({
+      query: () => ({
+        url: "/admin/init",
+        method: "GET"
+      }),
+      transformResponse(res) {
+        return res.data;
+      }
+    }),
+    information: builder.query({
+      query: () => ({
+        url: "/admin/information",
+        method: "GET"
+      }),
+      transformResponse(res) {
+        return res.data;
+      }
+    }),
+    telemetryProperties: builder.query({
+      query: () => ({
+        url: "/admin/telemetry-properties",
+        method: "GET",
+        config: {
+          validateStatus: (status) => status < 500
+        }
+      }),
+      transformResponse(res) {
+        return res.data;
+      }
+    }),
+    projectSettings: builder.query({
+      query: () => ({
+        url: "/admin/project-settings",
+        method: "GET"
+      }),
+      providesTags: ["ProjectSettings"],
+      transformResponse(data) {
+        return {
+          authLogo: data.authLogo ? {
+            name: data.authLogo.name,
+            url: prefixFileUrlWithBackendUrl(data.authLogo.url)
+          } : void 0,
+          menuLogo: data.menuLogo ? {
+            name: data.menuLogo.name,
+            url: prefixFileUrlWithBackendUrl(data.menuLogo.url)
+          } : void 0
+        };
+      }
+    }),
+    updateProjectSettings: builder.mutation({
+      query: (data) => ({
+        url: "/admin/project-settings",
+        method: "POST",
+        data,
+        config: {
+          headers: {
+            "Content-Type": "multipart/form-data"
+          }
+        }
+      }),
+      invalidatesTags: ["ProjectSettings"]
+    }),
+    getPlugins: builder.query({
+      query: () => ({
+        url: "/admin/plugins",
+        method: "GET"
+      })
+    }),
+    getLicenseLimits: builder.query({
+      query: () => ({
+        url: "/admin/license-limit-information",
+        method: "GET"
+      }),
+      providesTags: ["LicenseLimits"]
+    })
+  }),
+  overrideExisting: false
+});
+const {
+  useInitQuery,
+  useTelemetryPropertiesQuery,
+  useInformationQuery,
+  useProjectSettingsQuery,
+  useUpdateProjectSettingsMutation,
+  useGetPluginsQuery,
+  useGetLicenseLimitsQuery
+} = admin;
+
+const [AppInfoProvider, useAppInfo] = createContext("AppInfo", {});
+
+const TrackingContext = React__namespace.createContext({
+  uuid: false
+});
+const TrackingProvider = ({ children }) => {
+  const token = useAuth("App", (state) => state.token);
+  const { data: initData } = useInitQuery();
+  const { uuid } = initData ?? {};
+  const { data } = useTelemetryPropertiesQuery(void 0, {
+    skip: !initData?.uuid || !token
+  });
+  React__namespace.useEffect(() => {
+    if (uuid && data) {
+      const event = "didInitializeAdministration";
+      try {
+        fetch("https://analytics.strapi.io/api/v2/track", {
+          method: "POST",
+          body: JSON.stringify({
+            // This event is anonymous
+            event,
+            userId: "",
+            eventPropeties: {},
+            groupProperties: { ...data, projectId: uuid }
+          }),
+          headers: {
+            "Content-Type": "application/json",
+            "X-Strapi-Event": event
+          }
+        });
+      } catch {
+      }
+    }
+  }, [data, uuid]);
+  const value = React__namespace.useMemo(
+    () => ({
+      uuid,
+      telemetryProperties: data
+    }),
+    [uuid, data]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(TrackingContext.Provider, { value, children });
+};
+const useTracking = () => {
+  const { uuid, telemetryProperties } = React__namespace.useContext(TrackingContext);
+  const userId = useAppInfo("useTracking", (state) => state.userId);
+  const trackUsage = React__namespace.useCallback(
+    async (event, properties) => {
+      try {
+        if (uuid && !window.strapi.telemetryDisabled) {
+          const res = await axios__default.default.post(
+            "https://analytics.strapi.io/api/v2/track",
+            {
+              event,
+              userId,
+              eventProperties: { ...properties },
+              userProperties: {},
+              groupProperties: {
+                ...telemetryProperties,
+                projectId: uuid,
+                projectType: window.strapi.projectType
+              }
+            },
+            {
+              headers: {
+                "Content-Type": "application/json",
+                "X-Strapi-Event": event
+              }
+            }
+          );
+          return res;
+        }
+      } catch (err) {
+      }
+      return null;
+    },
+    [telemetryProperties, userId, uuid]
+  );
+  return { trackUsage };
+};
+
+const [ConfigurationContextProvider, useConfiguration] = reactContext.createContext("ConfigurationContext");
+const ConfigurationProvider = ({
+  children,
+  defaultAuthLogo,
+  defaultMenuLogo,
+  showReleaseNotification = false,
+  showTutorials = false
+}) => {
+  const { trackUsage } = useTracking();
+  const { formatMessage } = reactIntl.useIntl();
+  const { toggleNotification } = useNotification();
+  const { _unstableFormatAPIError: formatAPIError } = useAPIErrorHandler();
+  const permissions = useTypedSelector(
+    (state) => state.admin_app.permissions.settings?.["project-settings"]
+  );
+  const token = useAuth("ConfigurationProvider", (state) => state.token);
+  const {
+    allowedActions: { canRead }
+  } = useRBAC(permissions);
+  const {
+    data: { authLogo: customAuthLogo, menuLogo: customMenuLogo } = {},
+    error,
+    isLoading
+  } = useInitQuery();
+  React__namespace.useEffect(() => {
+    if (error) {
+      toggleNotification({
+        type: "danger",
+        message: formatMessage({ id: "app.containers.App.notification.error.init" })
+      });
+    }
+  }, [error, formatMessage, toggleNotification]);
+  const { data, isSuccess } = useProjectSettingsQuery(void 0, {
+    skip: !token || !canRead
+  });
+  const [updateProjectSettingsMutation] = useUpdateProjectSettingsMutation();
+  const updateProjectSettings = React__namespace.useCallback(
+    async (body) => {
+      const formData = new FormData();
+      Object.entries(body).forEach(([key, value]) => {
+        if (value?.rawFile) {
+          formData.append(key, value.rawFile);
+        } else if (value === null) {
+          formData.append(key, JSON.stringify(value));
+        }
+      });
+      const res = await updateProjectSettingsMutation(formData);
+      if ("data" in res) {
+        const updatedMenuLogo = !!res.data.menuLogo && !!body.menuLogo?.rawFile;
+        const updatedAuthLogo = !!res.data.authLogo && !!body.authLogo?.rawFile;
+        if (updatedMenuLogo) {
+          trackUsage("didChangeLogo", {
+            logo: "menu"
+          });
+        }
+        if (updatedAuthLogo) {
+          trackUsage("didChangeLogo", {
+            logo: "auth"
+          });
+        }
+        toggleNotification({
+          type: "success",
+          message: formatMessage({ id: "app", defaultMessage: "Saved" })
+        });
+      } else {
+        toggleNotification({
+          type: "danger",
+          message: formatAPIError(res.error)
+        });
+      }
+    },
+    [formatAPIError, formatMessage, toggleNotification, trackUsage, updateProjectSettingsMutation]
+  );
+  if (isLoading) {
+    return /* @__PURE__ */ jsxRuntime.jsx(Page.Loading, {});
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    ConfigurationContextProvider,
+    {
+      showReleaseNotification,
+      showTutorials,
+      logos: {
+        menu: {
+          custom: isSuccess ? data?.menuLogo : {
+            url: customMenuLogo ?? ""
+          },
+          default: defaultMenuLogo
+        },
+        auth: {
+          custom: isSuccess ? data?.authLogo : {
+            url: customAuthLogo ?? ""
+          },
+          default: defaultAuthLogo
+        }
+      },
+      updateProjectSettings,
+      children
+    }
+  );
+};
+
+const [StrapiAppProvider, useStrapiApp] = createContext("StrapiApp");
+
+const GUIDED_TOUR_COMPLETED_STEPS = "GUIDED_TOUR_COMPLETED_STEPS";
+const GUIDED_TOUR_CURRENT_STEP = "GUIDED_TOUR_CURRENT_STEP";
+const GUIDED_TOUR_SKIPPED = "GUIDED_TOUR_SKIPPED";
+const [GuidedTourProviderImpl, useGuidedTour] = createContext("GuidedTour");
+const GuidedTourProvider = ({ children }) => {
+  const [{ currentStep, guidedTourState, isGuidedTourVisible, isSkipped }, dispatch] = React__namespace.useReducer(reducer$4, initialState$2, initialiseState);
+  const setCurrentStep = (step) => {
+    if (step !== null) {
+      const isStepAlreadyDone = get__default.default(guidedTourState, step);
+      const [sectionName, stepName] = step.split(".");
+      const sectionArray = Object.entries(guidedTourState[sectionName]);
+      const currentStepIndex = sectionArray.findIndex(([key]) => key === stepName);
+      const previousSteps = sectionArray.slice(0, currentStepIndex);
+      const isStepToShow = previousSteps.every(([, sectionValue]) => sectionValue);
+      if (isStepAlreadyDone || isSkipped || !isStepToShow) {
+        return null;
+      }
+    }
+    window.localStorage.setItem(GUIDED_TOUR_CURRENT_STEP, JSON.stringify(null));
+    return dispatch({
+      type: "SET_CURRENT_STEP",
+      step
+    });
+  };
+  const setGuidedTourVisibility = (value) => {
+    dispatch({
+      type: "SET_GUIDED_TOUR_VISIBILITY",
+      value
+    });
+  };
+  const setStepState = (currentStep2, value) => {
+    addCompletedStep(currentStep2);
+    dispatch({
+      type: "SET_STEP_STATE",
+      currentStep: currentStep2,
+      value
+    });
+  };
+  const startSection = (sectionName) => {
+    const sectionSteps = guidedTourState[sectionName];
+    if (sectionSteps) {
+      const guidedTourArray = Object.entries(guidedTourState);
+      const currentSectionIndex = guidedTourArray.findIndex(([key]) => key === sectionName);
+      const previousSections = guidedTourArray.slice(0, currentSectionIndex);
+      const isSectionToShow = previousSections.every(
+        ([, sectionValue]) => Object.values(sectionValue).every(Boolean)
+      );
+      const [firstStep] = Object.keys(sectionSteps);
+      const isFirstStepDone = sectionSteps[firstStep];
+      if (isSectionToShow && !currentStep && !isFirstStepDone) {
+        setCurrentStep(`${sectionName}.${firstStep}`);
+      }
+    }
+  };
+  const setSkipped = (value) => {
+    window.localStorage.setItem(GUIDED_TOUR_SKIPPED, JSON.stringify(value));
+    dispatch({
+      type: "SET_SKIPPED",
+      value
+    });
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    GuidedTourProviderImpl,
+    {
+      guidedTourState,
+      currentStep,
+      setCurrentStep,
+      setGuidedTourVisibility,
+      setSkipped,
+      setStepState,
+      startSection,
+      isGuidedTourVisible,
+      isSkipped,
+      children
+    }
+  );
+};
+const initialState$2 = {
+  currentStep: null,
+  guidedTourState: {
+    contentTypeBuilder: {
+      create: false,
+      success: false
+    },
+    contentManager: {
+      create: false,
+      success: false
+    },
+    apiTokens: {
+      create: false,
+      success: false
+    },
+    transferTokens: {
+      create: false,
+      success: false
+    }
+  },
+  isGuidedTourVisible: false,
+  isSkipped: false
+};
+const reducer$4 = (state = initialState$2, action) => immer.produce(state, (draftState) => {
+  switch (action.type) {
+    case "SET_CURRENT_STEP": {
+      draftState.currentStep = action.step;
+      break;
+    }
+    case "SET_STEP_STATE": {
+      const [section, step] = action.currentStep.split(".");
+      draftState.guidedTourState[section][step] = action.value;
+      break;
+    }
+    case "SET_SKIPPED": {
+      draftState.isSkipped = action.value;
+      break;
+    }
+    case "SET_GUIDED_TOUR_VISIBILITY": {
+      draftState.isGuidedTourVisible = action.value;
+      break;
+    }
+    default: {
+      return draftState;
+    }
+  }
+});
+const initialiseState = (initialState2) => {
+  const copyInitialState = { ...initialState2 };
+  const guidedTourLocaleStorage = JSON.parse(
+    window.localStorage.getItem(GUIDED_TOUR_COMPLETED_STEPS) ?? "[]"
+  );
+  const currentStepLocaleStorage = JSON.parse(
+    window.localStorage.getItem(GUIDED_TOUR_CURRENT_STEP) ?? "null"
+  );
+  const skippedLocaleStorage = JSON.parse(
+    window.localStorage.getItem(GUIDED_TOUR_SKIPPED) ?? "false"
+  );
+  if (Array.isArray(guidedTourLocaleStorage)) {
+    guidedTourLocaleStorage.forEach((step) => {
+      const [sectionName, stepName] = step.split(".");
+      set__default.default(copyInitialState, ["guidedTourState", sectionName, stepName], true);
+    });
+  }
+  if (currentStepLocaleStorage) {
+    const [sectionName, stepName] = currentStepLocaleStorage.split(".");
+    set__default.default(copyInitialState, ["guidedTourState", sectionName, stepName], true);
+    addCompletedStep(currentStepLocaleStorage);
+    window.localStorage.setItem(GUIDED_TOUR_CURRENT_STEP, JSON.stringify(null));
+  }
+  if (skippedLocaleStorage !== null) {
+    set__default.default(copyInitialState, "isSkipped", skippedLocaleStorage);
+  }
+  return copyInitialState;
+};
+const addCompletedStep = (completedStep) => {
+  const currentSteps = JSON.parse(window.localStorage.getItem(GUIDED_TOUR_COMPLETED_STEPS) ?? "[]");
+  if (!Array.isArray(currentSteps)) {
+    return;
+  }
+  const isAlreadyStored = currentSteps.includes(completedStep);
+  if (isAlreadyStored) {
+    return;
+  }
+  window.localStorage.setItem(
+    GUIDED_TOUR_COMPLETED_STEPS,
+    JSON.stringify([...currentSteps, completedStep])
+  );
+};
+
+const LanguageProvider = ({ children, messages }) => {
+  const locale = useTypedSelector((state) => state.admin_app.language.locale);
+  const appMessages = defaultsDeep__default.default(messages[locale], messages.en);
+  return /* @__PURE__ */ jsxRuntime.jsx(reactIntl.IntlProvider, { locale, defaultLocale: "en", messages: appMessages, textComponent: "span", children });
+};
+
+const Theme = ({ children, themes }) => {
+  const { currentTheme } = useTypedSelector((state) => state.admin_app.theme);
+  const [systemTheme, setSystemTheme] = React__namespace.useState();
+  const { locale } = reactIntl.useIntl();
+  const dispatch = reactRedux.useDispatch();
+  React__namespace.useEffect(() => {
+    const themeWatcher = window.matchMedia("(prefers-color-scheme: dark)");
+    setSystemTheme(themeWatcher.matches ? "dark" : "light");
+    const listener = (event) => {
+      setSystemTheme(event.matches ? "dark" : "light");
+    };
+    themeWatcher.addEventListener("change", listener);
+    return () => {
+      themeWatcher.removeEventListener("change", listener);
+    };
+  }, []);
+  React__namespace.useEffect(() => {
+    dispatch(setAvailableThemes(Object.keys(themes)));
+  }, [dispatch, themes]);
+  const computedThemeName = currentTheme === "system" ? systemTheme : currentTheme;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    designSystem.DesignSystemProvider,
+    {
+      locale,
+      theme: themes?.[computedThemeName || "light"],
+      children: [
+        children,
+        /* @__PURE__ */ jsxRuntime.jsx(GlobalStyle, {})
+      ]
+    }
+  );
+};
+const GlobalStyle = styled.createGlobalStyle`
+  body {
+    background: ${({ theme }) => theme.colors.neutral100};
+  }
+`;
+
+const ADMIN_PERMISSIONS_CE = {
+  contentManager: {
+    main: [],
+    collectionTypesConfigurations: [
+      {
+        action: "plugin::content-manager.collection-types.configure-view",
+        subject: null
+      }
+    ],
+    componentsConfigurations: [
+      {
+        action: "plugin::content-manager.components.configure-layout",
+        subject: null
+      }
+    ],
+    singleTypesConfigurations: [
+      {
+        action: "plugin::content-manager.single-types.configure-view",
+        subject: null
+      }
+    ]
+  },
+  marketplace: {
+    main: [{ action: "admin::marketplace.read", subject: null }],
+    read: [{ action: "admin::marketplace.read", subject: null }]
+  },
+  settings: {
+    roles: {
+      main: [
+        { action: "admin::roles.create", subject: null },
+        { action: "admin::roles.update", subject: null },
+        { action: "admin::roles.read", subject: null },
+        { action: "admin::roles.delete", subject: null }
+      ],
+      create: [{ action: "admin::roles.create", subject: null }],
+      delete: [{ action: "admin::roles.delete", subject: null }],
+      read: [{ action: "admin::roles.read", subject: null }],
+      update: [{ action: "admin::roles.update", subject: null }]
+    },
+    users: {
+      main: [
+        { action: "admin::users.create", subject: null },
+        { action: "admin::users.read", subject: null },
+        { action: "admin::users.update", subject: null },
+        { action: "admin::users.delete", subject: null }
+      ],
+      create: [{ action: "admin::users.create", subject: null }],
+      delete: [{ action: "admin::users.delete", subject: null }],
+      read: [{ action: "admin::users.read", subject: null }],
+      update: [{ action: "admin::users.update", subject: null }]
+    },
+    webhooks: {
+      main: [
+        { action: "admin::webhooks.create", subject: null },
+        { action: "admin::webhooks.read", subject: null },
+        { action: "admin::webhooks.update", subject: null },
+        { action: "admin::webhooks.delete", subject: null }
+      ],
+      create: [{ action: "admin::webhooks.create", subject: null }],
+      delete: [{ action: "admin::webhooks.delete", subject: null }],
+      read: [
+        { action: "admin::webhooks.read", subject: null },
+        // NOTE: We need to check with the API
+        { action: "admin::webhooks.update", subject: null },
+        { action: "admin::webhooks.delete", subject: null }
+      ],
+      update: [{ action: "admin::webhooks.update", subject: null }]
+    },
+    "api-tokens": {
+      main: [{ action: "admin::api-tokens.access", subject: null }],
+      create: [{ action: "admin::api-tokens.create", subject: null }],
+      delete: [{ action: "admin::api-tokens.delete", subject: null }],
+      read: [{ action: "admin::api-tokens.read", subject: null }],
+      update: [{ action: "admin::api-tokens.update", subject: null }],
+      regenerate: [{ action: "admin::api-tokens.regenerate", subject: null }]
+    },
+    "transfer-tokens": {
+      main: [{ action: "admin::transfer.tokens.access", subject: null }],
+      create: [{ action: "admin::transfer.tokens.create", subject: null }],
+      delete: [{ action: "admin::transfer.tokens.delete", subject: null }],
+      read: [{ action: "admin::transfer.tokens.read", subject: null }],
+      update: [{ action: "admin::transfer.tokens.update", subject: null }],
+      regenerate: [{ action: "admin::transfer.tokens.regenerate", subject: null }]
+    },
+    "project-settings": {
+      read: [{ action: "admin::project-settings.read", subject: null }],
+      update: [{ action: "admin::project-settings.update", subject: null }]
+    }
+  }
+};
+const HOOKS = {
+  /**
+   * Hook that allows to mutate the displayed headers of the list view table
+   * @constant
+   * @type {string}
+   */
+  INJECT_COLUMN_IN_TABLE: "Admin/CM/pages/ListView/inject-column-in-table",
+  /**
+   * Hook that allows to mutate the CM's collection types links pre-set filters
+   * @constant
+   * @type {string}
+   */
+  MUTATE_COLLECTION_TYPES_LINKS: "Admin/CM/pages/App/mutate-collection-types-links",
+  /**
+   * Hook that allows to mutate the CM's edit view layout
+   * @constant
+   * @type {string}
+   */
+  MUTATE_EDIT_VIEW_LAYOUT: "Admin/CM/pages/EditView/mutate-edit-view-layout",
+  /**
+   * Hook that allows to mutate the CM's single types links pre-set filters
+   * @constant
+   * @type {string}
+   */
+  MUTATE_SINGLE_TYPES_LINKS: "Admin/CM/pages/App/mutate-single-types-links"
+};
+const SETTINGS_LINKS_CE = () => ({
+  global: [
+    {
+      intlLabel: { id: "Settings.application.title", defaultMessage: "Overview" },
+      to: "/settings/application-infos",
+      id: "000-application-infos"
+    },
+    {
+      intlLabel: { id: "Settings.webhooks.title", defaultMessage: "Webhooks" },
+      to: "/settings/webhooks",
+      id: "webhooks"
+    },
+    {
+      intlLabel: { id: "Settings.apiTokens.title", defaultMessage: "API Tokens" },
+      to: "/settings/api-tokens?sort=name:ASC",
+      id: "api-tokens"
+    },
+    {
+      intlLabel: { id: "Settings.transferTokens.title", defaultMessage: "Transfer Tokens" },
+      to: "/settings/transfer-tokens?sort=name:ASC",
+      id: "transfer-tokens"
+    },
+    // If the Enterprise feature is not enabled and if the config doesn't disable it, we promote the Enterprise feature by displaying them in the settings menu.
+    // Disable this by adding "promoteEE: false" to your `./config/admin.js` file
+    ...!window.strapi.features.isEnabled(window.strapi.features.SSO) && window.strapi?.flags?.promoteEE ? [
+      {
+        intlLabel: { id: "Settings.sso.title", defaultMessage: "Single Sign-On" },
+        to: "/settings/purchase-single-sign-on",
+        id: "sso",
+        lockIcon: true
+      }
+    ] : [],
+    ...!window.strapi.features.isEnabled(window.strapi.features.REVIEW_WORKFLOWS) && window.strapi?.flags?.promoteEE ? [
+      {
+        intlLabel: {
+          id: "Settings.review-workflows.page.title",
+          defaultMessage: "Review Workflows"
+        },
+        to: "/settings/purchase-review-workflows",
+        id: "review-workflows",
+        lockIcon: true
+      }
+    ] : []
+  ],
+  admin: [
+    {
+      intlLabel: { id: "global.roles", defaultMessage: "Roles" },
+      to: "/settings/roles",
+      id: "roles"
+    },
+    {
+      intlLabel: { id: "global.users", defaultMessage: "Users" },
+      // Init the search params directly
+      to: "/settings/users?pageSize=10&page=1&sort=firstname",
+      id: "users"
+    },
+    ...!window.strapi.features.isEnabled(window.strapi.features.AUDIT_LOGS) && window.strapi?.flags?.promoteEE ? [
+      {
+        intlLabel: { id: "global.auditLogs", defaultMessage: "Audit Logs" },
+        to: "/settings/purchase-audit-logs",
+        id: "auditLogs",
+        lockIcon: true
+      }
+    ] : []
+  ]
+});
+
+const SINGLE_TYPES = "single-types";
+const COLLECTION_TYPES = "collection-types";
+
+const routes = [
+  {
+    path: ":collectionType/:slug/:id/history",
+    lazy: async () => {
+      const { ProtectedHistoryPage } = await Promise.resolve().then(() => require('./History-eZH2Aqa1.js'));
+      return {
+        Component: ProtectedHistoryPage
+      };
+    }
+  },
+  {
+    path: ":collectionType/:slug/history",
+    lazy: async () => {
+      const { ProtectedHistoryPage } = await Promise.resolve().then(() => require('./History-eZH2Aqa1.js'));
+      return {
+        Component: ProtectedHistoryPage
+      };
+    }
+  }
+];
+function useIsHistoryRoute() {
+  const location = reactRouterDom.useLocation();
+  const historyRoutes = routes.map((route) => ({ path: `content-manager/${route.path}` }));
+  const matches = reactRouterDom.matchRoutes(historyRoutes, location);
+  return Boolean(matches);
+}
+
+const useQueryParams = (initialParams) => {
+  const { search } = reactRouterDom.useLocation();
+  const navigate = reactRouterDom.useNavigate();
+  const query = React.useMemo(() => {
+    const searchQuery = search.startsWith("?") ? search.slice(1) : search;
+    if (!search && initialParams) {
+      return initialParams;
+    }
+    return { ...initialParams, ...qs.parse(searchQuery) };
+  }, [search, initialParams]);
+  const setQuery = React.useCallback(
+    (nextParams, method = "push", replace = false) => {
+      let nextQuery = { ...query };
+      if (method === "remove") {
+        Object.keys(nextParams).forEach((key) => {
+          if (Object.prototype.hasOwnProperty.call(nextQuery, key)) {
+            delete nextQuery[key];
+          }
+        });
+      } else {
+        nextQuery = { ...query, ...nextParams };
+      }
+      navigate({ search: qs.stringify(nextQuery, { encode: false }) }, { replace });
+    },
+    [navigate, query]
+  );
+  return [{ query, rawQuery: search }, setQuery];
+};
+
+const extractValuesFromYupError = (errorType, errorParams) => {
+  if (!errorType || !errorParams) {
+    return {};
+  }
+  return {
+    [errorType]: errorParams[errorType]
+  };
+};
+const getYupInnerErrors = (error) => (error?.inner || []).reduce((acc, currentError) => {
+  if (currentError.path) {
+    acc[currentError.path.split("[").join(".").split("]").join("")] = {
+      id: currentError.message,
+      defaultMessage: currentError.message,
+      values: extractValuesFromYupError(currentError?.type, currentError?.params)
+    };
+  }
+  return acc;
+}, {});
+
+const contentManagerApi = react.createApi({
+  reducerPath: "contentManagerApi",
+  baseQuery: axiosBaseQuery(),
+  tagTypes: [
+    "ComponentConfiguration",
+    "ContentTypesConfiguration",
+    "ContentTypeSettings",
+    "Document",
+    "InitialData",
+    "HistoryVersion",
+    "Relations"
+  ],
+  endpoints: () => ({})
+});
+
+const documentApi = contentManagerApi.injectEndpoints({
+  endpoints: (builder) => ({
+    autoCloneDocument: builder.mutation({
+      query: ({ model, sourceId, query }) => ({
+        url: `/content-manager/collection-types/${model}/auto-clone/${sourceId}`,
+        method: "POST",
+        config: {
+          params: query
+        }
+      }),
+      invalidatesTags: (_result, _error, { model }) => [{ type: "Document", id: `${model}_LIST` }]
+    }),
+    cloneDocument: builder.mutation({
+      query: ({ model, sourceId, data, params }) => ({
+        url: `/content-manager/collection-types/${model}/clone/${sourceId}`,
+        method: "POST",
+        data,
+        config: {
+          params
+        }
+      }),
+      invalidatesTags: (_result, _error, { model }) => [{ type: "Document", id: `${model}_LIST` }]
+    }),
+    /**
+     * Creates a new collection-type document. This should ONLY be used for collection-types.
+     * single-types should always be using `updateDocument` since they always exist.
+     */
+    createDocument: builder.mutation({
+      query: ({ model, data, params }) => ({
+        url: `/content-manager/collection-types/${model}`,
+        method: "POST",
+        data,
+        config: {
+          params
+        }
+      }),
+      invalidatesTags: (result, _error, { model }) => [
+        { type: "Document", id: `${model}_LIST` },
+        "Relations"
+      ]
+    }),
+    deleteDocument: builder.mutation({
+      query: ({ collectionType, model, documentId, params }) => ({
+        url: `/content-manager/${collectionType}/${model}${collectionType !== SINGLE_TYPES && documentId ? `/${documentId}` : ""}`,
+        method: "DELETE",
+        config: {
+          params
+        }
+      }),
+      invalidatesTags: (_result, _error, { collectionType, model }) => [
+        { type: "Document", id: collectionType !== SINGLE_TYPES ? `${model}_LIST` : model }
+      ]
+    }),
+    deleteManyDocuments: builder.mutation({
+      query: ({ model, ...body }) => ({
+        url: `/content-manager/collection-types/${model}/actions/bulkDelete`,
+        method: "POST",
+        data: body
+      }),
+      invalidatesTags: (_res, _error, { model, documentIds }) => documentIds.map((id) => ({ type: "Document", id: `${model}_${id}` }))
+    }),
+    discardDocument: builder.mutation({
+      query: ({ collectionType, model, documentId, params }) => ({
+        url: documentId ? `/content-manager/${collectionType}/${model}/${documentId}/actions/discard` : `/content-manager/${collectionType}/${model}/actions/discard`,
+        method: "POST",
+        config: {
+          params
+        }
+      }),
+      invalidatesTags: (_result, _error, { collectionType, model, documentId }) => {
+        return [
+          {
+            type: "Document",
+            id: collectionType !== SINGLE_TYPES ? `${model}_${documentId}` : model
+          },
+          { type: "Document", id: `${model}_LIST` },
+          "Relations"
+        ];
+      }
+    }),
+    /**
+     * Gets all documents of a collection type or single type.
+     * By passing different params you can get different results e.g. only published documents or 'es' documents.
+     */
+    getAllDocuments: builder.query({
+      query: ({ model, params }) => ({
+        url: `/content-manager/collection-types/${model}`,
+        method: "GET",
+        config: {
+          params
+        }
+      }),
+      providesTags: (result, _error, arg) => {
+        return [
+          { type: "Document", id: `${arg.model}_LIST` },
+          ...result?.results.map(({ documentId }) => ({
+            type: "Document",
+            id: `${arg.model}_${documentId}`
+          })) ?? []
+        ];
+      }
+    }),
+    getDraftRelationCount: builder.query({
+      query: ({ collectionType, model, documentId, params }) => ({
+        url: documentId ? `/content-manager/${collectionType}/${model}/${documentId}/actions/countDraftRelations` : `/content-manager/${collectionType}/${model}/actions/countDraftRelations`,
+        method: "GET",
+        config: {
+          params
+        }
+      })
+    }),
+    getDocument: builder.query({
+      // @ts-expect-error – TODO: fix ts error where data unknown doesn't work with response via an assertion?
+      queryFn: async ({ collectionType, model, documentId, params }, _api, _extraOpts, baseQuery) => {
+        const res = await baseQuery({
+          url: `/content-manager/${collectionType}/${model}${documentId ? `/${documentId}` : ""}`,
+          method: "GET",
+          config: {
+            params
+          }
+        });
+        if (res.error && res.error.name === "NotFoundError" && collectionType === SINGLE_TYPES) {
+          return { data: { document: void 0 }, error: void 0 };
+        }
+        return res;
+      },
+      providesTags: (result, _error, { collectionType, model, documentId }) => {
+        return [
+          // we prefer the result's id because we don't fetch single-types with an ID.
+          {
+            type: "Document",
+            id: collectionType !== SINGLE_TYPES ? `${model}_${result && "documentId" in result ? result.documentId : documentId}` : model
+          }
+        ];
+      }
+    }),
+    getManyDraftRelationCount: builder.query({
+      query: ({ model, ...params }) => ({
+        url: `/content-manager/collection-types/${model}/actions/countManyEntriesDraftRelations`,
+        method: "GET",
+        config: {
+          params
+        }
+      }),
+      transformResponse: (response) => response.data
+    }),
+    /**
+     * This endpoint will either create or update documents at the same time as publishing.
+     */
+    publishDocument: builder.mutation({
+      query: ({ collectionType, model, documentId, params, data }) => ({
+        url: documentId ? `/content-manager/${collectionType}/${model}/${documentId}/actions/publish` : `/content-manager/${collectionType}/${model}/actions/publish`,
+        method: "POST",
+        data,
+        config: {
+          params
+        }
+      }),
+      invalidatesTags: (_result, _error, { collectionType, model, documentId }) => {
+        return [
+          {
+            type: "Document",
+            id: collectionType !== SINGLE_TYPES ? `${model}_${documentId}` : model
+          },
+          { type: "Document", id: `${model}_LIST` },
+          "Relations"
+        ];
+      }
+    }),
+    publishManyDocuments: builder.mutation({
+      query: ({ model, ...body }) => ({
+        url: `/content-manager/collection-types/${model}/actions/bulkPublish`,
+        method: "POST",
+        data: body
+      }),
+      invalidatesTags: (_res, _error, { model, documentIds }) => documentIds.map((id) => ({ type: "Document", id: `${model}_${id}` }))
+    }),
+    updateDocument: builder.mutation({
+      query: ({ collectionType, model, documentId, data, params }) => ({
+        url: `/content-manager/${collectionType}/${model}${documentId ? `/${documentId}` : ""}`,
+        method: "PUT",
+        data,
+        config: {
+          params
+        }
+      }),
+      invalidatesTags: (_result, _error, { collectionType, model, documentId }) => {
+        return [
+          {
+            type: "Document",
+            id: collectionType !== SINGLE_TYPES ? `${model}_${documentId}` : model
+          },
+          "Relations"
+        ];
+      }
+    }),
+    unpublishDocument: builder.mutation({
+      query: ({ collectionType, model, documentId, params, data }) => ({
+        url: documentId ? `/content-manager/${collectionType}/${model}/${documentId}/actions/unpublish` : `/content-manager/${collectionType}/${model}/actions/unpublish`,
+        method: "POST",
+        data,
+        config: {
+          params
+        }
+      }),
+      invalidatesTags: (_result, _error, { collectionType, model, documentId }) => {
+        return [
+          {
+            type: "Document",
+            id: collectionType !== SINGLE_TYPES ? `${model}_${documentId}` : model
+          }
+        ];
+      }
+    }),
+    unpublishManyDocuments: builder.mutation({
+      query: ({ model, ...body }) => ({
+        url: `/content-manager/collection-types/${model}/actions/bulkUnpublish`,
+        method: "POST",
+        data: body
+      }),
+      invalidatesTags: (_res, _error, { model, documentIds }) => documentIds.map((id) => ({ type: "Document", id: `${model}_${id}` }))
+    })
+  })
+});
+const {
+  useAutoCloneDocumentMutation,
+  useCloneDocumentMutation,
+  useCreateDocumentMutation,
+  useDeleteDocumentMutation,
+  useDeleteManyDocumentsMutation,
+  useDiscardDocumentMutation,
+  useGetAllDocumentsQuery,
+  useLazyGetDocumentQuery,
+  useGetDocumentQuery,
+  useLazyGetDraftRelationCountQuery,
+  useGetManyDraftRelationCountQuery,
+  usePublishDocumentMutation,
+  usePublishManyDocumentsMutation,
+  useUpdateDocumentMutation,
+  useUnpublishDocumentMutation,
+  useUnpublishManyDocumentsMutation
+} = documentApi;
+
+const buildValidParams = (query) => {
+  if (!query)
+    return query;
+  const { plugins: _, ...validQueryParams } = {
+    ...query,
+    ...Object.values(query?.plugins ?? {}).reduce(
+      (acc, current) => Object.assign(acc, current),
+      {}
+    )
+  };
+  if ("_q" in validQueryParams) {
+    validQueryParams._q = encodeURIComponent(validQueryParams._q);
+  }
+  return validQueryParams;
+};
+
+const errorsTrads = {
+  email: {
+    id: "components.Input.error.validation.email",
+    defaultMessage: "This is not a valid email."
+  },
+  json: {
+    id: "components.Input.error.validation.json",
+    defaultMessage: "This doesn't match the JSON format"
+  },
+  lowercase: {
+    id: "components.Input.error.validation.lowercase",
+    defaultMessage: "The value must be a lowercase string"
+  },
+  max: {
+    id: "components.Input.error.validation.max",
+    defaultMessage: "The value is too high (max: {max})."
+  },
+  maxLength: {
+    id: "components.Input.error.validation.maxLength",
+    defaultMessage: "The value is too long (max: {max})."
+  },
+  min: {
+    id: "components.Input.error.validation.min",
+    defaultMessage: "The value is too low (min: {min})."
+  },
+  minLength: {
+    id: "components.Input.error.validation.minLength",
+    defaultMessage: "The value is too short (min: {min})."
+  },
+  regex: {
+    id: "components.Input.error.validation.regex",
+    defaultMessage: "The value does not match the regex."
+  },
+  required: {
+    id: "components.Input.error.validation.required",
+    defaultMessage: "This value is required."
+  },
+  string: {
+    id: "components.Input.error.validation.string",
+    defaultMessage: "This is not a valid string."
+  },
+  unique: {
+    id: "components.Input.error.validation.unique",
+    defaultMessage: "This value is already used."
+  },
+  integer: {
+    id: "component.Input.error.validation.integer",
+    defaultMessage: "The value must be an integer"
+  }
+};
+
+const ID = "id";
+const CREATED_BY_ATTRIBUTE_NAME = "createdBy";
+const UPDATED_BY_ATTRIBUTE_NAME = "updatedBy";
+const CREATOR_FIELDS = [CREATED_BY_ATTRIBUTE_NAME, UPDATED_BY_ATTRIBUTE_NAME];
+const PUBLISHED_BY_ATTRIBUTE_NAME = "publishedBy";
+const CREATED_AT_ATTRIBUTE_NAME = "createdAt";
+const UPDATED_AT_ATTRIBUTE_NAME = "updatedAt";
+const PUBLISHED_AT_ATTRIBUTE_NAME = "publishedAt";
+const DOCUMENT_META_FIELDS = [
+  ID,
+  ...CREATOR_FIELDS,
+  PUBLISHED_BY_ATTRIBUTE_NAME,
+  CREATED_AT_ATTRIBUTE_NAME,
+  UPDATED_AT_ATTRIBUTE_NAME,
+  PUBLISHED_AT_ATTRIBUTE_NAME
+];
+const ATTRIBUTE_TYPES_THAT_CANNOT_BE_MAIN_FIELD = [
+  "dynamiczone",
+  "json",
+  "text",
+  "relation",
+  "component",
+  "boolean",
+  "media",
+  "password",
+  "richtext",
+  "timestamp",
+  "blocks"
+];
+
+const createYupSchema = (attributes = {}, components = {}) => {
+  const createModelSchema = (attributes2) => yup__namespace.object().shape(
+    Object.entries(attributes2).reduce((acc, [name, attribute]) => {
+      if (DOCUMENT_META_FIELDS.includes(name)) {
+        return acc;
+      }
+      const validations = [
+        addRequiredValidation,
+        addMinLengthValidation,
+        addMaxLengthValidation,
+        addMinValidation,
+        addMaxValidation,
+        addRegexValidation
+      ].map((fn) => fn(attribute));
+      const transformSchema = pipe__default.default(...validations);
+      switch (attribute.type) {
+        case "component": {
+          const { attributes: attributes3 } = components[attribute.component];
+          if (attribute.repeatable) {
+            return {
+              ...acc,
+              [name]: transformSchema(
+                yup__namespace.array().of(createModelSchema(attributes3).nullable(false))
+              )
+            };
+          } else {
+            return {
+              ...acc,
+              [name]: transformSchema(createModelSchema(attributes3))
+            };
+          }
+        }
+        case "dynamiczone":
+          return {
+            ...acc,
+            [name]: transformSchema(
+              yup__namespace.array().of(
+                yup__namespace.lazy((data) => {
+                  const { attributes: attributes3 } = components[data.__component];
+                  return yup__namespace.object().shape({
+                    __component: yup__namespace.string().required().oneOf(Object.keys(components))
+                  }).nullable(false).concat(createModelSchema(attributes3));
+                })
+              )
+            )
+          };
+        case "relation":
+          return {
+            ...acc,
+            [name]: transformSchema(
+              yup__namespace.array().of(
+                yup__namespace.object().shape({
+                  id: yup__namespace.string().required()
+                })
+              )
+            )
+          };
+        default:
+          return {
+            ...acc,
+            [name]: transformSchema(createAttributeSchema(attribute))
+          };
+      }
+    }, {})
+  ).default(null);
+  return createModelSchema(attributes);
+};
+const createAttributeSchema = (attribute) => {
+  switch (attribute.type) {
+    case "biginteger":
+      return yup__namespace.string().matches(/^-?\d*$/);
+    case "boolean":
+      return yup__namespace.boolean();
+    case "blocks":
+      return yup__namespace.mixed().test("isBlocks", errorsTrads.json, (value) => {
+        if (!value || Array.isArray(value)) {
+          return true;
+        } else {
+          return false;
+        }
+      });
+    case "decimal":
+    case "float":
+    case "integer":
+      return yup__namespace.number();
+    case "email":
+      return yup__namespace.string().email(errorsTrads.email);
+    case "enumeration":
+      return yup__namespace.string().oneOf([...attribute.enum, null]);
+    case "json":
+      return yup__namespace.mixed().test("isJSON", errorsTrads.json, (value) => {
+        if (!value || typeof value === "string" && value.length === 0) {
+          return true;
+        }
+        try {
+          JSON.parse(value);
+          return true;
+        } catch (err) {
+          return false;
+        }
+      });
+    case "password":
+    case "richtext":
+    case "string":
+    case "text":
+      return yup__namespace.string();
+    case "uid":
+      return yup__namespace.string().matches(/^[A-Za-z0-9-_.~]*$/);
+    default:
+      return yup__namespace.mixed();
+  }
+};
+const addRequiredValidation = (attribute) => (schema) => {
+  if (attribute.required) {
+    return schema.required({
+      id: errorsTrads.required.id,
+      defaultMessage: "This field is required."
+    });
+  }
+  return schema.nullable();
+};
+const addMinLengthValidation = (attribute) => (schema) => {
+  if ("minLength" in attribute && attribute.minLength && Number.isInteger(attribute.minLength) && "min" in schema) {
+    return schema.min(attribute.minLength, {
+      ...errorsTrads.minLength,
+      values: {
+        min: attribute.minLength
+      }
+    });
+  }
+  return schema;
+};
+const addMaxLengthValidation = (attribute) => (schema) => {
+  if ("maxLength" in attribute && attribute.maxLength && Number.isInteger(attribute.maxLength) && "max" in schema) {
+    return schema.max(attribute.maxLength, {
+      ...errorsTrads.maxLength,
+      values: {
+        max: attribute.maxLength
+      }
+    });
+  }
+  return schema;
+};
+const addMinValidation = (attribute) => (schema) => {
+  if ("min" in attribute) {
+    const min = toInteger(attribute.min);
+    if ("min" in schema && min) {
+      return schema.min(min, {
+        ...errorsTrads.min,
+        values: {
+          min
+        }
+      });
+    }
+  }
+  return schema;
+};
+const addMaxValidation = (attribute) => (schema) => {
+  if ("max" in attribute) {
+    const max = toInteger(attribute.max);
+    if ("max" in schema && max) {
+      return schema.max(max, {
+        ...errorsTrads.max,
+        values: {
+          max
+        }
+      });
+    }
+  }
+  return schema;
+};
+const toInteger = (val) => {
+  if (typeof val === "number" || val === void 0) {
+    return val;
+  } else {
+    const num = Number(val);
+    return isNaN(num) ? void 0 : num;
+  }
+};
+const addRegexValidation = (attribute) => (schema) => {
+  if ("regex" in attribute && attribute.regex && "matches" in schema) {
+    return schema.matches(new RegExp(attribute.regex), {
+      message: {
+        id: errorsTrads.regex.id,
+        defaultMessage: "The value does not match the defined pattern."
+      },
+      excludeEmptyString: !attribute.required
+    });
+  }
+  return schema;
+};
+
+const initApi = contentManagerApi.injectEndpoints({
+  endpoints: (builder) => ({
+    getInitialData: builder.query({
+      query: () => "/content-manager/init",
+      transformResponse: (response) => response.data,
+      providesTags: ["InitialData"]
+    })
+  })
+});
+const { useGetInitialDataQuery } = initApi;
+
+const useContentTypeSchema = (model) => {
+  const { toggleNotification } = useNotification();
+  const { _unstableFormatAPIError: formatAPIError } = useAPIErrorHandler();
+  const { components, contentType, contentTypes, error, isLoading, isFetching } = useGetInitialDataQuery(void 0, {
+    selectFromResult: (res) => {
+      const contentType2 = res.data?.contentTypes.find((ct) => ct.uid === model);
+      const componentsByKey = res.data?.components.reduce(
+        (acc, component) => {
+          acc[component.uid] = component;
+          return acc;
+        },
+        {}
+      );
+      const components2 = extractContentTypeComponents(contentType2?.attributes, componentsByKey);
+      return {
+        isLoading: res.isLoading,
+        isFetching: res.isFetching,
+        error: res.error,
+        components: Object.keys(components2).length === 0 ? void 0 : components2,
+        contentType: contentType2,
+        contentTypes: res.data?.contentTypes ?? []
+      };
+    }
+  });
+  React__namespace.useEffect(() => {
+    if (error) {
+      toggleNotification({
+        type: "danger",
+        message: formatAPIError(error)
+      });
+    }
+  }, [toggleNotification, error, formatAPIError]);
+  return {
+    // This must be memoized to avoid inifiinite re-renders where the empty object is different everytime.
+    components: React__namespace.useMemo(() => components ?? {}, [components]),
+    schema: contentType,
+    schemas: contentTypes,
+    isLoading: isLoading || isFetching
+  };
+};
+const extractContentTypeComponents = (attributes = {}, allComponents = {}) => {
+  const getComponents = (attributes2) => {
+    return attributes2.reduce((acc, attribute) => {
+      if (attribute.type === "component") {
+        const componentAttributes = Object.values(
+          allComponents[attribute.component]?.attributes ?? {}
+        );
+        acc.push(attribute.component, ...getComponents(componentAttributes));
+      } else if (attribute.type === "dynamiczone") {
+        acc.push(
+          ...attribute.components,
+          ...attribute.components.flatMap((componentUid) => {
+            const componentAttributes = Object.values(
+              allComponents[componentUid]?.attributes ?? {}
+            );
+            return getComponents(componentAttributes);
+          })
+        );
+      }
+      return acc;
+    }, []);
+  };
+  const componentUids = getComponents(Object.values(attributes));
+  const uniqueComponentUids = [...new Set(componentUids)];
+  const componentsByKey = uniqueComponentUids.reduce((acc, uid) => {
+    acc[uid] = allComponents[uid];
+    return acc;
+  }, {});
+  return componentsByKey;
+};
+
+const useDocument = (args, opts) => {
+  const { toggleNotification } = useNotification();
+  const { _unstableFormatAPIError: formatAPIError } = useAPIErrorHandler();
+  const {
+    currentData: data,
+    isLoading: isLoadingDocument,
+    isFetching: isFetchingDocument,
+    error
+  } = useGetDocumentQuery(args, opts);
+  const { components, schema, isLoading: isLoadingSchema } = useContentTypeSchema(args.model);
+  React__namespace.useEffect(() => {
+    if (error) {
+      toggleNotification({
+        type: "danger",
+        message: formatAPIError(error)
+      });
+    }
+  }, [toggleNotification, error, formatAPIError, args.collectionType]);
+  const validationSchema = React__namespace.useMemo(() => {
+    if (!schema) {
+      return null;
+    }
+    return createYupSchema(schema.attributes, components);
+  }, [schema, components]);
+  const validate = React__namespace.useCallback(
+    (document) => {
+      if (!validationSchema) {
+        throw new Error(
+          "There is no validation schema generated, this is likely due to the schema not being loaded yet."
+        );
+      }
+      try {
+        validationSchema.validateSync(document, { abortEarly: false, strict: true });
+        return null;
+      } catch (error2) {
+        if (error2 instanceof yup.ValidationError) {
+          return getYupInnerErrors(error2);
+        }
+        throw error2;
+      }
+    },
+    [validationSchema]
+  );
+  const isLoading = isLoadingDocument || isFetchingDocument || isLoadingSchema;
+  return {
+    components,
+    document: data?.data,
+    meta: data?.meta,
+    isLoading,
+    schema,
+    validate
+  };
+};
+const useDoc = () => {
+  const { id, slug, collectionType, origin } = reactRouterDom.useParams();
+  const [{ query }] = useQueryParams();
+  const params = React__namespace.useMemo(() => buildValidParams(query), [query]);
+  if (!collectionType) {
+    throw new Error("Could not find collectionType in url params");
+  }
+  if (!slug) {
+    throw new Error("Could not find model in url params");
+  }
+  return {
+    collectionType,
+    model: slug,
+    id: origin || id === "create" ? void 0 : id,
+    ...useDocument(
+      { documentId: origin || id, model: slug, collectionType, params },
+      {
+        skip: id === "create" || !origin && !id && collectionType !== SINGLE_TYPES
+      }
+    )
+  };
+};
+
+function getIn(obj, key, def, pathStartIndex = 0) {
+  const path = toPath__default.default(key);
+  while (obj && pathStartIndex < path.length) {
+    obj = obj[path[pathStartIndex++]];
+  }
+  if (pathStartIndex !== path.length && !obj) {
+    return def;
+  }
+  return obj === void 0 ? def : obj;
+}
+const isObject = (obj) => obj !== null && typeof obj === "object" && !Array.isArray(obj);
+const isInteger = (obj) => String(Math.floor(Number(obj))) === obj;
+function setIn(obj, path, value) {
+  const res = clone__default.default(obj);
+  let resVal = res;
+  let i = 0;
+  const pathArray = toPath__default.default(path);
+  for (; i < pathArray.length - 1; i++) {
+    const currentPath = pathArray[i];
+    const currentObj = getIn(obj, pathArray.slice(0, i + 1));
+    if (currentObj && (isObject(currentObj) || Array.isArray(currentObj))) {
+      resVal = resVal[currentPath] = clone__default.default(currentObj);
+    } else {
+      const nextPath = pathArray[i + 1];
+      resVal = resVal[currentPath] = isInteger(nextPath) && Number(nextPath) >= 0 ? [] : {};
+    }
+  }
+  if ((i === 0 ? obj : resVal)[pathArray[i]] === value) {
+    return obj;
+  }
+  if (value === void 0) {
+    delete resVal[pathArray[i]];
+  } else {
+    resVal[pathArray[i]] = value;
+  }
+  if (i === 0 && value === void 0) {
+    delete res[pathArray[i]];
+  }
+  return res;
+}
+
+const ERR_MSG = "The Form Component has not been initialised, ensure you are using this hook within a Form component";
+const [FormProvider, useForm] = createContext("Form", {
+  disabled: false,
+  errors: {},
+  initialValues: {},
+  isSubmitting: false,
+  modified: false,
+  addFieldRow: () => {
+    throw new Error(ERR_MSG);
+  },
+  moveFieldRow: () => {
+    throw new Error(ERR_MSG);
+  },
+  onChange: () => {
+    throw new Error(ERR_MSG);
+  },
+  removeFieldRow: () => {
+    throw new Error(ERR_MSG);
+  },
+  resetForm: () => {
+    throw new Error(ERR_MSG);
+  },
+  setErrors: () => {
+    throw new Error(ERR_MSG);
+  },
+  setValues: () => {
+    throw new Error(ERR_MSG);
+  },
+  setSubmitting: () => {
+    throw new Error(ERR_MSG);
+  },
+  validate: async () => {
+    throw new Error(ERR_MSG);
+  },
+  values: {}
+});
+const Form = React__namespace.forwardRef(
+  ({ disabled = false, method, onSubmit, ...props }, ref) => {
+    const formRef = React__namespace.useRef(null);
+    const initialValues = React__namespace.useRef(props.initialValues ?? {});
+    const [state, dispatch] = React__namespace.useReducer(reducer$3, {
+      errors: {},
+      isSubmitting: false,
+      values: props.initialValues ?? {}
+    });
+    React__namespace.useEffect(() => {
+      if (!isEqual__default.default(initialValues.current, props.initialValues)) {
+        initialValues.current = props.initialValues ?? {};
+        dispatch({
+          type: "SET_INITIAL_VALUES",
+          payload: props.initialValues ?? {}
+        });
+      }
+    }, [props.initialValues]);
+    const setErrors = React__namespace.useCallback((errors) => {
+      dispatch({
+        type: "SET_ERRORS",
+        payload: errors
+      });
+    }, []);
+    const setValues = React__namespace.useCallback((values) => {
+      dispatch({
+        type: "SET_VALUES",
+        payload: values
+      });
+    }, []);
+    React__namespace.useEffect(() => {
+      if (Object.keys(state.errors).length === 0)
+        return;
+      const ref2 = setTimeout(() => {
+        const [firstError] = formRef.current.querySelectorAll("[data-strapi-field-error]");
+        if (firstError) {
+          const errorId = firstError.getAttribute("id");
+          const formElementInError = formRef.current.querySelector(
+            `[aria-describedby="${errorId}"]`
+          );
+          if (formElementInError && formElementInError instanceof HTMLElement) {
+            formElementInError.focus();
+          }
+        }
+      });
+      return () => clearTimeout(ref2);
+    }, [state.errors]);
+    const validate = React__namespace.useCallback(
+      async (shouldSetErrors = true) => {
+        setErrors({});
+        if (!props.validationSchema) {
+          return { data: state.values };
+        }
+        try {
+          const data = await props.validationSchema.validate(state.values, { abortEarly: false });
+          return { data };
+        } catch (err) {
+          if (isErrorYupValidationError(err)) {
+            let errors = {};
+            if (err.inner) {
+              if (err.inner.length === 0) {
+                return setIn(errors, err.path, err.message);
+              }
+              for (const error of err.inner) {
+                if (!getIn(errors, error.path)) {
+                  errors = setIn(errors, error.path, error.message);
+                }
+              }
+            }
+            if (shouldSetErrors) {
+              setErrors(errors);
+            }
+            return { errors };
+          } else {
+            if (process.env.NODE_ENV !== "production") {
+              console.warn(
+                `Warning: An unhandled error was caught during validation in <Formik validationSchema />`,
+                err
+              );
+            }
+            throw err;
+          }
+        }
+      },
+      [props, setErrors, state.values]
+    );
+    const handleSubmit = async (e) => {
+      e.stopPropagation();
+      e.preventDefault();
+      if (!onSubmit) {
+        return;
+      }
+      dispatch({
+        type: "SUBMIT_ATTEMPT"
+      });
+      try {
+        const { data, errors } = await validate();
+        if (errors) {
+          setErrors(errors);
+          throw new Error("Submission failed");
+        }
+        await onSubmit(data, {
+          setErrors,
+          setValues,
+          resetForm
+        });
+        dispatch({
+          type: "SUBMIT_SUCCESS"
+        });
+      } catch (err) {
+        dispatch({
+          type: "SUBMIT_FAILURE"
+        });
+        if (err instanceof Error && err.message === "Submission failed") {
+          return;
+        }
+      }
+    };
+    const modified = React__namespace.useMemo(
+      () => !isEqual__default.default(initialValues.current, state.values),
+      [state.values]
+    );
+    const handleChange = designSystem.useCallbackRef((eventOrPath, v) => {
+      if (typeof eventOrPath === "string") {
+        dispatch({
+          type: "SET_FIELD_VALUE",
+          payload: {
+            field: eventOrPath,
+            value: v
+          }
+        });
+        return;
+      }
+      const target = eventOrPath.target || eventOrPath.currentTarget;
+      const { type, name, id, value, options, multiple } = target;
+      const field = name || id;
+      if (!field && process.env.NODE_ENV !== "production") {
+        console.warn(
+          `\`onChange\` was called with an event, but you forgot to pass a \`name\` or \`id'\` attribute to your input. The field to update cannot be determined`
+        );
+      }
+      let val;
+      if (/number|range/.test(type)) {
+        const parsed = parseFloat(value);
+        val = isNaN(parsed) ? "" : parsed;
+      } else if (/checkbox/.test(type)) {
+        val = !getIn(state.values, field);
+      } else if (options && multiple) {
+        val = Array.from(options).filter((el) => el.selected).map((el) => el.value);
+      } else {
+        val = value;
+      }
+      if (field) {
+        dispatch({
+          type: "SET_FIELD_VALUE",
+          payload: {
+            field,
+            value: val
+          }
+        });
+      }
+    });
+    const addFieldRow = React__namespace.useCallback(
+      (field, value, addAtIndex) => {
+        dispatch({
+          type: "ADD_FIELD_ROW",
+          payload: {
+            field,
+            value,
+            addAtIndex
+          }
+        });
+      },
+      []
+    );
+    const removeFieldRow = React__namespace.useCallback(
+      (field, removeAtIndex) => {
+        dispatch({
+          type: "REMOVE_FIELD_ROW",
+          payload: {
+            field,
+            removeAtIndex
+          }
+        });
+      },
+      []
+    );
+    const moveFieldRow = React__namespace.useCallback(
+      (field, fromIndex, toIndex) => {
+        dispatch({
+          type: "MOVE_FIELD_ROW",
+          payload: {
+            field,
+            fromIndex,
+            toIndex
+          }
+        });
+      },
+      []
+    );
+    const resetForm = React__namespace.useCallback(() => {
+      dispatch({
+        type: "RESET_FORM",
+        payload: {
+          errors: {},
+          isSubmitting: false,
+          values: initialValues.current
+        }
+      });
+    }, []);
+    const setSubmitting = React__namespace.useCallback((isSubmitting) => {
+      dispatch({ type: "SET_ISSUBMITTING", payload: isSubmitting });
+    }, []);
+    const composedRefs = designSystem.useComposedRefs(formRef, ref);
+    return /* @__PURE__ */ jsxRuntime.jsx("form", { ref: composedRefs, method, noValidate: true, onSubmit: handleSubmit, children: /* @__PURE__ */ jsxRuntime.jsx(
+      FormProvider,
+      {
+        disabled,
+        onChange: handleChange,
+        initialValues,
+        modified,
+        addFieldRow,
+        moveFieldRow,
+        removeFieldRow,
+        resetForm,
+        setErrors,
+        setValues,
+        setSubmitting,
+        validate,
+        ...state,
+        children: typeof props.children === "function" ? props.children({
+          modified,
+          disabled,
+          onChange: handleChange,
+          ...state,
+          resetForm
+        }) : props.children
+      }
+    ) });
+  }
+);
+const isErrorYupValidationError = (err) => typeof err === "object" && err !== null && "name" in err && typeof err.name === "string" && err.name === "ValidationError";
+const reducer$3 = (state, action) => immer.produce(state, (draft) => {
+  switch (action.type) {
+    case "SET_INITIAL_VALUES":
+      draft.values = action.payload;
+      break;
+    case "SET_VALUES":
+      draft.values = action.payload;
+      break;
+    case "SUBMIT_ATTEMPT":
+      draft.isSubmitting = true;
+      break;
+    case "SUBMIT_FAILURE":
+      draft.isSubmitting = false;
+      break;
+    case "SUBMIT_SUCCESS":
+      draft.isSubmitting = false;
+      break;
+    case "SET_FIELD_VALUE":
+      draft.values = setIn(state.values, action.payload.field, action.payload.value);
+      break;
+    case "ADD_FIELD_ROW": {
+      const currentField = getIn(state.values, action.payload.field, []);
+      let position = action.payload.addAtIndex;
+      if (position === void 0) {
+        position = currentField.length;
+      } else if (position < 0) {
+        position = 0;
+      }
+      const [key] = fractionalIndexing.generateNKeysBetween(
+        currentField.at(position - 1)?.__temp_key__,
+        currentField.at(position)?.__temp_key__,
+        1
+      );
+      draft.values = setIn(
+        state.values,
+        action.payload.field,
+        setIn(currentField, position.toString(), { ...action.payload.value, __temp_key__: key })
+      );
+      break;
+    }
+    case "MOVE_FIELD_ROW": {
+      const { field, fromIndex, toIndex } = action.payload;
+      const currentField = [...getIn(state.values, field, [])];
+      const currentRow = currentField[fromIndex];
+      const startKey = fromIndex > toIndex ? currentField[toIndex - 1]?.__temp_key__ : currentField[toIndex]?.__temp_key__;
+      const endKey = fromIndex > toIndex ? currentField[toIndex]?.__temp_key__ : currentField[toIndex + 1]?.__temp_key__;
+      const [newKey] = fractionalIndexing.generateNKeysBetween(startKey, endKey, 1);
+      currentField.splice(fromIndex, 1);
+      currentField.splice(toIndex, 0, { ...currentRow, __temp_key__: newKey });
+      draft.values = setIn(state.values, field, currentField);
+      break;
+    }
+    case "REMOVE_FIELD_ROW": {
+      const currentField = getIn(state.values, action.payload.field, []);
+      let position = action.payload.removeAtIndex;
+      if (position === void 0) {
+        position = currentField.length - 1;
+      } else if (position < 0) {
+        position = 0;
+      }
+      const newValue = setIn(currentField, position.toString(), void 0).filter(
+        (val) => val
+      );
+      draft.values = setIn(
+        state.values,
+        action.payload.field,
+        newValue.length > 0 ? newValue : void 0
+      );
+      break;
+    }
+    case "SET_ERRORS":
+      if (!isEqual__default.default(state.errors, action.payload)) {
+        draft.errors = action.payload;
+      }
+      break;
+    case "SET_ISSUBMITTING":
+      draft.isSubmitting = action.payload;
+      break;
+    case "RESET_FORM":
+      draft.values = action.payload.values;
+      draft.errors = action.payload.errors;
+      draft.isSubmitting = action.payload.isSubmitting;
+      break;
+  }
+});
+const useField = (path) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const initialValue = useForm(
+    "useField",
+    (state) => getIn(state.initialValues, path)
+  );
+  const value = useForm(
+    "useField",
+    (state) => getIn(state.values, path)
+  );
+  const handleChange = useForm("useField", (state) => state.onChange);
+  const error = useForm("useField", (state) => getIn(state.errors, path));
+  return {
+    initialValue,
+    /**
+     * Errors can be a string, or a MesaageDescriptor, so we need to handle both cases.
+     * If it's anything else, we don't return it.
+     */
+    error: isErrorMessageDescriptor(error) ? formatMessage(
+      {
+        id: error.id,
+        defaultMessage: error.defaultMessage
+      },
+      error.values
+    ) : typeof error === "string" ? error : void 0,
+    onChange: handleChange,
+    value
+  };
+};
+const isErrorMessageDescriptor = (object) => {
+  return typeof object === "object" && object !== null && "id" in object && "defaultMessage" in object;
+};
+const Blocker = () => {
+  const { formatMessage } = reactIntl.useIntl();
+  const modified = useForm("Blocker", (state) => state.modified);
+  const isSubmitting = useForm("Blocker", (state) => state.isSubmitting);
+  const blocker = reactRouterDom.useBlocker(
+    ({ currentLocation, nextLocation }) => !isSubmitting && modified && currentLocation.pathname !== nextLocation.pathname
+  );
+  if (blocker.state === "blocked") {
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      designSystem.Dialog,
+      {
+        isOpen: true,
+        title: formatMessage({
+          id: "app.components.ConfirmDialog.title",
+          defaultMessage: "Confirmation"
+        }),
+        onClose: () => blocker.reset(),
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.DialogBody, { children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", gap: 2, children: [
+            /* @__PURE__ */ jsxRuntime.jsx(designSystem.Icon, { as: Icons.ExclamationMarkCircle, width: "24px", height: "24px", color: "danger600" }),
+            /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { as: "p", variant: "omega", textAlign: "center", children: formatMessage({
+              id: "global.prompt.unsaved",
+              defaultMessage: "You have unsaved changes, are you sure you want to leave?"
+            }) })
+          ] }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            designSystem.DialogFooter,
+            {
+              startAction: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { onClick: () => blocker.reset(), variant: "tertiary", children: formatMessage({
+                id: "app.components.Button.cancel",
+                defaultMessage: "Cancel"
+              }) }),
+              endAction: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { onClick: () => blocker.proceed(), variant: "danger", children: formatMessage({
+                id: "app.components.Button.confirm",
+                defaultMessage: "Confirm"
+              }) })
+            }
+          )
+        ]
+      }
+    );
+  }
+  return null;
+};
+
+const getTranslation = (id) => `content-manager.${id}`;
+
+const DocumentStatus = ({ status = "draft", ...restProps }) => {
+  const statusVariant = status === "draft" ? "primary" : status === "published" ? "success" : "alternative";
+  return /* @__PURE__ */ jsxRuntime.jsx(designSystem.Status, { ...restProps, showBullet: false, size: "S", variant: statusVariant, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { as: "span", variant: "omega", fontWeight: "bold", children: capitalise(status) }) });
+};
+
+function getStyle(initialOffset, currentOffset, mouseOffset) {
+  if (!initialOffset || !currentOffset || !mouseOffset) {
+    return { display: "none" };
+  }
+  const { x, y } = mouseOffset;
+  return {
+    transform: `translate(${x}px, ${y}px)`
+  };
+}
+const DragLayer = ({ renderItem }) => {
+  const { itemType, isDragging, item, initialOffset, currentOffset, mouseOffset } = reactDnd.useDragLayer(
+    (monitor) => ({
+      item: monitor.getItem(),
+      itemType: monitor.getItemType(),
+      initialOffset: monitor.getInitialSourceClientOffset(),
+      currentOffset: monitor.getSourceClientOffset(),
+      isDragging: monitor.isDragging(),
+      mouseOffset: monitor.getClientOffset()
+    })
+  );
+  if (!isDragging) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    designSystem.Box,
+    {
+      height: "100%",
+      left: 0,
+      position: "fixed",
+      pointerEvents: "none",
+      top: 0,
+      zIndex: 100,
+      width: "100%",
+      children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { style: getStyle(initialOffset, currentOffset, mouseOffset), children: renderItem({ type: itemType, item }) })
+    }
+  );
+};
+
+const CardDragPreview = ({ label, isSibling = false }) => {
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    FieldContainer,
+    {
+      background: isSibling ? "neutral100" : "primary100",
+      display: "inline-flex",
+      gap: 3,
+      hasRadius: true,
+      justifyContent: "space-between",
+      isSibling,
+      "max-height": `${32 / 16}rem`,
+      maxWidth: "min-content",
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 3, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(DragButton, { alignItems: "center", cursor: "all-scroll", padding: 3, children: /* @__PURE__ */ jsxRuntime.jsx(Icons.Drag, {}) }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            TypographyMaxWidth,
+            {
+              textColor: isSibling ? void 0 : "primary600",
+              fontWeight: "bold",
+              ellipsis: true,
+              children: label
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(ActionBox, { alignItems: "center", children: /* @__PURE__ */ jsxRuntime.jsx(Icons.Pencil, {}) }),
+          /* @__PURE__ */ jsxRuntime.jsx(ActionBox, { alignItems: "center", children: /* @__PURE__ */ jsxRuntime.jsx(Icons.Cross, {}) })
+        ] })
+      ]
+    }
+  );
+};
+const ActionBox = styled__default.default(designSystem.Flex)`
+  height: ${({ theme }) => theme.spaces[7]};
+
+  &:last-child {
+    padding: 0 ${({ theme }) => theme.spaces[3]};
+  }
+`;
+const DragButton = styled__default.default(ActionBox)`
+  border-right: 1px solid ${({ theme }) => theme.colors.primary200};
+
+  svg {
+    width: ${12 / 16}rem;
+    height: ${12 / 16}rem;
+  }
+`;
+const FieldContainer = styled__default.default(designSystem.Flex)`
+  border: 1px solid
+    ${({ theme, isSibling }) => isSibling ? theme.colors.neutral150 : theme.colors.primary200};
+
+  svg {
+    width: ${10 / 16}rem;
+    height: ${10 / 16}rem;
+
+    path {
+      fill: ${({ theme, isSibling }) => isSibling ? void 0 : theme.colors.primary600};
+    }
+  }
+`;
+const TypographyMaxWidth = styled__default.default(designSystem.Typography)`
+  max-width: ${72 / 16}rem;
+`;
+
+const ComponentDragPreview = ({ displayedValue }) => {
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    designSystem.Flex,
+    {
+      background: "neutral0",
+      borderColor: "neutral200",
+      justifyContent: "space-between",
+      gap: 3,
+      padding: 3,
+      width: `${300 / 16}rem`,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(ToggleButton, { type: "button", children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 6, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            DropdownIconWrapper,
+            {
+              alignItems: "center",
+              justifyContent: "center",
+              background: "neutral200",
+              height: `${32 / 16}rem`,
+              width: `${32 / 16}rem`,
+              children: /* @__PURE__ */ jsxRuntime.jsx(Icons.CarretDown, {})
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { maxWidth: `${150 / 16}rem`, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { textColor: "neutral700", ellipsis: true, children: displayedValue }) })
+        ] }) }),
+        /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 2, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.IconButton, { "aria-label": "", borderWidth: 0, children: /* @__PURE__ */ jsxRuntime.jsx(Icons.Trash, {}) }),
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.IconButton, { "aria-label": "", borderWidth: 0, children: /* @__PURE__ */ jsxRuntime.jsx(Icons.Drag, {}) })
+        ] })
+      ]
+    }
+  );
+};
+const DropdownIconWrapper = styled__default.default(designSystem.Flex)`
+  border-radius: 50%;
+
+  svg {
+    height: ${6 / 16}rem;
+    width: ${11 / 16}rem;
+    > path {
+      fill: ${({ theme }) => theme.colors.neutral600};
+    }
+  }
+`;
+const ToggleButton = styled__default.default.button`
+  border: none;
+  background: transparent;
+  display: block;
+  width: 100%;
+  text-align: unset;
+  padding: 0;
+`;
+
+const useFocusInputField = (name) => {
+  const { search: searchString } = reactRouterDom.useLocation();
+  const search = React.useMemo(() => new URLSearchParams(searchString), [searchString]);
+  const [field, setField] = React.useState(null);
+  React.useEffect(() => {
+    if (search.has("field") && search.get("field") === name && field) {
+      if ("input" in field) {
+        field.input.current.focus();
+        field.input.current.scrollIntoView({
+          block: "center"
+        });
+      } else {
+        field.focus();
+        field.scrollIntoView({
+          block: "center"
+        });
+      }
+    }
+  }, [search, name, field]);
+  return setField;
+};
+
+const ItemTypes = {
+  COMPONENT: "component",
+  EDIT_FIELD: "editField",
+  FIELD: "field",
+  DYNAMIC_ZONE: "dynamicZone",
+  RELATION: "relation",
+  BLOCKS: "blocks"
+};
+
+const useKeyboardDragAndDrop = (active, index, { onCancel, onDropItem, onGrabItem, onMoveItem }) => {
+  const [isSelected, setIsSelected] = React__namespace.useState(false);
+  const handleMove = (movement) => {
+    if (!isSelected) {
+      return;
+    }
+    if (typeof index === "number" && onMoveItem) {
+      if (movement === "UP") {
+        onMoveItem(index - 1, index);
+      } else if (movement === "DOWN") {
+        onMoveItem(index + 1, index);
+      }
+    }
+  };
+  const handleDragClick = () => {
+    if (isSelected) {
+      if (onDropItem) {
+        onDropItem(index);
+      }
+      setIsSelected(false);
+    } else {
+      if (onGrabItem) {
+        onGrabItem(index);
+      }
+      setIsSelected(true);
+    }
+  };
+  const handleCancel = () => {
+    if (isSelected) {
+      setIsSelected(false);
+      if (onCancel) {
+        onCancel(index);
+      }
+    }
+  };
+  const handleKeyDown = (e) => {
+    if (!active) {
+      return;
+    }
+    if (e.key === "Tab" && !isSelected) {
+      return;
+    }
+    e.preventDefault();
+    switch (e.key) {
+      case " ":
+      case "Enter":
+        handleDragClick();
+        break;
+      case "Escape":
+        handleCancel();
+        break;
+      case "ArrowDown":
+      case "ArrowRight":
+        handleMove("DOWN");
+        break;
+      case "ArrowUp":
+      case "ArrowLeft":
+        handleMove("UP");
+        break;
+    }
+  };
+  return handleKeyDown;
+};
+
+const DIRECTIONS = {
+  UPWARD: "upward",
+  DOWNWARD: "downward"
+};
+const DROP_SENSITIVITY = {
+  REGULAR: "regular",
+  IMMEDIATE: "immediate"
+};
+const useDragAndDrop = (active, {
+  type = "STRAPI_DND",
+  index,
+  item,
+  onStart,
+  onEnd,
+  onGrabItem,
+  onDropItem,
+  onCancel,
+  onMoveItem,
+  dropSensitivity = DROP_SENSITIVITY.REGULAR
+}) => {
+  const objectRef = React__namespace.useRef(null);
+  const [{ handlerId, isOver }, dropRef] = reactDnd.useDrop({
+    accept: type,
+    collect(monitor) {
+      return {
+        handlerId: monitor.getHandlerId(),
+        isOver: monitor.isOver({ shallow: true })
+      };
+    },
+    drop(item2) {
+      const draggedIndex = item2.index;
+      const newIndex = index;
+      if (isOver && onDropItem) {
+        onDropItem(draggedIndex, newIndex);
+      }
+    },
+    hover(item2, monitor) {
+      if (!objectRef.current || !onMoveItem) {
+        return;
+      }
+      const dragIndex = item2.index;
+      const newIndex = index;
+      const hoverBoundingRect = objectRef.current?.getBoundingClientRect();
+      const hoverMiddleY = (hoverBoundingRect.bottom - hoverBoundingRect.top) / 2;
+      const clientOffset = monitor.getClientOffset();
+      if (!clientOffset)
+        return;
+      const hoverClientY = clientOffset && clientOffset.y - hoverBoundingRect.top;
+      if (typeof dragIndex === "number" && typeof newIndex === "number") {
+        if (dragIndex === newIndex) {
+          return;
+        }
+        if (dropSensitivity === DROP_SENSITIVITY.REGULAR) {
+          if (dragIndex < newIndex && hoverClientY < hoverMiddleY) {
+            return;
+          }
+          if (dragIndex > newIndex && hoverClientY > hoverMiddleY) {
+            return;
+          }
+        }
+        onMoveItem(newIndex, dragIndex);
+        item2.index = newIndex;
+      } else {
+        if (Array.isArray(dragIndex) && Array.isArray(newIndex)) {
+          const minLength = Math.min(dragIndex.length, newIndex.length);
+          let areEqual = true;
+          let isLessThan = false;
+          let isGreaterThan = false;
+          for (let i = 0; i < minLength; i++) {
+            if (dragIndex[i] < newIndex[i]) {
+              isLessThan = true;
+              areEqual = false;
+              break;
+            } else if (dragIndex[i] > newIndex[i]) {
+              isGreaterThan = true;
+              areEqual = false;
+              break;
+            }
+          }
+          if (areEqual && dragIndex.length === newIndex.length) {
+            return;
+          }
+          if (dropSensitivity === DROP_SENSITIVITY.REGULAR) {
+            if (isLessThan && !isGreaterThan && hoverClientY < hoverMiddleY) {
+              return;
+            }
+            if (isGreaterThan && !isLessThan && hoverClientY > hoverMiddleY) {
+              return;
+            }
+          }
+        }
+        onMoveItem(newIndex, dragIndex);
+        item2.index = newIndex;
+      }
+    }
+  });
+  const getDragDirection = (monitor) => {
+    if (monitor && monitor.isDragging() && !monitor.didDrop() && monitor.getInitialClientOffset() && monitor.getClientOffset()) {
+      const deltaY = monitor.getInitialClientOffset().y - monitor.getClientOffset().y;
+      if (deltaY > 0)
+        return DIRECTIONS.UPWARD;
+      if (deltaY < 0)
+        return DIRECTIONS.DOWNWARD;
+      return null;
+    }
+    return null;
+  };
+  const [{ isDragging, direction }, dragRef, dragPreviewRef] = reactDnd.useDrag({
+    type,
+    item() {
+      if (onStart) {
+        onStart();
+      }
+      const { width } = objectRef.current?.getBoundingClientRect() ?? {};
+      return { index, width, ...item };
+    },
+    end() {
+      if (onEnd) {
+        onEnd();
+      }
+    },
+    canDrag: active,
+    /**
+     * This is useful when the item is in a virtualized list.
+     * However, if we don't have an ID then we want the libraries
+     * defaults to take care of this.
+     */
+    isDragging: item?.id ? (monitor) => {
+      return item.id === monitor.getItem().id;
+    } : void 0,
+    collect: (monitor) => ({
+      isDragging: monitor.isDragging(),
+      initialOffset: monitor.getInitialClientOffset(),
+      currentOffset: monitor.getClientOffset(),
+      direction: getDragDirection(monitor)
+    })
+  });
+  const handleKeyDown = useKeyboardDragAndDrop(active, index, {
+    onGrabItem,
+    onDropItem,
+    onCancel,
+    onMoveItem
+  });
+  return [
+    { handlerId, isDragging, handleKeyDown, isOverDropTarget: isOver, direction },
+    objectRef,
+    dropRef,
+    dragRef,
+    dragPreviewRef
+  ];
+};
+
+const relationsApi = contentManagerApi.injectEndpoints({
+  endpoints: (build) => ({
+    getRelations: build.query({
+      query: ({ model, id, targetField, params }) => {
+        return {
+          url: `/content-manager/relations/${model}/${id}/${targetField}`,
+          method: "GET",
+          config: {
+            params
+          }
+        };
+      },
+      serializeQueryArgs: (args) => {
+        const { endpointName, queryArgs } = args;
+        return {
+          endpointName,
+          model: queryArgs.model,
+          id: queryArgs.id,
+          targetField: queryArgs.targetField,
+          locale: queryArgs.params?.locale,
+          status: queryArgs.params?.status
+        };
+      },
+      merge: (currentCache, newItems) => {
+        if (currentCache.pagination && newItems.pagination) {
+          if (currentCache.pagination.page < newItems.pagination.page) {
+            const existingIds = currentCache.results.map((item) => item.documentId);
+            const uniqueNewItems = newItems.results.filter(
+              (item) => !existingIds.includes(item.documentId)
+            );
+            currentCache.results.push(...prepareTempKeys(uniqueNewItems, currentCache.results));
+            currentCache.pagination = newItems.pagination;
+          } else if (newItems.pagination.page === 1) {
+            currentCache.results = prepareTempKeys(newItems.results);
+            currentCache.pagination = newItems.pagination;
+          }
+        }
+      },
+      forceRefetch({ currentArg, previousArg }) {
+        if (!currentArg?.params && !previousArg?.params) {
+          return false;
+        }
+        return currentArg?.params?.page !== previousArg?.params?.page || currentArg?.params?.pageSize !== previousArg?.params?.pageSize;
+      },
+      transformResponse: (response) => {
+        if ("results" in response && response.results) {
+          return {
+            ...response,
+            results: prepareTempKeys(response.results.toReversed())
+          };
+        } else {
+          return response;
+        }
+      },
+      providesTags: ["Relations"]
+    }),
+    searchRelations: build.query({
+      query: ({ model, targetField, params }) => {
+        return {
+          url: `/content-manager/relations/${model}/${targetField}`,
+          method: "GET",
+          config: {
+            params
+          }
+        };
+      },
+      serializeQueryArgs: (args) => {
+        const { endpointName, queryArgs } = args;
+        return {
+          endpointName,
+          model: queryArgs.model,
+          targetField: queryArgs.targetField,
+          _q: queryArgs.params?._q,
+          idsToOmit: queryArgs.params?.idsToOmit,
+          idsToInclude: queryArgs.params?.idsToInclude
+        };
+      },
+      merge: (currentCache, newItems) => {
+        if (currentCache.pagination && newItems.pagination) {
+          if (currentCache.pagination.page < newItems.pagination.page) {
+            const existingIds = currentCache.results.map((item) => item.documentId);
+            const uniqueNewItems = newItems.results.filter(
+              (item) => !existingIds.includes(item.documentId)
+            );
+            currentCache.results.push(...uniqueNewItems);
+            currentCache.pagination = newItems.pagination;
+          } else if (newItems.pagination.page === 1) {
+            currentCache.results = newItems.results;
+            currentCache.pagination = newItems.pagination;
+          }
+        }
+      },
+      forceRefetch({ currentArg, previousArg }) {
+        if (!currentArg?.params && !previousArg?.params) {
+          return false;
+        }
+        return currentArg?.params?.page !== previousArg?.params?.page || currentArg?.params?.pageSize !== previousArg?.params?.pageSize;
+      },
+      transformResponse: (response) => {
+        if (response.results) {
+          return {
+            ...response,
+            results: response.results
+          };
+        } else {
+          return response;
+        }
+      }
+    })
+  })
+});
+const prepareTempKeys = (relations, existingRelations = []) => {
+  const [firstItem] = existingRelations.slice(0);
+  const keys = fractionalIndexing.generateNKeysBetween(null, firstItem?.__temp_key__ ?? null, relations.length);
+  return relations.map((datum, index) => ({
+    ...datum,
+    __temp_key__: keys[index]
+  }));
+};
+const { useGetRelationsQuery, useLazySearchRelationsQuery } = relationsApi;
+
+const getRelationLabel = (relation, mainField) => {
+  const label = mainField && relation[mainField.name] ? relation[mainField.name] : null;
+  if (typeof label === "string") {
+    return label;
+  }
+  return relation.documentId;
+};
+
+const [ComponentProvider, useComponent] = createContext("ComponentContext", {
+  id: void 0,
+  level: -1,
+  uid: void 0,
+  type: void 0
+});
+
+const RELATIONS_TO_DISPLAY = 5;
+const ONE_WAY_RELATIONS = ["oneWay", "oneToOne", "manyToOne", "oneToManyMorph", "oneToOneMorph"];
+const RelationsField = React__namespace.forwardRef(
+  ({ disabled, label, ...props }, ref) => {
+    const [currentPage, setCurrentPage] = React__namespace.useState(1);
+    const { document, model: documentModel } = useDoc();
+    const documentId = document?.documentId;
+    const { formatMessage } = reactIntl.useIntl();
+    const [{ query }] = useQueryParams();
+    const params = buildValidParams(query);
+    const isMorph = props.attribute.relation.toLowerCase().includes("morph");
+    const isDisabled = isMorph || disabled;
+    const { id: componentId, uid } = useComponent("RelationsField", ({ uid: uid2, id: id2 }) => ({ id: id2, uid: uid2 }));
+    const id = componentId ? componentId.toString() : documentId;
+    const model = uid ?? documentModel;
+    const [targetField] = props.name.split(".").slice(-1);
+    const { data, isLoading, isFetching } = useGetRelationsQuery(
+      {
+        model,
+        targetField,
+        // below we don't run the query if there is no id.
+        id,
+        params: {
+          ...params,
+          pageSize: RELATIONS_TO_DISPLAY,
+          page: currentPage
+        }
+      },
+      {
+        refetchOnMountOrArgChange: true,
+        skip: !id,
+        selectFromResult: (result) => {
+          return {
+            ...result,
+            data: {
+              ...result.data,
+              results: result.data?.results ? result.data.results : []
+            }
+          };
+        }
+      }
+    );
+    const handleLoadMore = () => {
+      setCurrentPage((prev) => prev + 1);
+    };
+    const field = useField(props.name);
+    const isFetchingMoreRelations = isLoading || isFetching;
+    const realServerRelationsCount = "pagination" in data && data.pagination ? data.pagination.total : 0;
+    const relationsConnected = (field.value?.connect ?? []).filter(
+      (rel) => data.results.findIndex((relation) => relation.id === rel.id) === -1
+    ).length ?? 0;
+    const relationsDisconnected = field.value?.disconnect?.length ?? 0;
+    const relationsCount = realServerRelationsCount + relationsConnected - relationsDisconnected;
+    const relations = React__namespace.useMemo(() => {
+      const ctx = {
+        field: field.value,
+        // @ts-expect-error – targetModel does exist on the attribute. But it's not typed.
+        href: `../${COLLECTION_TYPES}/${props.attribute.targetModel}`,
+        mainField: props.mainField
+      };
+      const transformations = pipe__default.default(
+        removeConnected(ctx),
+        removeDisconnected(ctx),
+        addLabelAndHref(ctx)
+      );
+      const transformedRels = transformations([...data.results]);
+      return [...transformedRels, ...field.value?.connect ?? []].sort((a, b) => {
+        if (a.__temp_key__ < b.__temp_key__)
+          return -1;
+        if (a.__temp_key__ > b.__temp_key__)
+          return 1;
+        return 0;
+      });
+    }, [
+      data.results,
+      field.value,
+      // @ts-expect-error – targetModel does exist on the attribute. But it's not typed.
+      props.attribute.targetModel,
+      props.mainField
+    ]);
+    const handleConnect = (relation) => {
+      const [lastItemInList] = relations.slice(-1);
+      const item = {
+        id: relation.id,
+        status: relation.status,
+        /**
+         * If there's a last item, that's the first key we use to generate out next one.
+         */
+        __temp_key__: fractionalIndexing.generateNKeysBetween(lastItemInList?.__temp_key__ ?? null, null, 1)[0],
+        // Fallback to `id` if there is no `mainField` value, which will overwrite the above `id` property with the exact same data.
+        [props.mainField?.name ?? "documentId"]: relation[props.mainField?.name ?? "documentId"],
+        label: getRelationLabel(relation, props.mainField),
+        // @ts-expect-error – targetModel does exist on the attribute, but it's not typed.
+        href: `../${COLLECTION_TYPES}/${props.attribute.targetModel}/${relation.documentId}`
+      };
+      if (ONE_WAY_RELATIONS.includes(props.attribute.relation)) {
+        field.onChange(`${props.name}.connect`, [item]);
+      } else {
+        field.onChange(`${props.name}.connect`, [...field.value?.connect ?? [], item]);
+      }
+    };
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      designSystem.Flex,
+      {
+        ref,
+        direction: "column",
+        gap: 3,
+        justifyContent: "space-between",
+        alignItems: "stretch",
+        wrap: "wrap",
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(StyledFlex, { direction: "column", alignItems: "start", gap: 2, width: "100%", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              RelationsInput,
+              {
+                disabled: isDisabled,
+                id,
+                label: `${label} ${relationsCount > 0 ? `(${relationsCount})` : ""}`,
+                model,
+                onChange: handleConnect,
+                ...props
+              }
+            ),
+            "pagination" in data && data.pagination && data.pagination.pageCount > data.pagination.page ? /* @__PURE__ */ jsxRuntime.jsx(
+              designSystem.TextButton,
+              {
+                disabled: isFetchingMoreRelations,
+                onClick: handleLoadMore,
+                loading: isFetchingMoreRelations,
+                startIcon: /* @__PURE__ */ jsxRuntime.jsx(Icons.Refresh, {}),
+                shrink: 0,
+                children: formatMessage({
+                  id: getTranslation("relation.loadMore"),
+                  defaultMessage: "Load More"
+                })
+              }
+            ) : null
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            RelationsList,
+            {
+              data: relations,
+              serverData: data.results,
+              disabled: isDisabled,
+              name: props.name,
+              isLoading: isFetchingMoreRelations,
+              relationType: props.attribute.relation
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+const StyledFlex = styled__default.default(designSystem.Flex)`
+  & > div {
+    width: 100%;
+  }
+`;
+const removeConnected = ({ field }) => (relations) => {
+  return relations.filter((relation) => {
+    const connectedRelations = field?.connect ?? [];
+    return connectedRelations.findIndex((rel) => rel.id === relation.id) === -1;
+  });
+};
+const removeDisconnected = ({ field }) => (relations) => relations.filter((relation) => {
+  const disconnectedRelations = field?.disconnect ?? [];
+  return disconnectedRelations.findIndex((rel) => rel.id === relation.id) === -1;
+});
+const addLabelAndHref = ({ mainField, href }) => (relations) => relations.map((relation) => {
+  return {
+    ...relation,
+    // Fallback to `id` if there is no `mainField` value, which will overwrite the above `documentId` property with the exact same data.
+    [mainField?.name ?? "documentId"]: relation[mainField?.name ?? "documentId"],
+    label: getRelationLabel(relation, mainField),
+    href: `${href}/${relation.documentId}`
+  };
+});
+const RelationsInput = ({
+  disabled,
+  hint,
+  id,
+  label,
+  model,
+  name,
+  mainField,
+  placeholder,
+  required,
+  onChange
+}) => {
+  const [textValue, setTextValue] = React__namespace.useState("");
+  const [searchParams, setSearchParams] = React__namespace.useState({
+    _q: "",
+    page: 1
+  });
+  const { toggleNotification } = useNotification();
+  const [{ query }] = useQueryParams();
+  const { formatMessage } = reactIntl.useIntl();
+  const fieldRef = useFocusInputField(name);
+  const field = useField(name);
+  const [searchForTrigger, { data, isLoading }] = useLazySearchRelationsQuery();
+  React__namespace.useEffect(() => {
+    const [targetField] = name.split(".").slice(-1);
+    searchForTrigger({
+      model,
+      targetField,
+      params: {
+        ...buildValidParams(query),
+        id: id ?? "",
+        pageSize: 10,
+        idsToInclude: field.value?.disconnect?.map((rel) => rel.id.toString()) ?? [],
+        idsToOmit: field.value?.connect?.map((rel) => rel.id.toString()) ?? [],
+        ...searchParams
+      }
+    });
+  }, [
+    field.value?.connect,
+    field.value?.disconnect,
+    id,
+    model,
+    name,
+    query,
+    searchForTrigger,
+    searchParams
+  ]);
+  const handleSearch = async (search) => {
+    setSearchParams((s) => ({ ...s, _q: search, page: 1 }));
+  };
+  const hasNextPage = data?.pagination ? data.pagination.page < data.pagination.pageCount : false;
+  const options = data?.results ?? [];
+  const handleChange = (relationId) => {
+    if (!relationId) {
+      return;
+    }
+    const relation = options.find((opt) => opt.id.toString() === relationId);
+    if (!relation) {
+      console.error(
+        "You've tried to add a relation with an id that does not exist in the options you can see, this is likely a bug with Strapi. Please open an issue."
+      );
+      toggleNotification({
+        message: formatMessage({
+          id: getTranslation("relation.error-adding-relation"),
+          defaultMessage: "An error occurred while trying to add the relation."
+        }),
+        type: "danger"
+      });
+      return;
+    }
+    onChange(relation);
+  };
+  const handleLoadMore = () => {
+    if (!data || !data.pagination) {
+      return;
+    } else if (data.pagination.page < data.pagination.pageCount) {
+      setSearchParams((s) => ({ ...s, page: s.page + 1 }));
+    }
+  };
+  React__namespace.useLayoutEffect(() => {
+    setTextValue("");
+  }, [field.value]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    designSystem.Combobox,
+    {
+      ref: fieldRef,
+      autocomplete: "none",
+      error: field.error,
+      name,
+      hint,
+      required,
+      label,
+      disabled,
+      placeholder: placeholder || formatMessage({
+        id: getTranslation("relation.add"),
+        defaultMessage: "Add relation"
+      }),
+      hasMoreItems: hasNextPage,
+      loading: isLoading,
+      onOpenChange: () => {
+        handleSearch(textValue ?? "");
+      },
+      noOptionsMessage: () => formatMessage({
+        id: getTranslation("relation.notAvailable"),
+        defaultMessage: "No relations available"
+      }),
+      loadingMessage: formatMessage({
+        id: getTranslation("relation.isLoading"),
+        defaultMessage: "Relations are loading"
+      }),
+      onLoadMore: handleLoadMore,
+      textValue,
+      onChange: handleChange,
+      onTextValueChange: (text) => {
+        setTextValue(text);
+      },
+      onInputChange: (event) => {
+        handleSearch(event.currentTarget.value);
+      },
+      children: options.map((opt) => {
+        const textValue2 = getRelationLabel(opt, mainField);
+        return /* @__PURE__ */ jsxRuntime.jsx(designSystem.ComboboxOption, { value: opt.id.toString(), textValue: textValue2, children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 2, justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { ellipsis: true, children: textValue2 }),
+          opt.status ? /* @__PURE__ */ jsxRuntime.jsx(DocumentStatus, { status: opt.status }) : null
+        ] }) }, opt.id);
+      })
+    }
+  );
+};
+const RELATION_ITEM_HEIGHT = 50;
+const RELATION_GUTTER = 4;
+const RelationsList = ({
+  data,
+  serverData,
+  disabled,
+  name,
+  isLoading,
+  relationType
+}) => {
+  const ariaDescriptionId = React__namespace.useId();
+  const { formatMessage } = reactIntl.useIntl();
+  const listRef = React__namespace.useRef(null);
+  const outerListRef = React__namespace.useRef(null);
+  const [overflow, setOverflow] = React__namespace.useState();
+  const [liveText, setLiveText] = React__namespace.useState("");
+  const field = useField(name);
+  const removeFieldRow = useForm("RelationsList", (state) => state.removeFieldRow);
+  const addFieldRow = useForm("RelationsList", (state) => state.addFieldRow);
+  React__namespace.useEffect(() => {
+    if (data.length <= RELATIONS_TO_DISPLAY) {
+      return setOverflow(void 0);
+    }
+    const handleNativeScroll = (e) => {
+      const el = e.target;
+      const parentScrollContainerHeight = el.parentNode.scrollHeight;
+      const maxScrollBottom = el.scrollHeight - el.scrollTop;
+      if (el.scrollTop === 0) {
+        return setOverflow("bottom");
+      }
+      if (maxScrollBottom === parentScrollContainerHeight) {
+        return setOverflow("top");
+      }
+      return setOverflow("top-bottom");
+    };
+    const outerListRefCurrent = outerListRef?.current;
+    if (!isLoading && data.length > 0 && outerListRefCurrent) {
+      outerListRef.current.addEventListener("scroll", handleNativeScroll);
+    }
+    return () => {
+      if (outerListRefCurrent) {
+        outerListRefCurrent.removeEventListener("scroll", handleNativeScroll);
+      }
+    };
+  }, [isLoading, data.length]);
+  const getItemPos = (index) => `${index + 1} of ${data.length}`;
+  const handleMoveItem = (newIndex, oldIndex) => {
+    const item = data[oldIndex];
+    setLiveText(
+      formatMessage(
+        {
+          id: getTranslation("dnd.reorder"),
+          defaultMessage: "{item}, moved. New position in list: {position}."
+        },
+        {
+          item: item.label ?? item.documentId,
+          position: getItemPos(newIndex)
+        }
+      )
+    );
+    const newData = [...data];
+    const currentRow = data[oldIndex];
+    const startKey = oldIndex > newIndex ? newData[newIndex - 1]?.__temp_key__ : newData[newIndex]?.__temp_key__;
+    const endKey = oldIndex > newIndex ? newData[newIndex]?.__temp_key__ : newData[newIndex + 1]?.__temp_key__;
+    const [newKey] = fractionalIndexing.generateNKeysBetween(startKey, endKey, 1);
+    newData.splice(oldIndex, 1);
+    newData.splice(newIndex, 0, { ...currentRow, __temp_key__: newKey });
+    const connectedRelations = newData.reduce((acc, relation, currentIndex, array) => {
+      const relationOnServer = serverData.find(
+        (oldRelation) => oldRelation.documentId === relation.documentId
+      );
+      const relationInFront = array[currentIndex + 1];
+      if (!relationOnServer || relationOnServer.__temp_key__ !== relation.__temp_key__) {
+        const position = relationInFront ? {
+          before: relationInFront.documentId,
+          locale: relationInFront.locale,
+          status: relationInFront.status
+        } : { end: true };
+        const relationWithPosition = { ...relation, position };
+        return [...acc, relationWithPosition];
+      }
+      return acc;
+    }, []).toReversed();
+    field.onChange(`${name}.connect`, connectedRelations);
+  };
+  const handleGrabItem = (index) => {
+    const item = data[index];
+    setLiveText(
+      formatMessage(
+        {
+          id: getTranslation("dnd.grab-item"),
+          defaultMessage: `{item}, grabbed. Current position in list: {position}. Press up and down arrow to change position, Spacebar to drop, Escape to cancel.`
+        },
+        {
+          item: item.label ?? item.documentId,
+          position: getItemPos(index)
+        }
+      )
+    );
+  };
+  const handleDropItem = (index) => {
+    const { href: _href, label, ...item } = data[index];
+    setLiveText(
+      formatMessage(
+        {
+          id: getTranslation("dnd.drop-item"),
+          defaultMessage: `{item}, dropped. Final position in list: {position}.`
+        },
+        {
+          item: label ?? item.documentId,
+          position: getItemPos(index)
+        }
+      )
+    );
+  };
+  const handleCancel = (index) => {
+    const item = data[index];
+    setLiveText(
+      formatMessage(
+        {
+          id: getTranslation("dnd.cancel-item"),
+          defaultMessage: "{item}, dropped. Re-order cancelled."
+        },
+        {
+          item: item.label ?? item.documentId
+        }
+      )
+    );
+  };
+  const handleDisconnect = (relation) => {
+    if (field.value && field.value.connect) {
+      const indexOfRelationInConnectArray = field.value.connect.findIndex(
+        (rel) => rel.id === relation.id
+      );
+      if (indexOfRelationInConnectArray >= 0) {
+        removeFieldRow(`${name}.connect`, indexOfRelationInConnectArray);
+        return;
+      }
+    }
+    addFieldRow(`${name}.disconnect`, { id: relation.id });
+  };
+  const canReorder = !ONE_WAY_RELATIONS.includes(relationType);
+  const dynamicListHeight = data.length > RELATIONS_TO_DISPLAY ? Math.min(data.length, RELATIONS_TO_DISPLAY) * (RELATION_ITEM_HEIGHT + RELATION_GUTTER) + RELATION_ITEM_HEIGHT / 2 : Math.min(data.length, RELATIONS_TO_DISPLAY) * (RELATION_ITEM_HEIGHT + RELATION_GUTTER);
+  return /* @__PURE__ */ jsxRuntime.jsxs(ShadowBox, { overflowDirection: overflow, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.VisuallyHidden, { id: ariaDescriptionId, children: formatMessage({
+      id: getTranslation("dnd.instructions"),
+      defaultMessage: `Press spacebar to grab and re-order`
+    }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.VisuallyHidden, { "aria-live": "assertive", children: liveText }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      reactWindow.FixedSizeList,
+      {
+        height: dynamicListHeight,
+        ref: listRef,
+        outerRef: outerListRef,
+        itemCount: data.length,
+        itemSize: RELATION_ITEM_HEIGHT + RELATION_GUTTER,
+        itemData: {
+          ariaDescribedBy: ariaDescriptionId,
+          canDrag: canReorder,
+          disabled,
+          handleCancel,
+          handleDropItem,
+          handleGrabItem,
+          handleMoveItem,
+          name,
+          handleDisconnect,
+          relations: data
+        },
+        itemKey: (index) => data[index].id,
+        innerElementType: "ol",
+        children: ListItem
+      }
+    )
+  ] });
+};
+const ShadowBox = styled__default.default(designSystem.Box)`
+  position: relative;
+  overflow: hidden;
+  flex: 1;
+
+  &:before,
+  &:after {
+    position: absolute;
+    width: 100%;
+    height: 4px;
+    z-index: 1;
+  }
+
+  &:before {
+    /* TODO: as for DS Table component we would need this to be handled by the DS theme */
+    content: '';
+    background: linear-gradient(rgba(3, 3, 5, 0.2) 0%, rgba(0, 0, 0, 0) 100%);
+    top: 0;
+    opacity: ${({ overflowDirection }) => overflowDirection === "top-bottom" || overflowDirection === "top" ? 1 : 0};
+    transition: opacity 0.2s ease-in-out;
+  }
+
+  &:after {
+    /* TODO: as for DS Table component we would need this to be handled by the DS theme */
+    content: '';
+    background: linear-gradient(0deg, rgba(3, 3, 5, 0.2) 0%, rgba(0, 0, 0, 0) 100%);
+    bottom: 0;
+    opacity: ${({ overflowDirection }) => overflowDirection === "top-bottom" || overflowDirection === "bottom" ? 1 : 0};
+    transition: opacity 0.2s ease-in-out;
+  }
+`;
+const ListItem = ({ data, index, style }) => {
+  const {
+    ariaDescribedBy,
+    canDrag = false,
+    disabled = false,
+    handleCancel,
+    handleDisconnect,
+    handleDropItem,
+    handleGrabItem,
+    handleMoveItem,
+    name,
+    relations
+  } = data;
+  const { formatMessage } = reactIntl.useIntl();
+  const { href, documentId, label, status } = relations[index];
+  const [{ handlerId, isDragging, handleKeyDown }, relationRef, dropRef, dragRef, dragPreviewRef] = useDragAndDrop(
+    canDrag && !disabled,
+    {
+      type: `${ItemTypes.RELATION}_${name}`,
+      index,
+      item: {
+        displayedValue: label,
+        status,
+        id: documentId,
+        index
+      },
+      onMoveItem: handleMoveItem,
+      onDropItem: handleDropItem,
+      onGrabItem: handleGrabItem,
+      onCancel: handleCancel,
+      dropSensitivity: DROP_SENSITIVITY.REGULAR
+    }
+  );
+  const composedRefs = designSystem.useComposedRefs(relationRef, dragRef);
+  React__namespace.useEffect(() => {
+    dragPreviewRef(reactDndHtml5Backend.getEmptyImage());
+  }, [dragPreviewRef]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    designSystem.Box,
+    {
+      style,
+      as: "li",
+      ref: dropRef,
+      "aria-describedby": ariaDescribedBy,
+      cursor: canDrag ? "all-scroll" : "default",
+      children: isDragging ? /* @__PURE__ */ jsxRuntime.jsx(RelationItemPlaceholder, {}) : /* @__PURE__ */ jsxRuntime.jsxs(
+        designSystem.Flex,
+        {
+          paddingTop: 2,
+          paddingBottom: 2,
+          paddingLeft: canDrag ? 2 : 4,
+          paddingRight: 4,
+          hasRadius: true,
+          borderColor: "neutral200",
+          background: disabled ? "neutral150" : "neutral0",
+          justifyContent: "space-between",
+          ref: composedRefs,
+          "data-handler-id": handlerId,
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsxs(FlexWrapper, { gap: 1, children: [
+              canDrag ? /* @__PURE__ */ jsxRuntime.jsx(
+                designSystem.IconButton,
+                {
+                  forwardedAs: "div",
+                  role: "button",
+                  tabIndex: 0,
+                  "aria-label": formatMessage({
+                    id: getTranslation("components.RelationInput.icon-button-aria-label"),
+                    defaultMessage: "Drag"
+                  }),
+                  borderWidth: 0,
+                  onKeyDown: handleKeyDown,
+                  disabled,
+                  children: /* @__PURE__ */ jsxRuntime.jsx(Icons.Drag, {})
+                }
+              ) : null,
+              /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { width: "100%", minWidth: 0, justifyContent: "space-between", children: [
+                /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { minWidth: 0, paddingTop: 1, paddingBottom: 1, paddingRight: 4, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Tooltip, { description: label, children: href ? /* @__PURE__ */ jsxRuntime.jsx(LinkEllipsis, { forwardedAs: reactRouterDom.NavLink, to: href, children: label }) : /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { textColor: disabled ? "neutral600" : "primary600", ellipsis: true, children: label }) }) }),
+                status ? /* @__PURE__ */ jsxRuntime.jsx(DocumentStatus, { status }) : null
+              ] })
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingLeft: 4, children: /* @__PURE__ */ jsxRuntime.jsx(
+              DisconnectButton,
+              {
+                disabled,
+                type: "button",
+                onClick: () => handleDisconnect(relations[index]),
+                "aria-label": formatMessage({
+                  id: getTranslation("relation.disconnect"),
+                  defaultMessage: "Remove"
+                }),
+                children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Icon, { width: "12px", as: Icons.Cross })
+              }
+            ) })
+          ]
+        }
+      )
+    }
+  );
+};
+const FlexWrapper = styled__default.default(designSystem.Flex)`
+  width: 100%;
+  /* Used to prevent endAction to be pushed out of container */
+  min-width: 0;
+
+  & > div[role='button'] {
+    cursor: all-scroll;
+  }
+`;
+const DisconnectButton = styled__default.default.button`
+  svg path {
+    fill: ${({ theme, disabled }) => disabled ? theme.colors.neutral600 : theme.colors.neutral500};
+  }
+
+  &:hover svg path,
+  &:focus svg path {
+    fill: ${({ theme, disabled }) => !disabled && theme.colors.neutral600};
+  }
+`;
+const LinkEllipsis = styled__default.default(v2.Link)`
+  display: block;
+
+  & > span {
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    display: block;
+  }
+`;
+const RelationItemPlaceholder = () => /* @__PURE__ */ jsxRuntime.jsx(
+  designSystem.Box,
+  {
+    paddingTop: 2,
+    paddingBottom: 2,
+    paddingLeft: 4,
+    paddingRight: 4,
+    hasRadius: true,
+    borderStyle: "dashed",
+    borderColor: "primary600",
+    borderWidth: "1px",
+    background: "primary100",
+    height: `calc(100% - ${RELATION_GUTTER}px)`
+  }
+);
+
+const RelationDragPreview = ({ status, displayedValue, width }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { style: { width }, children: /* @__PURE__ */ jsxRuntime.jsxs(
+    designSystem.Flex,
+    {
+      paddingTop: 2,
+      paddingBottom: 2,
+      paddingLeft: 2,
+      paddingRight: 4,
+      hasRadius: true,
+      borderWidth: 1,
+      background: "neutral0",
+      borderColor: "neutral200",
+      justifyContent: "space-between",
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(FlexWrapper, { gap: 1, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.IconButton, { "aria-label": "", borderWidth: 0, children: /* @__PURE__ */ jsxRuntime.jsx(Icons.Drag, {}) }),
+          /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { width: "100%", minWidth: 0, justifyContent: "space-between", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { minWidth: 0, paddingTop: 1, paddingBottom: 1, paddingRight: 4, children: /* @__PURE__ */ jsxRuntime.jsx(LinkEllipsis, { href: "", children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { textColor: "primary600", ellipsis: true, children: displayedValue }) }) }),
+            status ? /* @__PURE__ */ jsxRuntime.jsx(DocumentStatus, { status }) : null
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingLeft: 4, children: /* @__PURE__ */ jsxRuntime.jsx(DisconnectButton, { type: "button", children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Icon, { width: "12px", as: Icons.Cross }) }) })
+      ]
+    }
+  ) });
+};
+
+const LeftMenu = () => {
+  const [search, setSearch] = React__namespace.useState("");
+  const [{ query }] = useQueryParams();
+  const { formatMessage, locale } = reactIntl.useIntl();
+  const collectionTypeLinks = useTypedSelector(
+    (state) => state["content-manager_app"].collectionTypeLinks
+  );
+  const singleTypeLinks = useTypedSelector((state) => state["content-manager_app"].singleTypeLinks);
+  const { startsWith } = designSystem.useFilter(locale, {
+    sensitivity: "base"
+  });
+  const formatter = designSystem.useCollator(locale, {
+    sensitivity: "base"
+  });
+  const menu = React__namespace.useMemo(
+    () => [
+      {
+        id: "collectionTypes",
+        title: formatMessage({
+          id: getTranslation("components.LeftMenu.collection-types"),
+          defaultMessage: "Collection Types"
+        }),
+        searchable: true,
+        links: collectionTypeLinks
+      },
+      {
+        id: "singleTypes",
+        title: formatMessage({
+          id: getTranslation("components.LeftMenu.single-types"),
+          defaultMessage: "Single Types"
+        }),
+        searchable: true,
+        links: singleTypeLinks
+      }
+    ].map((section) => ({
+      ...section,
+      links: section.links.filter((link) => startsWith(link.title, search)).sort((a, b) => formatter.compare(a.title, b.title)).map((link) => {
+        return {
+          ...link,
+          title: formatMessage({ id: link.title, defaultMessage: link.title })
+        };
+      })
+    })),
+    [collectionTypeLinks, search, singleTypeLinks, startsWith, formatMessage, formatter]
+  );
+  const handleClear = () => {
+    setSearch("");
+  };
+  const handleChangeSearch = ({ target: { value } }) => {
+    setSearch(value);
+  };
+  const label = formatMessage({
+    id: getTranslation("header.name"),
+    defaultMessage: "Content"
+  });
+  return /* @__PURE__ */ jsxRuntime.jsxs(v2.SubNav, { ariaLabel: label, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      v2.SubNavHeader,
+      {
+        label,
+        searchable: true,
+        value: search,
+        onChange: handleChangeSearch,
+        onClear: handleClear,
+        searchLabel: formatMessage({
+          id: "content-manager.components.LeftMenu.Search.label",
+          defaultMessage: "Search for a content type"
+        })
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(v2.SubNavSections, { children: menu.map((section) => {
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        v2.SubNavSection,
+        {
+          label: section.title,
+          badgeLabel: section.links.length.toString(),
+          children: section.links.map((link) => {
+            return /* @__PURE__ */ jsxRuntime.jsx(
+              v2.SubNavLink,
+              {
+                as: reactRouterDom.NavLink,
+                to: {
+                  pathname: link.to,
+                  /**
+                   * We re-add the plugins query to the params available in the menu,
+                   * this means once you've changed the locale in the app, you continue
+                   * to see the same locale when changing content-type.
+                   *
+                   * NOTE: if you go to a content-type that does not have i18n enabled,
+                   * we return the default documents anyway.
+                   */
+                  search: qs.stringify({
+                    ...qs.parse(link.search ?? ""),
+                    plugins: query.plugins
+                  })
+                },
+                children: link.title
+              },
+              link.uid
+            );
+          })
+        },
+        section.id
+      );
+    }) })
+  ] });
+};
+
+const contentTypesApi = contentManagerApi.injectEndpoints({
+  endpoints: (builder) => ({
+    getContentTypeConfiguration: builder.query({
+      query: (uid) => ({
+        url: `/content-manager/content-types/${uid}/configuration`,
+        method: "GET"
+      }),
+      transformResponse: (response) => response.data,
+      providesTags: (_result, _error, uid) => [
+        { type: "ContentTypesConfiguration", id: uid },
+        { type: "ContentTypeSettings", id: "LIST" }
+      ]
+    }),
+    getAllContentTypeSettings: builder.query({
+      query: () => "/content-manager/content-types-settings",
+      transformResponse: (response) => response.data,
+      providesTags: [{ type: "ContentTypeSettings", id: "LIST" }]
+    }),
+    updateContentTypeConfiguration: builder.mutation({
+      query: ({ uid, ...body }) => ({
+        url: `/content-manager/content-types/${uid}/configuration`,
+        method: "PUT",
+        data: body
+      }),
+      transformResponse: (response) => response.data,
+      invalidatesTags: (_result, _error, { uid }) => [
+        { type: "ContentTypesConfiguration", id: uid },
+        { type: "ContentTypeSettings", id: "LIST" },
+        // Is this necessary?
+        { type: "InitialData" }
+      ]
+    })
+  })
+});
+const {
+  useGetContentTypeConfigurationQuery,
+  useGetAllContentTypeSettingsQuery,
+  useUpdateContentTypeConfigurationMutation
+} = contentTypesApi;
+
+const { MUTATE_COLLECTION_TYPES_LINKS, MUTATE_SINGLE_TYPES_LINKS } = HOOKS;
+const useContentManagerInitData = () => {
+  const dispatch = useTypedDispatch();
+  const { toggleNotification } = useNotification();
+  const runHookWaterfall = useStrapiApp(
+    "useContentManagerInitData",
+    (state2) => state2.runHookWaterfall
+  );
+  const { notifyStatus } = designSystem.useNotifyAT();
+  const { formatMessage } = reactIntl.useIntl();
+  const { _unstableFormatAPIError: formatAPIError } = useAPIErrorHandler(getTranslation);
+  const checkUserHasPermissions = useAuth(
+    "useContentManagerInitData",
+    (state2) => state2.checkUserHasPermissions
+  );
+  const state = useTypedSelector((state2) => state2["content-manager_app"]);
+  const initialDataQuery = useGetInitialDataQuery(void 0, {
+    /**
+     * TODO: remove this when the CTB has been refactored to use redux-toolkit-query
+     * and it can invalidate the cache on mutation
+     */
+    refetchOnMountOrArgChange: true
+  });
+  React.useEffect(() => {
+    if (initialDataQuery.data) {
+      notifyStatus(
+        formatMessage({
+          id: getTranslation("App.schemas.data-loaded"),
+          defaultMessage: "The schemas have been successfully loaded."
+        })
+      );
+    }
+  }, [formatMessage, initialDataQuery.data, notifyStatus]);
+  React.useEffect(() => {
+    if (initialDataQuery.error) {
+      toggleNotification({ type: "danger", message: formatAPIError(initialDataQuery.error) });
+    }
+  }, [formatAPIError, initialDataQuery.error, toggleNotification]);
+  const contentTypeSettingsQuery = useGetAllContentTypeSettingsQuery();
+  React.useEffect(() => {
+    if (contentTypeSettingsQuery.error) {
+      toggleNotification({
+        type: "danger",
+        message: formatAPIError(contentTypeSettingsQuery.error)
+      });
+    }
+  }, [formatAPIError, contentTypeSettingsQuery.error, toggleNotification]);
+  const formatData = async (components, contentTypes, fieldSizes, contentTypeConfigurations) => {
+    const { collectionType: collectionTypeLinks, singleType: singleTypeLinks } = contentTypes.reduce(
+      (acc, model) => {
+        acc[model.kind].push(model);
+        return acc;
+      },
+      {
+        collectionType: [],
+        singleType: []
+      }
+    );
+    const collectionTypeSectionLinks = generateLinks(
+      collectionTypeLinks,
+      "collectionTypes",
+      contentTypeConfigurations
+    );
+    const singleTypeSectionLinks = generateLinks(singleTypeLinks, "singleTypes");
+    const collectionTypeLinksPermissions = await Promise.all(
+      collectionTypeSectionLinks.map(({ permissions }) => checkUserHasPermissions(permissions))
+    );
+    const authorizedCollectionTypeLinks = collectionTypeSectionLinks.filter(
+      (_, index) => collectionTypeLinksPermissions[index]
+    );
+    const singleTypeLinksPermissions = await Promise.all(
+      singleTypeSectionLinks.map(({ permissions }) => checkUserHasPermissions(permissions))
+    );
+    const authorizedSingleTypeLinks = singleTypeSectionLinks.filter(
+      (_, index) => singleTypeLinksPermissions[index]
+    );
+    const { ctLinks } = runHookWaterfall(MUTATE_COLLECTION_TYPES_LINKS, {
+      ctLinks: authorizedCollectionTypeLinks,
+      models: contentTypes
+    });
+    const { stLinks } = runHookWaterfall(MUTATE_SINGLE_TYPES_LINKS, {
+      stLinks: authorizedSingleTypeLinks,
+      models: contentTypes
+    });
+    dispatch({
+      type: SET_INIT_DATA,
+      authorizedCollectionTypeLinks: ctLinks,
+      authorizedSingleTypeLinks: stLinks,
+      contentTypeSchemas: contentTypes,
+      components,
+      fieldSizes
+    });
+  };
+  React.useEffect(() => {
+    if (initialDataQuery.data && contentTypeSettingsQuery.data) {
+      formatData(
+        initialDataQuery.data.components,
+        initialDataQuery.data.contentTypes,
+        initialDataQuery.data.fieldSizes,
+        contentTypeSettingsQuery.data
+      );
+    }
+  }, [initialDataQuery.data, contentTypeSettingsQuery.data]);
+  return { ...state };
+};
+const generateLinks = (links, type, configurations = []) => {
+  return links.filter((link) => link.isDisplayed).map((link) => {
+    const collectionTypesPermissions = [
+      { action: "plugin::content-manager.explorer.create", subject: link.uid },
+      { action: "plugin::content-manager.explorer.read", subject: link.uid }
+    ];
+    const singleTypesPermissions = [
+      { action: "plugin::content-manager.explorer.read", subject: link.uid }
+    ];
+    const permissions = type === "collectionTypes" ? collectionTypesPermissions : singleTypesPermissions;
+    const currentContentTypeConfig = configurations.find(({ uid }) => uid === link.uid);
+    let search = null;
+    if (currentContentTypeConfig) {
+      const searchParams = {
+        page: 1,
+        pageSize: currentContentTypeConfig.settings.pageSize,
+        sort: `${currentContentTypeConfig.settings.defaultSortBy}:${currentContentTypeConfig.settings.defaultSortOrder}`
+      };
+      search = qs.stringify(searchParams, { encode: false });
+    }
+    return {
+      permissions,
+      search,
+      kind: link.kind,
+      title: link.info.displayName,
+      to: `/content-manager/${link.kind === "collectionType" ? COLLECTION_TYPES : SINGLE_TYPES}/${link.uid}`,
+      uid: link.uid,
+      // Used for the list item key in the helper plugin
+      name: link.uid,
+      isDisplayed: link.isDisplayed
+    };
+  });
+};
+
+const Layout = () => {
+  const contentTypeMatch = reactRouterDom.useMatch("/content-manager/:kind/:uid/*");
+  const { isLoading, collectionTypeLinks, models, singleTypeLinks } = useContentManagerInitData();
+  const authorisedModels = [...collectionTypeLinks, ...singleTypeLinks].sort(
+    (a, b) => a.title.localeCompare(b.title)
+  );
+  const { pathname } = reactRouterDom.useLocation();
+  const { formatMessage } = reactIntl.useIntl();
+  const startSection = useGuidedTour("Layout", (state) => state.startSection);
+  const startSectionRef = React__namespace.useRef(startSection);
+  const isHistoryRoute = useIsHistoryRoute();
+  React__namespace.useEffect(() => {
+    if (startSectionRef.current) {
+      startSectionRef.current("contentManager");
+    }
+  }, []);
+  if (isLoading) {
+    return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        reactHelmet.Helmet,
+        {
+          title: formatMessage({
+            id: getTranslation("plugin.name"),
+            defaultMessage: "Content Manager"
+          })
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(Page.Loading, {})
+    ] });
+  }
+  const supportedModelsToDisplay = models.filter(({ isDisplayed }) => isDisplayed);
+  if (authorisedModels.length === 0 && supportedModelsToDisplay.length > 0 && pathname !== "/content-manager/403") {
+    return /* @__PURE__ */ jsxRuntime.jsx(reactRouterDom.Navigate, { to: "/403" });
+  }
+  if (supportedModelsToDisplay.length === 0 && pathname !== "/no-content-types") {
+    return /* @__PURE__ */ jsxRuntime.jsx(reactRouterDom.Navigate, { to: "/no-content-types" });
+  }
+  if (!contentTypeMatch && authorisedModels.length > 0) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      reactRouterDom.Navigate,
+      {
+        to: {
+          pathname: authorisedModels[0].to,
+          search: authorisedModels[0].search ?? ""
+        }
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      reactHelmet.Helmet,
+      {
+        title: formatMessage({
+          id: getTranslation("plugin.name"),
+          defaultMessage: "Content Manager"
+        })
+      }
+    ),
+    isHistoryRoute ? /* @__PURE__ */ jsxRuntime.jsx(reactRouterDom.Outlet, {}) : /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Layout, { sideNav: /* @__PURE__ */ jsxRuntime.jsx(LeftMenu, {}), children: [
+      /* @__PURE__ */ jsxRuntime.jsx(DragLayer, { renderItem: renderDraglayerItem }),
+      /* @__PURE__ */ jsxRuntime.jsx(reactRouterDom.Outlet, {})
+    ] })
+  ] });
+};
+function renderDraglayerItem({ type, item }) {
+  if (!type || type && typeof type !== "string") {
+    return null;
+  }
+  const [actualType] = type.split("_");
+  switch (actualType) {
+    case ItemTypes.EDIT_FIELD:
+    case ItemTypes.FIELD:
+      return /* @__PURE__ */ jsxRuntime.jsx(CardDragPreview, { label: item.label });
+    case ItemTypes.COMPONENT:
+    case ItemTypes.DYNAMIC_ZONE:
+      return /* @__PURE__ */ jsxRuntime.jsx(ComponentDragPreview, { displayedValue: item.displayedValue });
+    case ItemTypes.RELATION:
+      return /* @__PURE__ */ jsxRuntime.jsx(RelationDragPreview, { ...item });
+    default:
+      return null;
+  }
+}
+const SET_INIT_DATA = "ContentManager/App/SET_INIT_DATA";
+const initialState$1 = {
+  collectionTypeLinks: [],
+  components: [],
+  fieldSizes: {},
+  models: [],
+  singleTypeLinks: [],
+  isLoading: true
+};
+const reducer$2 = (state = initialState$1, action) => immer.produce(state, (draftState) => {
+  switch (action.type) {
+    case SET_INIT_DATA: {
+      const initDataAction = action;
+      draftState.collectionTypeLinks = initDataAction.authorizedCollectionTypeLinks.filter(
+        ({ isDisplayed }) => isDisplayed
+      );
+      draftState.singleTypeLinks = initDataAction.authorizedSingleTypeLinks.filter(
+        ({ isDisplayed }) => isDisplayed
+      );
+      draftState.components = initDataAction.components;
+      draftState.models = initDataAction.contentTypeSchemas;
+      draftState.fieldSizes = initDataAction.fieldSizes;
+      draftState.isLoading = false;
+      break;
+    }
+    default:
+      return draftState;
+  }
+});
+
+const layout = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+  __proto__: null,
+  Layout,
+  SET_INIT_DATA,
+  reducer: reducer$2
+}, Symbol.toStringTag, { value: 'Module' }));
+
+const initialState = {
+  permissions: void 0
+};
+const rbacSlice = toolkit.createSlice({
+  name: "rbac",
+  initialState,
+  reducers: {
+    setPermissions(state, action) {
+      state.permissions = Object.values(action.payload.permissions).reduce((acc, current) => {
+        return [...acc, ...current];
+      }, []);
+    },
+    resetPermissions(state) {
+      state.permissions = void 0;
+    }
+  }
+});
+const { actions, reducer: reducer$1 } = rbacSlice;
+const { setPermissions, resetPermissions } = actions;
+
+const reducer = toolkit.combineReducers({
+  rbac: reducer$1
+});
+
+exports.ADMIN_PERMISSIONS_CE = ADMIN_PERMISSIONS_CE;
+exports.ATTRIBUTE_TYPES_THAT_CANNOT_BE_MAIN_FIELD = ATTRIBUTE_TYPES_THAT_CANNOT_BE_MAIN_FIELD;
+exports.AppInfoProvider = AppInfoProvider;
+exports.AuthProvider = AuthProvider;
+exports.Blocker = Blocker;
+exports.COLLECTION_TYPES = COLLECTION_TYPES;
+exports.CREATED_AT_ATTRIBUTE_NAME = CREATED_AT_ATTRIBUTE_NAME;
+exports.CREATED_BY_ATTRIBUTE_NAME = CREATED_BY_ATTRIBUTE_NAME;
+exports.CREATOR_FIELDS = CREATOR_FIELDS;
+exports.CardDragPreview = CardDragPreview;
+exports.ComponentProvider = ComponentProvider;
+exports.ConfigurationContextProvider = ConfigurationContextProvider;
+exports.ConfigurationProvider = ConfigurationProvider;
+exports.DIRECTIONS = DIRECTIONS;
+exports.DOCUMENT_META_FIELDS = DOCUMENT_META_FIELDS;
+exports.DocumentStatus = DocumentStatus;
+exports.DragLayer = DragLayer;
+exports.Form = Form;
+exports.GuidedTourProvider = GuidedTourProvider;
+exports.HOOKS = HOOKS;
+exports.ItemTypes = ItemTypes;
+exports.LANGUAGE_LOCAL_STORAGE_KEY = LANGUAGE_LOCAL_STORAGE_KEY;
+exports.LanguageProvider = LanguageProvider;
+exports.NotificationsProvider = NotificationsProvider;
+exports.PUBLISHED_AT_ATTRIBUTE_NAME = PUBLISHED_AT_ATTRIBUTE_NAME;
+exports.PUBLISHED_BY_ATTRIBUTE_NAME = PUBLISHED_BY_ATTRIBUTE_NAME;
+exports.Page = Page;
+exports.RelationsField = RelationsField;
+exports.SETTINGS_LINKS_CE = SETTINGS_LINKS_CE;
+exports.SINGLE_TYPES = SINGLE_TYPES;
+exports.StrapiAppProvider = StrapiAppProvider;
+exports.THEME_LOCAL_STORAGE_KEY = THEME_LOCAL_STORAGE_KEY;
+exports.Theme = Theme;
+exports.TrackingProvider = TrackingProvider;
+exports.UPDATED_AT_ATTRIBUTE_NAME = UPDATED_AT_ATTRIBUTE_NAME;
+exports.UPDATED_BY_ATTRIBUTE_NAME = UPDATED_BY_ATTRIBUTE_NAME;
+exports.adminApi = adminApi;
+exports.buildValidParams = buildValidParams;
+exports.capitalise = capitalise;
+exports.contentManagerApi = contentManagerApi;
+exports.createContext = createContext;
+exports.createTypedSelector = createTypedSelector;
+exports.createYupSchema = createYupSchema;
+exports.errorsTrads = errorsTrads;
+exports.extractContentTypeComponents = extractContentTypeComponents;
+exports.getFetchClient = getFetchClient;
+exports.getIn = getIn;
+exports.getRelationLabel = getRelationLabel;
+exports.getTranslation = getTranslation;
+exports.isBaseQueryError = isBaseQueryError;
+exports.isObject = isObject;
+exports.layout = layout;
+exports.prefixFileUrlWithBackendUrl = prefixFileUrlWithBackendUrl;
+exports.reducer = reducer$5;
+exports.reducer$1 = reducer$2;
+exports.reducer$2 = reducer;
+exports.resetPermissions = resetPermissions;
+exports.routes = routes;
+exports.setAppTheme = setAppTheme;
+exports.setIn = setIn;
+exports.setLocale = setLocale;
+exports.setPermissions = setPermissions;
+exports.useAPIErrorHandler = useAPIErrorHandler;
+exports.useAppInfo = useAppInfo;
+exports.useAuth = useAuth;
+exports.useAutoCloneDocumentMutation = useAutoCloneDocumentMutation;
+exports.useCloneDocumentMutation = useCloneDocumentMutation;
+exports.useComponent = useComponent;
+exports.useConfiguration = useConfiguration;
+exports.useContentTypeSchema = useContentTypeSchema;
+exports.useCreateDocumentMutation = useCreateDocumentMutation;
+exports.useDeleteDocumentMutation = useDeleteDocumentMutation;
+exports.useDiscardDocumentMutation = useDiscardDocumentMutation;
+exports.useDoc = useDoc;
+exports.useDocument = useDocument;
+exports.useDragAndDrop = useDragAndDrop;
+exports.useField = useField;
+exports.useFocusInputField = useFocusInputField;
+exports.useForgotPasswordMutation = useForgotPasswordMutation;
+exports.useForm = useForm;
+exports.useGetAllDocumentsQuery = useGetAllDocumentsQuery;
+exports.useGetContentTypeConfigurationQuery = useGetContentTypeConfigurationQuery;
+exports.useGetInitialDataQuery = useGetInitialDataQuery;
+exports.useGetLicenseLimitsQuery = useGetLicenseLimitsQuery;
+exports.useGetPluginsQuery = useGetPluginsQuery;
+exports.useGetProviderOptionsQuery = useGetProviderOptionsQuery;
+exports.useGetProvidersQuery = useGetProvidersQuery;
+exports.useGetRegistrationInfoQuery = useGetRegistrationInfoQuery;
+exports.useGetRelationsQuery = useGetRelationsQuery;
+exports.useGuidedTour = useGuidedTour;
+exports.useInformationQuery = useInformationQuery;
+exports.useInitQuery = useInitQuery;
+exports.useIsHistoryRoute = useIsHistoryRoute;
+exports.useIsSSOLockedQuery = useIsSSOLockedQuery;
+exports.useLazyGetDocumentQuery = useLazyGetDocumentQuery;
+exports.useNotification = useNotification;
+exports.usePrev = usePrev;
+exports.usePublishDocumentMutation = usePublishDocumentMutation;
+exports.useQueryParams = useQueryParams;
+exports.useRBAC = useRBAC;
+exports.useRegenerateTokenMutation = useRegenerateTokenMutation;
+exports.useRegisterAdminMutation = useRegisterAdminMutation;
+exports.useRegisterUserMutation = useRegisterUserMutation;
+exports.useResetPasswordMutation = useResetPasswordMutation;
+exports.useStrapiApp = useStrapiApp;
+exports.useTracking = useTracking;
+exports.useTypedDispatch = useTypedDispatch;
+exports.useTypedSelector = useTypedSelector;
+exports.useTypedStore = useTypedStore;
+exports.useUnpublishDocumentMutation = useUnpublishDocumentMutation;
+exports.useUpdateContentTypeConfigurationMutation = useUpdateContentTypeConfigurationMutation;
+exports.useUpdateDocumentMutation = useUpdateDocumentMutation;
+exports.useUpdateMeMutation = useUpdateMeMutation;
+exports.useUpdateProviderOptionsMutation = useUpdateProviderOptionsMutation;
+//# sourceMappingURL=reducers-uDxSALD_.js.map