@strapi/content-manager 0.0.0 → 5.0.0-beta.6

package/dist/_chunks/index-DNVx8ssZ.mjs

@@ -0,0 +1,3175 @@
+import { ClockCounterClockwise, CrossCircle, More, WarningCircle, Cog, Pencil, Trash, ChevronRight, Duplicate, Feather } from "@strapi/icons";
+import { jsx, Fragment, jsxs } from "react/jsx-runtime";
+import { useStrapiApp, useQueryParams, createContext, useAuth, useRBAC, Page, getFetchClient, translatedErrors, useNotification, useAPIErrorHandler, useTracking, useForm, BackButton, DescriptionComponentRenderer } from "@strapi/admin/strapi-admin";
+import { stringify } from "qs";
+import { useIntl } from "react-intl";
+import { useNavigate, useParams, Navigate, useMatch, NavLink } from "react-router-dom";
+import * as React from "react";
+import { lazy } from "react";
+import { Menu, VisuallyHidden, Flex, Typography, Dialog, DialogBody, DialogFooter, Button, ModalLayout, ModalHeader, ModalBody, Box, Radio, Status, SingleSelect, SingleSelectOption, LinkButton } from "@strapi/design-system";
+import styled from "styled-components";
+import * as yup from "yup";
+import { ValidationError } from "yup";
+import { createApi } from "@reduxjs/toolkit/query/react";
+import { isAxiosError } from "axios";
+import pipe from "lodash/fp/pipe";
+import { intervalToDuration, isPast } from "date-fns";
+import { createSlice, combineReducers } from "@reduxjs/toolkit";
+const __variableDynamicImportRuntimeHelper = (glob, path) => {
+  const v = glob[path];
+  if (v) {
+    return typeof v === "function" ? v() : Promise.resolve(v);
+  }
+  return new Promise((_, reject) => {
+    (typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(reject.bind(null, new Error("Unknown variable dynamic import: " + path)));
+  });
+};
+const PLUGIN_ID = "content-manager";
+const PERMISSIONS = [
+  "plugin::content-manager.explorer.create",
+  "plugin::content-manager.explorer.read",
+  "plugin::content-manager.explorer.update",
+  "plugin::content-manager.explorer.delete",
+  "plugin::content-manager.explorer.publish"
+];
+const INJECTION_ZONES = {
+  editView: { informations: [], "right-links": [] },
+  listView: {
+    actions: [],
+    deleteModalAdditionalInfos: [],
+    publishModalAdditionalInfos: [],
+    unpublishModalAdditionalInfos: []
+  }
+};
+const InjectionZone = ({ area, ...props }) => {
+  const components = useInjectionZone(area);
+  return /* @__PURE__ */ jsx(Fragment, { children: components.map((component) => /* @__PURE__ */ jsx(component.Component, { ...props }, component.name)) });
+};
+const useInjectionZone = (area) => {
+  const getPlugin = useStrapiApp("useInjectionZone", (state) => state.getPlugin);
+  const contentManagerPlugin = getPlugin(PLUGIN_ID);
+  const [page, position] = area.split(".");
+  return contentManagerPlugin.getInjectedComponents(page, position);
+};
+const HistoryAction = ({ model, document }) => {
+  const { formatMessage } = useIntl();
+  const [{ query }] = useQueryParams();
+  const navigate = useNavigate();
+  const pluginsQueryParams = stringify({ plugins: query.plugins }, { encode: false });
+  if (!window.strapi.features.isEnabled("cms-content-history")) {
+    return null;
+  }
+  return {
+    icon: /* @__PURE__ */ jsx(ClockCounterClockwise, {}),
+    label: formatMessage({
+      id: "content-manager.history.document-action",
+      defaultMessage: "Content History"
+    }),
+    onClick: () => navigate({ pathname: "history", search: pluginsQueryParams }),
+    disabled: (
+      /**
+       * The user is creating a new document.
+       * It hasn't been saved yet, so there's no history to go to
+       */
+      !document || /**
+      * The document has been created but the current dimension has never been saved.
+      * For example, the user is creating a new locale in an existing document,
+      * so there's no history for the document in that locale
+      */
+      !document.id || /**
+      * History is only available for content types created by the user.
+      * These have the `api::` prefix, as opposed to the ones created by Strapi or plugins,
+      * which start with `admin::` or `plugin::`
+      */
+      !model.startsWith("api::")
+    ),
+    position: "header"
+  };
+};
+HistoryAction.type = "history";
+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 SINGLE_TYPES = "single-types";
+const COLLECTION_TYPES = "collection-types";
+const [DocumentRBACProvider, useDocumentRBAC] = createContext(
+  "DocumentRBAC",
+  {
+    canCreate: false,
+    canCreateFields: [],
+    canDelete: false,
+    canPublish: false,
+    canRead: false,
+    canReadFields: [],
+    canUpdate: false,
+    canUpdateFields: [],
+    canUserAction: () => false,
+    isLoading: false
+  }
+);
+const DocumentRBAC = ({ children, permissions }) => {
+  const { slug } = useParams();
+  if (!slug) {
+    throw new Error("Cannot find the slug param in the URL");
+  }
+  const userPermissions = useAuth("DocumentRBAC", (state) => state.permissions);
+  const contentTypePermissions = React.useMemo(() => {
+    const contentTypePermissions2 = userPermissions.filter(
+      (permission) => permission.subject === slug
+    );
+    return contentTypePermissions2.reduce((acc, permission) => {
+      const [action] = permission.action.split(".").slice(-1);
+      return { ...acc, [action]: [permission] };
+    }, {});
+  }, [slug, userPermissions]);
+  const { isLoading, allowedActions } = useRBAC(contentTypePermissions, permissions ?? void 0);
+  const canCreateFields = !isLoading && allowedActions.canCreate ? extractAndDedupeFields(contentTypePermissions.create) : [];
+  const canReadFields = !isLoading && allowedActions.canRead ? extractAndDedupeFields(contentTypePermissions.read) : [];
+  const canUpdateFields = !isLoading && allowedActions.canUpdate ? extractAndDedupeFields(contentTypePermissions.update) : [];
+  const canUserAction = React.useCallback(
+    (fieldName, fieldsUserCanAction, fieldType) => {
+      const name = removeNumericalStrings(fieldName.split("."));
+      const componentFieldNames = fieldsUserCanAction.filter((field) => field.split(".").length > 1);
+      if (fieldType === "component") {
+        const componentOrDynamicZoneFields = componentFieldNames.map((field) => field.split("."));
+        return componentOrDynamicZoneFields.some((field) => {
+          return field.includes(fieldName);
+        });
+      }
+      if (name.length > 1) {
+        return componentFieldNames.includes(name.join("."));
+      }
+      return fieldsUserCanAction.includes(fieldName);
+    },
+    []
+  );
+  if (isLoading) {
+    return /* @__PURE__ */ jsx(Page.Loading, {});
+  }
+  return /* @__PURE__ */ jsx(
+    DocumentRBACProvider,
+    {
+      isLoading,
+      canCreateFields,
+      canReadFields,
+      canUpdateFields,
+      canUserAction,
+      ...allowedActions,
+      children
+    }
+  );
+};
+const extractAndDedupeFields = (permissions = []) => permissions.flatMap((permission) => permission.properties?.fields).filter(
+  (field, index2, arr) => arr.indexOf(field) === index2 && typeof field === "string"
+);
+const removeNumericalStrings = (arr) => arr.filter((item) => isNaN(Number(item)));
+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 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 (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 contentManagerApi = 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 createYupSchema = (attributes = {}, components = {}) => {
+  const createModelSchema = (attributes2) => yup.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(...validations);
+      switch (attribute.type) {
+        case "component": {
+          const { attributes: attributes3 } = components[attribute.component];
+          if (attribute.repeatable) {
+            return {
+              ...acc,
+              [name]: transformSchema(
+                yup.array().of(createModelSchema(attributes3).nullable(false))
+              )
+            };
+          } else {
+            return {
+              ...acc,
+              [name]: transformSchema(createModelSchema(attributes3))
+            };
+          }
+        }
+        case "dynamiczone":
+          return {
+            ...acc,
+            [name]: transformSchema(
+              yup.array().of(
+                yup.lazy(
+                  (data) => {
+                    const { attributes: attributes3 } = components[data.__component];
+                    return yup.object().shape({
+                      __component: yup.string().required().oneOf(Object.keys(components))
+                    }).nullable(false).concat(createModelSchema(attributes3));
+                  }
+                )
+              )
+            )
+          };
+        case "relation":
+          return {
+            ...acc,
+            [name]: transformSchema(
+              yup.array().of(
+                yup.object().shape({
+                  id: yup.string().required()
+                })
+              )
+            )
+          };
+        default:
+          return {
+            ...acc,
+            [name]: transformSchema(createAttributeSchema(attribute))
+          };
+      }
+    }, {})
+  ).default(null);
+  return createModelSchema(attributes);
+};
+const createAttributeSchema = (attribute) => {
+  switch (attribute.type) {
+    case "biginteger":
+      return yup.string().matches(/^-?\d*$/);
+    case "boolean":
+      return yup.boolean();
+    case "blocks":
+      return yup.mixed().test("isBlocks", translatedErrors.json, (value) => {
+        if (!value || Array.isArray(value)) {
+          return true;
+        } else {
+          return false;
+        }
+      });
+    case "decimal":
+    case "float":
+    case "integer":
+      return yup.number();
+    case "email":
+      return yup.string().email(translatedErrors.email);
+    case "enumeration":
+      return yup.string().oneOf([...attribute.enum, null]);
+    case "json":
+      return yup.mixed().test("isJSON", translatedErrors.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.string();
+    case "uid":
+      return yup.string().matches(/^[A-Za-z0-9-_.~]*$/);
+    default:
+      return yup.mixed();
+  }
+};
+const addRequiredValidation = (attribute) => (schema) => {
+  if (attribute.required) {
+    return schema.required({
+      id: translatedErrors.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, {
+      ...translatedErrors.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, {
+      ...translatedErrors.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, {
+        ...translatedErrors.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, {
+        ...translatedErrors.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: translatedErrors.regex.id,
+        defaultMessage: "The value does not match the defined pattern."
+      },
+      excludeEmptyString: !attribute.required
+    });
+  }
+  return schema;
+};
+const extractValuesFromYupError = (errorType, errorParams) => {
+  if (!errorType || !errorParams) {
+    return {};
+  }
+  return {
+    [errorType]: errorParams[errorType]
+  };
+};
+const getInnerErrors = (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 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.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.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.useEffect(() => {
+    if (error) {
+      toggleNotification({
+        type: "danger",
+        message: formatAPIError(error)
+      });
+    }
+  }, [toggleNotification, error, formatAPIError, args.collectionType]);
+  const validationSchema = React.useMemo(() => {
+    if (!schema) {
+      return null;
+    }
+    return createYupSchema(schema.attributes, components);
+  }, [schema, components]);
+  const validate = React.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 ValidationError) {
+          return getInnerErrors(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 } = useParams();
+  const [{ query }] = useQueryParams();
+  const params = React.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
+      }
+    )
+  };
+};
+const prefixPluginTranslations = (trad, pluginId) => {
+  if (!pluginId) {
+    throw new TypeError("pluginId can't be empty");
+  }
+  return Object.keys(trad).reduce((acc, current) => {
+    acc[`${pluginId}.${current}`] = trad[current];
+    return acc;
+  }, {});
+};
+const getTranslation = (id) => `content-manager.${id}`;
+const DEFAULT_UNEXPECTED_ERROR_MSG = {
+  id: "notification.error",
+  defaultMessage: "An error occurred, please try again"
+};
+const useDocumentActions = () => {
+  const { toggleNotification } = useNotification();
+  const { formatMessage } = useIntl();
+  const { trackUsage } = useTracking();
+  const { _unstableFormatAPIError: formatAPIError } = useAPIErrorHandler();
+  const [deleteDocument] = useDeleteDocumentMutation();
+  const _delete = React.useCallback(
+    async ({ collectionType, model, documentId, params }, trackerProperty) => {
+      try {
+        trackUsage("willDeleteEntry", trackerProperty);
+        const res = await deleteDocument({
+          collectionType,
+          model,
+          documentId,
+          params
+        });
+        if ("error" in res) {
+          toggleNotification({
+            type: "danger",
+            message: formatAPIError(res.error)
+          });
+          return { error: res.error };
+        }
+        toggleNotification({
+          type: "success",
+          message: formatMessage({
+            id: getTranslation("success.record.delete"),
+            defaultMessage: "Deleted document"
+          })
+        });
+        trackUsage("didDeleteEntry", trackerProperty);
+        return res.data;
+      } catch (err) {
+        toggleNotification({
+          type: "danger",
+          message: formatMessage(DEFAULT_UNEXPECTED_ERROR_MSG)
+        });
+        trackUsage("didNotDeleteEntry", { error: err, ...trackerProperty });
+        throw err;
+      }
+    },
+    [trackUsage, deleteDocument, toggleNotification, formatMessage, formatAPIError]
+  );
+  const [discardDocument] = useDiscardDocumentMutation();
+  const discard = React.useCallback(
+    async ({ collectionType, model, documentId }) => {
+      try {
+        const res = await discardDocument({
+          collectionType,
+          model,
+          documentId
+        });
+        if ("error" in res) {
+          toggleNotification({
+            type: "danger",
+            message: formatAPIError(res.error)
+          });
+          return { error: res.error };
+        }
+        toggleNotification({
+          type: "success",
+          message: formatMessage({
+            id: "content-manager.success.record.discard",
+            defaultMessage: "Changes discarded"
+          })
+        });
+        return res.data;
+      } catch (err) {
+        toggleNotification({
+          type: "danger",
+          message: formatMessage(DEFAULT_UNEXPECTED_ERROR_MSG)
+        });
+        throw err;
+      }
+    },
+    [discardDocument, formatAPIError, formatMessage, toggleNotification]
+  );
+  const [publishDocument] = usePublishDocumentMutation();
+  const publish = React.useCallback(
+    async ({ collectionType, model, documentId, params }, data) => {
+      try {
+        trackUsage("willPublishEntry");
+        const res = await publishDocument({
+          collectionType,
+          model,
+          documentId,
+          data,
+          params
+        });
+        if ("error" in res) {
+          toggleNotification({ type: "danger", message: formatAPIError(res.error) });
+          return { error: res.error };
+        }
+        trackUsage("didPublishEntry");
+        toggleNotification({
+          type: "success",
+          message: formatMessage({
+            id: getTranslation("success.record.publish"),
+            defaultMessage: "Published document"
+          })
+        });
+        return res.data;
+      } catch (err) {
+        toggleNotification({
+          type: "danger",
+          message: formatMessage(DEFAULT_UNEXPECTED_ERROR_MSG)
+        });
+        throw err;
+      }
+    },
+    [trackUsage, publishDocument, toggleNotification, formatMessage, formatAPIError]
+  );
+  const [updateDocument] = useUpdateDocumentMutation();
+  const update = React.useCallback(
+    async ({ collectionType, model, documentId, params }, data, trackerProperty) => {
+      try {
+        trackUsage("willEditEntry", trackerProperty);
+        const res = await updateDocument({
+          collectionType,
+          model,
+          documentId,
+          data,
+          params
+        });
+        if ("error" in res) {
+          toggleNotification({ type: "danger", message: formatAPIError(res.error) });
+          trackUsage("didNotEditEntry", { error: res.error, ...trackerProperty });
+          return { error: res.error };
+        }
+        trackUsage("didEditEntry", trackerProperty);
+        toggleNotification({
+          type: "success",
+          message: formatMessage({
+            id: getTranslation("success.record.save"),
+            defaultMessage: "Saved document"
+          })
+        });
+        return res.data;
+      } catch (err) {
+        trackUsage("didNotEditEntry", { error: err, ...trackerProperty });
+        toggleNotification({
+          type: "danger",
+          message: formatMessage(DEFAULT_UNEXPECTED_ERROR_MSG)
+        });
+        throw err;
+      }
+    },
+    [trackUsage, updateDocument, toggleNotification, formatMessage, formatAPIError]
+  );
+  const [unpublishDocument] = useUnpublishDocumentMutation();
+  const unpublish = React.useCallback(
+    async ({ collectionType, model, documentId, params }, discardDraft = false) => {
+      try {
+        trackUsage("willUnpublishEntry");
+        const res = await unpublishDocument({
+          collectionType,
+          model,
+          documentId,
+          params,
+          data: {
+            discardDraft
+          }
+        });
+        if ("error" in res) {
+          toggleNotification({ type: "danger", message: formatAPIError(res.error) });
+          return { error: res.error };
+        }
+        trackUsage("didUnpublishEntry");
+        toggleNotification({
+          type: "success",
+          message: formatMessage({
+            id: getTranslation("success.record.unpublish"),
+            defaultMessage: "Unpublished document"
+          })
+        });
+        return res.data;
+      } catch (err) {
+        toggleNotification({
+          type: "danger",
+          message: formatMessage(DEFAULT_UNEXPECTED_ERROR_MSG)
+        });
+        throw err;
+      }
+    },
+    [trackUsage, unpublishDocument, toggleNotification, formatMessage, formatAPIError]
+  );
+  const [createDocument] = useCreateDocumentMutation();
+  const create = React.useCallback(
+    async ({ model, params }, data, trackerProperty) => {
+      try {
+        const res = await createDocument({
+          model,
+          data,
+          params
+        });
+        if ("error" in res) {
+          toggleNotification({ type: "danger", message: formatAPIError(res.error) });
+          trackUsage("didNotCreateEntry", { error: res.error, ...trackerProperty });
+          return { error: res.error };
+        }
+        trackUsage("didCreateEntry", trackerProperty);
+        toggleNotification({
+          type: "success",
+          message: formatMessage({
+            id: getTranslation("success.record.save"),
+            defaultMessage: "Saved document"
+          })
+        });
+        return res.data;
+      } catch (err) {
+        toggleNotification({
+          type: "danger",
+          message: formatMessage(DEFAULT_UNEXPECTED_ERROR_MSG)
+        });
+        trackUsage("didNotCreateEntry", { error: err, ...trackerProperty });
+        throw err;
+      }
+    },
+    [createDocument, formatAPIError, formatMessage, toggleNotification, trackUsage]
+  );
+  const [autoCloneDocument] = useAutoCloneDocumentMutation();
+  const autoClone = React.useCallback(
+    async ({ model, sourceId }) => {
+      try {
+        const res = await autoCloneDocument({
+          model,
+          sourceId
+        });
+        if ("error" in res) {
+          toggleNotification({ type: "danger", message: formatAPIError(res.error) });
+          return { error: res.error };
+        }
+        toggleNotification({
+          type: "success",
+          message: formatMessage({
+            id: getTranslation("success.record.clone"),
+            defaultMessage: "Cloned document"
+          })
+        });
+        return res.data;
+      } catch (err) {
+        toggleNotification({
+          type: "danger",
+          message: formatMessage(DEFAULT_UNEXPECTED_ERROR_MSG)
+        });
+        throw err;
+      }
+    },
+    [autoCloneDocument, formatAPIError, formatMessage, toggleNotification]
+  );
+  const [cloneDocument] = useCloneDocumentMutation();
+  const clone = React.useCallback(
+    async ({ model, documentId, params }, body, trackerProperty) => {
+      try {
+        const { id: _id, ...restBody } = body;
+        const res = await cloneDocument({
+          model,
+          sourceId: documentId,
+          data: restBody,
+          params
+        });
+        if ("error" in res) {
+          toggleNotification({ type: "danger", message: formatAPIError(res.error) });
+          trackUsage("didNotCreateEntry", { error: res.error, ...trackerProperty });
+          return { error: res.error };
+        }
+        trackUsage("didCreateEntry", trackerProperty);
+        toggleNotification({
+          type: "success",
+          message: formatMessage({
+            id: getTranslation("success.record.clone"),
+            defaultMessage: "Cloned document"
+          })
+        });
+        return res.data;
+      } catch (err) {
+        toggleNotification({
+          type: "danger",
+          message: formatMessage(DEFAULT_UNEXPECTED_ERROR_MSG)
+        });
+        trackUsage("didNotCreateEntry", { error: err, ...trackerProperty });
+        throw err;
+      }
+    },
+    [cloneDocument, trackUsage, toggleNotification, formatMessage, formatAPIError]
+  );
+  const [getDoc] = useLazyGetDocumentQuery();
+  const getDocument = React.useCallback(
+    async (args) => {
+      const { data } = await getDoc(args);
+      return data;
+    },
+    [getDoc]
+  );
+  return {
+    autoClone,
+    clone,
+    create,
+    delete: _delete,
+    discard,
+    getDocument,
+    publish,
+    unpublish,
+    update
+  };
+};
+const ProtectedHistoryPage = lazy(
+  () => import("./History-D6sbCJvo.mjs").then((mod) => ({ default: mod.ProtectedHistoryPage }))
+);
+const routes$1 = [
+  {
+    path: ":collectionType/:slug/:id/history",
+    Component: ProtectedHistoryPage
+  },
+  {
+    path: ":collectionType/:slug/history",
+    Component: ProtectedHistoryPage
+  }
+];
+const ProtectedEditViewPage = lazy(
+  () => import("./EditViewPage-Bm8lgcm6.mjs").then((mod) => ({ default: mod.ProtectedEditViewPage }))
+);
+const ProtectedListViewPage = lazy(
+  () => import("./ListViewPage-Be7S5aKL.mjs").then((mod) => ({ default: mod.ProtectedListViewPage }))
+);
+const ProtectedListConfiguration = lazy(
+  () => import("./ListConfigurationPage-Ce4qs7qE.mjs").then((mod) => ({
+    default: mod.ProtectedListConfiguration
+  }))
+);
+const ProtectedEditConfigurationPage = lazy(
+  () => import("./EditConfigurationPage-CUcGHHvQ.mjs").then((mod) => ({
+    default: mod.ProtectedEditConfigurationPage
+  }))
+);
+const ProtectedComponentConfigurationPage = lazy(
+  () => import("./ComponentConfigurationPage--2aLCv-G.mjs").then((mod) => ({
+    default: mod.ProtectedComponentConfigurationPage
+  }))
+);
+const NoPermissions = lazy(
+  () => import("./NoPermissionsPage-DhJ7LYrr.mjs").then((mod) => ({ default: mod.NoPermissions }))
+);
+const NoContentType = lazy(
+  () => import("./NoContentTypePage-CIPmYQMm.mjs").then((mod) => ({ default: mod.NoContentType }))
+);
+const CollectionTypePages = () => {
+  const { collectionType } = useParams();
+  if (collectionType !== COLLECTION_TYPES && collectionType !== SINGLE_TYPES) {
+    return /* @__PURE__ */ jsx(Navigate, { to: "/404" });
+  }
+  return collectionType === COLLECTION_TYPES ? /* @__PURE__ */ jsx(ProtectedListViewPage, {}) : /* @__PURE__ */ jsx(ProtectedEditViewPage, {});
+};
+const CLONE_RELATIVE_PATH = ":collectionType/:slug/clone/:origin";
+const CLONE_PATH = `/content-manager/${CLONE_RELATIVE_PATH}`;
+const LIST_RELATIVE_PATH = ":collectionType/:slug";
+const LIST_PATH = `/content-manager/${LIST_RELATIVE_PATH}`;
+const routes = [
+  {
+    path: LIST_RELATIVE_PATH,
+    element: /* @__PURE__ */ jsx(CollectionTypePages, {})
+  },
+  {
+    path: ":collectionType/:slug/:id",
+    Component: ProtectedEditViewPage
+  },
+  {
+    path: CLONE_RELATIVE_PATH,
+    Component: ProtectedEditViewPage
+  },
+  {
+    path: ":collectionType/:slug/configurations/list",
+    Component: ProtectedListConfiguration
+  },
+  {
+    path: "components/:slug/configurations/edit",
+    Component: ProtectedComponentConfigurationPage
+  },
+  {
+    path: ":collectionType/:slug/configurations/edit",
+    Component: ProtectedEditConfigurationPage
+  },
+  {
+    path: "403",
+    Component: NoPermissions
+  },
+  {
+    path: "no-content-types",
+    Component: NoContentType
+  },
+  ...routes$1
+];
+const DocumentActions = ({ actions: actions2 }) => {
+  const { formatMessage } = useIntl();
+  const [primaryAction, secondaryAction, ...restActions] = actions2.filter((action) => {
+    if (action.position === void 0) {
+      return true;
+    }
+    const positions = Array.isArray(action.position) ? action.position : [action.position];
+    return positions.includes("panel");
+  });
+  if (!primaryAction) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 2, alignItems: "stretch", width: "100%", children: [
+    /* @__PURE__ */ jsxs(Flex, { gap: 2, children: [
+      /* @__PURE__ */ jsx(DocumentActionButton, { ...primaryAction, variant: primaryAction.variant || "default" }),
+      restActions.length > 0 ? /* @__PURE__ */ jsx(
+        DocumentActionsMenu,
+        {
+          actions: restActions,
+          label: formatMessage({
+            id: "content-manager.containers.edit.panels.default.more-actions",
+            defaultMessage: "More document actions"
+          })
+        }
+      ) : null
+    ] }),
+    secondaryAction ? /* @__PURE__ */ jsx(
+      DocumentActionButton,
+      {
+        ...secondaryAction,
+        variant: secondaryAction.variant || "secondary"
+      }
+    ) : null
+  ] });
+};
+const DocumentActionButton = (action) => {
+  const [dialogId, setDialogId] = React.useState(null);
+  const { toggleNotification } = useNotification();
+  const handleClick = (action2) => async (e) => {
+    const { onClick = () => false, dialog, id } = action2;
+    const muteDialog = await onClick(e);
+    if (dialog && !muteDialog) {
+      switch (dialog.type) {
+        case "notification":
+          toggleNotification({
+            title: dialog.title,
+            message: dialog.content,
+            type: dialog.status,
+            timeout: dialog.timeout,
+            onClose: dialog.onClose
+          });
+          break;
+        case "dialog":
+        case "modal":
+          e.preventDefault();
+          setDialogId(id);
+      }
+    }
+  };
+  const handleClose = () => {
+    setDialogId(null);
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      Button,
+      {
+        flex: 1,
+        startIcon: action.icon,
+        disabled: action.disabled,
+        onClick: handleClick(action),
+        justifyContent: "center",
+        variant: action.variant || "default",
+        children: action.label
+      }
+    ),
+    action.dialog?.type === "dialog" ? /* @__PURE__ */ jsx(
+      DocumentActionConfirmDialog,
+      {
+        ...action.dialog,
+        variant: action.variant,
+        isOpen: dialogId === action.id,
+        onClose: handleClose
+      }
+    ) : null,
+    action.dialog?.type === "modal" ? /* @__PURE__ */ jsx(
+      DocumentActionModal,
+      {
+        ...action.dialog,
+        onModalClose: handleClose,
+        isOpen: dialogId === action.id
+      }
+    ) : null
+  ] });
+};
+const DocumentActionsMenu = ({
+  actions: actions2,
+  children,
+  label,
+  variant = "tertiary"
+}) => {
+  const [isOpen, setIsOpen] = React.useState(false);
+  const [dialogId, setDialogId] = React.useState(null);
+  const { formatMessage } = useIntl();
+  const { toggleNotification } = useNotification();
+  const isDisabled = actions2.every((action) => action.disabled) || actions2.length === 0;
+  const handleClick = (action) => async (e) => {
+    const { onClick = () => false, dialog, id } = action;
+    const muteDialog = await onClick(e);
+    if (dialog && !muteDialog) {
+      switch (dialog.type) {
+        case "notification":
+          toggleNotification({
+            title: dialog.title,
+            message: dialog.content,
+            type: dialog.status,
+            timeout: dialog.timeout,
+            onClose: dialog.onClose
+          });
+          break;
+        case "dialog":
+        case "modal":
+          setDialogId(id);
+      }
+    }
+  };
+  const handleClose = () => {
+    setDialogId(null);
+    setIsOpen(false);
+  };
+  return /* @__PURE__ */ jsxs(Menu.Root, { open: isOpen, onOpenChange: setIsOpen, children: [
+    /* @__PURE__ */ jsxs(
+      Menu.Trigger,
+      {
+        disabled: isDisabled,
+        size: "S",
+        endIcon: null,
+        paddingTop: "7px",
+        paddingLeft: "9px",
+        paddingRight: "9px",
+        variant,
+        children: [
+          /* @__PURE__ */ jsx(More, { "aria-hidden": true, focusable: false }),
+          /* @__PURE__ */ jsx(VisuallyHidden, { as: "span", children: label || formatMessage({
+            id: "content-manager.containers.edit.panels.default.more-actions",
+            defaultMessage: "More document actions"
+          }) })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs(Menu.Content, { top: "4px", maxHeight: void 0, popoverPlacement: "bottom-end", children: [
+      actions2.map((action) => {
+        return /* @__PURE__ */ jsx(
+          Menu.Item,
+          {
+            disabled: action.disabled,
+            onSelect: handleClick(action),
+            display: "block",
+            children: /* @__PURE__ */ jsxs(Flex, { justifyContent: "space-between", gap: 4, children: [
+              /* @__PURE__ */ jsxs(Flex, { color: convertActionVariantToColor(action.variant), gap: 2, as: "span", children: [
+                action.icon,
+                action.label
+              ] }),
+              action.id.startsWith("HistoryAction") && /* @__PURE__ */ jsx(
+                Flex,
+                {
+                  alignItems: "center",
+                  background: "alternative100",
+                  borderStyle: "solid",
+                  borderColor: "alternative200",
+                  borderWidth: "1px",
+                  height: 5,
+                  paddingLeft: 2,
+                  paddingRight: 2,
+                  hasRadius: true,
+                  color: "alternative600",
+                  children: /* @__PURE__ */ jsx(Typography, { variant: "sigma", fontWeight: "bold", lineHeight: 1, children: formatMessage({ id: "global.new", defaultMessage: "New" }) })
+                }
+              )
+            ] })
+          },
+          action.id
+        );
+      }),
+      children
+    ] }),
+    actions2.map((action) => {
+      return /* @__PURE__ */ jsxs(React.Fragment, { children: [
+        action.dialog?.type === "dialog" ? /* @__PURE__ */ jsx(
+          DocumentActionConfirmDialog,
+          {
+            ...action.dialog,
+            variant: action.variant,
+            isOpen: dialogId === action.id,
+            onClose: handleClose
+          }
+        ) : null,
+        action.dialog?.type === "modal" ? /* @__PURE__ */ jsx(
+          DocumentActionModal,
+          {
+            ...action.dialog,
+            onModalClose: handleClose,
+            isOpen: dialogId === action.id
+          }
+        ) : null
+      ] }, action.id);
+    })
+  ] });
+};
+const convertActionVariantToColor = (variant = "secondary") => {
+  switch (variant) {
+    case "danger":
+      return "danger600";
+    case "secondary":
+      return void 0;
+    case "success":
+      return "success600";
+    default:
+      return "primary600";
+  }
+};
+const DocumentActionConfirmDialog = ({
+  onClose,
+  onCancel,
+  onConfirm,
+  title,
+  content,
+  isOpen,
+  variant = "secondary"
+}) => {
+  const { formatMessage } = useIntl();
+  const handleClose = async () => {
+    if (onCancel) {
+      await onCancel();
+    }
+    onClose();
+  };
+  const handleConfirm = async () => {
+    if (onConfirm) {
+      await onConfirm();
+    }
+    onClose();
+  };
+  return /* @__PURE__ */ jsxs(Dialog, { isOpen, title, onClose: handleClose, children: [
+    /* @__PURE__ */ jsx(DialogBody, { children: content }),
+    /* @__PURE__ */ jsx(
+      DialogFooter,
+      {
+        startAction: /* @__PURE__ */ jsx(Button, { onClick: handleClose, variant: "tertiary", children: formatMessage({
+          id: "app.components.Button.cancel",
+          defaultMessage: "Cancel"
+        }) }),
+        endAction: /* @__PURE__ */ jsx(Button, { onClick: handleConfirm, variant, children: formatMessage({
+          id: "app.components.Button.confirm",
+          defaultMessage: "Confirm"
+        }) })
+      }
+    )
+  ] });
+};
+const DocumentActionModal = ({
+  isOpen,
+  title,
+  onClose,
+  footer: Footer,
+  content,
+  onModalClose
+}) => {
+  const id = React.useId();
+  if (!isOpen) {
+    return null;
+  }
+  const handleClose = () => {
+    if (onClose) {
+      onClose();
+    }
+    onModalClose();
+  };
+  return /* @__PURE__ */ jsxs(ModalLayout, { borderRadius: "4px", overflow: "hidden", onClose: handleClose, labelledBy: id, children: [
+    /* @__PURE__ */ jsx(ModalHeader, { children: /* @__PURE__ */ jsx(Typography, { fontWeight: "bold", textColor: "neutral800", as: "h2", id, children: title }) }),
+    /* @__PURE__ */ jsx(ModalBody, { children: content }),
+    /* @__PURE__ */ jsx(
+      Box,
+      {
+        paddingTop: 4,
+        paddingBottom: 4,
+        paddingLeft: 5,
+        paddingRight: 5,
+        borderWidth: "1px 0 0 0",
+        borderStyle: "solid",
+        borderColor: "neutral150",
+        background: "neutral100",
+        children: typeof Footer === "function" ? /* @__PURE__ */ jsx(Footer, { onClose: handleClose }) : Footer
+      }
+    )
+  ] });
+};
+const PublishAction = ({
+  activeTab,
+  documentId,
+  model,
+  collectionType,
+  meta,
+  document
+}) => {
+  const { schema } = useDoc();
+  const navigate = useNavigate();
+  const { toggleNotification } = useNotification();
+  const { _unstableFormatValidationErrors: formatValidationErrors } = useAPIErrorHandler();
+  const isCloning = useMatch(CLONE_PATH) !== null;
+  const { formatMessage } = useIntl();
+  const { canPublish, canCreate, canUpdate } = useDocumentRBAC(
+    "PublishAction",
+    ({ canPublish: canPublish2, canCreate: canCreate2, canUpdate: canUpdate2 }) => ({ canPublish: canPublish2, canCreate: canCreate2, canUpdate: canUpdate2 })
+  );
+  const { publish } = useDocumentActions();
+  const [{ query, rawQuery }] = useQueryParams();
+  const params = React.useMemo(() => buildValidParams(query), [query]);
+  const modified = useForm("PublishAction", ({ modified: modified2 }) => modified2);
+  const setSubmitting = useForm("PublishAction", ({ setSubmitting: setSubmitting2 }) => setSubmitting2);
+  const isSubmitting = useForm("PublishAction", ({ isSubmitting: isSubmitting2 }) => isSubmitting2);
+  const validate = useForm("PublishAction", (state) => state.validate);
+  const setErrors = useForm("PublishAction", (state) => state.setErrors);
+  const formValues = useForm("PublishAction", ({ values }) => values);
+  const isDocumentPublished = (document?.[PUBLISHED_AT_ATTRIBUTE_NAME] || meta?.availableStatus.some((doc) => doc[PUBLISHED_AT_ATTRIBUTE_NAME] !== null)) && document?.status !== "modified";
+  if (!schema?.options?.draftAndPublish) {
+    return null;
+  }
+  return {
+    /**
+     * Disabled when:
+     *  - currently if you're cloning a document we don't support publish & clone at the same time.
+     *  - the form is submitting
+     *  - the active tab is the published tab
+     *  - the document is already published & not modified
+     *  - the document is being created & not modified
+     *  - the user doesn't have the permission to publish
+     *  - the user doesn't have the permission to create a new document
+     *  - the user doesn't have the permission to update the document
+     */
+    disabled: isCloning || isSubmitting || activeTab === "published" || !modified && isDocumentPublished || !modified && !document?.documentId || !canPublish || Boolean(!document?.documentId && !canCreate || document?.documentId && !canUpdate),
+    label: formatMessage({
+      id: "app.utils.publish",
+      defaultMessage: "Publish"
+    }),
+    onClick: async () => {
+      setSubmitting(true);
+      try {
+        const { errors } = await validate();
+        if (errors) {
+          toggleNotification({
+            type: "danger",
+            message: formatMessage({
+              id: "content-manager.validation.error",
+              defaultMessage: "There are validation errors in your document. Please fix them before saving."
+            })
+          });
+          return;
+        }
+        const res = await publish(
+          {
+            collectionType,
+            model,
+            documentId,
+            params
+          },
+          formValues
+        );
+        if ("data" in res && collectionType !== SINGLE_TYPES) {
+          navigate({
+            pathname: `../${collectionType}/${model}/${res.data.documentId}`,
+            search: rawQuery
+          });
+        } else if ("error" in res && isBaseQueryError(res.error) && res.error.name === "ValidationError") {
+          setErrors(formatValidationErrors(res.error));
+        }
+      } finally {
+        setSubmitting(false);
+      }
+    }
+  };
+};
+PublishAction.type = "publish";
+const UpdateAction = ({
+  activeTab,
+  documentId,
+  model,
+  collectionType
+}) => {
+  const navigate = useNavigate();
+  const { toggleNotification } = useNotification();
+  const { _unstableFormatValidationErrors: formatValidationErrors } = useAPIErrorHandler();
+  const cloneMatch = useMatch(CLONE_PATH);
+  const isCloning = cloneMatch !== null;
+  const { formatMessage } = useIntl();
+  const { canCreate, canUpdate } = useDocumentRBAC("UpdateAction", ({ canCreate: canCreate2, canUpdate: canUpdate2 }) => ({
+    canCreate: canCreate2,
+    canUpdate: canUpdate2
+  }));
+  const { create, update, clone } = useDocumentActions();
+  const [{ query, rawQuery }] = useQueryParams();
+  const params = React.useMemo(() => buildValidParams(query), [query]);
+  const isSubmitting = useForm("UpdateAction", ({ isSubmitting: isSubmitting2 }) => isSubmitting2);
+  const modified = useForm("UpdateAction", ({ modified: modified2 }) => modified2);
+  const setSubmitting = useForm("UpdateAction", ({ setSubmitting: setSubmitting2 }) => setSubmitting2);
+  const document = useForm("UpdateAction", ({ values }) => values);
+  const validate = useForm("UpdateAction", (state) => state.validate);
+  const setErrors = useForm("UpdateAction", (state) => state.setErrors);
+  const resetForm = useForm("PublishAction", ({ resetForm: resetForm2 }) => resetForm2);
+  return {
+    /**
+     * Disabled when:
+     * - the form is submitting
+     * - the document is not modified & we're not cloning (you can save a clone entity straight away)
+     * - the active tab is the published tab
+     * - the user doesn't have the permission to create a new document
+     * - the user doesn't have the permission to update the document
+     */
+    disabled: isSubmitting || !modified && !isCloning || activeTab === "published" || Boolean(!documentId && !canCreate || documentId && !canUpdate),
+    label: formatMessage({
+      id: "content-manager.containers.Edit.save",
+      defaultMessage: "Save"
+    }),
+    onClick: async () => {
+      setSubmitting(true);
+      try {
+        const { errors } = await validate();
+        if (errors) {
+          toggleNotification({
+            type: "danger",
+            message: formatMessage({
+              id: "content-manager.validation.error",
+              defaultMessage: "There are validation errors in your document. Please fix them before saving."
+            })
+          });
+          return;
+        }
+        if (isCloning) {
+          const res = await clone(
+            {
+              model,
+              documentId: cloneMatch.params.origin,
+              params
+            },
+            document
+          );
+          if ("data" in res) {
+            navigate({
+              pathname: `../${collectionType}/${model}/${res.data.documentId}`,
+              search: rawQuery
+            });
+          } else if ("error" in res && isBaseQueryError(res.error) && res.error.name === "ValidationError") {
+            setErrors(formatValidationErrors(res.error));
+          }
+        } else if (documentId || collectionType === SINGLE_TYPES) {
+          const res = await update(
+            {
+              collectionType,
+              model,
+              documentId,
+              params
+            },
+            document
+          );
+          if ("error" in res && isBaseQueryError(res.error) && res.error.name === "ValidationError") {
+            setErrors(formatValidationErrors(res.error));
+          } else {
+            resetForm();
+          }
+        } else {
+          const res = await create(
+            {
+              model,
+              params
+            },
+            document
+          );
+          if ("data" in res && collectionType !== SINGLE_TYPES) {
+            navigate({
+              pathname: `../${collectionType}/${model}/${res.data.documentId}`,
+              search: rawQuery
+            });
+          } else if ("error" in res && isBaseQueryError(res.error) && res.error.name === "ValidationError") {
+            setErrors(formatValidationErrors(res.error));
+          }
+        }
+      } finally {
+        setSubmitting(false);
+      }
+    }
+  };
+};
+UpdateAction.type = "update";
+const UNPUBLISH_DRAFT_OPTIONS = {
+  KEEP: "keep",
+  DISCARD: "discard"
+};
+const UnpublishAction = ({
+  activeTab,
+  documentId,
+  model,
+  collectionType,
+  document
+}) => {
+  const { formatMessage } = useIntl();
+  const { schema } = useDoc();
+  const canPublish = useDocumentRBAC("UnpublishAction", ({ canPublish: canPublish2 }) => canPublish2);
+  const { unpublish } = useDocumentActions();
+  const [{ query }] = useQueryParams();
+  const params = React.useMemo(() => buildValidParams(query), [query]);
+  const { toggleNotification } = useNotification();
+  const [shouldKeepDraft, setShouldKeepDraft] = React.useState(true);
+  const isDocumentModified = document?.status === "modified";
+  const handleChange = (e) => {
+    if ("value" in e.target) {
+      setShouldKeepDraft(e.target.value === UNPUBLISH_DRAFT_OPTIONS.KEEP);
+    }
+  };
+  if (!schema?.options?.draftAndPublish) {
+    return null;
+  }
+  return {
+    disabled: !canPublish || activeTab === "published" || document?.status !== "published" && document?.status !== "modified",
+    label: formatMessage({
+      id: "app.utils.unpublish",
+      defaultMessage: "Unpublish"
+    }),
+    icon: /* @__PURE__ */ jsx(StyledCrossCircle, {}),
+    onClick: async () => {
+      if (!documentId && collectionType !== SINGLE_TYPES || isDocumentModified) {
+        if (!documentId) {
+          console.error(
+            "You're trying to unpublish a document without an id, this is likely a bug with Strapi. Please open an issue."
+          );
+          toggleNotification({
+            message: formatMessage({
+              id: "content-manager.actions.unpublish.error",
+              defaultMessage: "An error occurred while trying to unpublish the document."
+            }),
+            type: "danger"
+          });
+        }
+        return;
+      }
+      await unpublish({
+        collectionType,
+        model,
+        documentId,
+        params
+      });
+    },
+    dialog: isDocumentModified ? {
+      type: "dialog",
+      title: formatMessage({
+        id: "app.components.ConfirmDialog.title",
+        defaultMessage: "Confirmation"
+      }),
+      content: /* @__PURE__ */ jsxs(Flex, { alignItems: "flex-start", direction: "column", gap: 6, children: [
+        /* @__PURE__ */ jsxs(Flex, { width: "100%", direction: "column", gap: 2, children: [
+          /* @__PURE__ */ jsx(WarningCircle, { width: "24px", height: "24px", fill: "danger600" }),
+          /* @__PURE__ */ jsx(Typography, { as: "p", variant: "omega", textAlign: "center", children: formatMessage({
+            id: "content-manager.actions.unpublish.dialog.body",
+            defaultMessage: "Are you sure?"
+          }) })
+        ] }),
+        /* @__PURE__ */ jsxs(
+          Flex,
+          {
+            onChange: handleChange,
+            direction: "column",
+            alignItems: "flex-start",
+            as: "fieldset",
+            gap: 3,
+            children: [
+              /* @__PURE__ */ jsx(VisuallyHidden, { as: "legend" }),
+              /* @__PURE__ */ jsx(
+                Radio,
+                {
+                  checked: shouldKeepDraft,
+                  value: UNPUBLISH_DRAFT_OPTIONS.KEEP,
+                  name: "discard-options",
+                  children: formatMessage({
+                    id: "content-manager.actions.unpublish.dialog.option.keep-draft",
+                    defaultMessage: "Keep draft"
+                  })
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                Radio,
+                {
+                  checked: !shouldKeepDraft,
+                  value: UNPUBLISH_DRAFT_OPTIONS.DISCARD,
+                  name: "discard-options",
+                  children: formatMessage({
+                    id: "content-manager.actions.unpublish.dialog.option.replace-draft",
+                    defaultMessage: "Replace draft"
+                  })
+                }
+              )
+            ]
+          }
+        )
+      ] }),
+      onConfirm: async () => {
+        if (!documentId && collectionType !== SINGLE_TYPES) {
+          console.error(
+            "You're trying to unpublish a document without an id, this is likely a bug with Strapi. Please open an issue."
+          );
+          toggleNotification({
+            message: formatMessage({
+              id: "content-manager.actions.unpublish.error",
+              defaultMessage: "An error occurred while trying to unpublish the document."
+            }),
+            type: "danger"
+          });
+        }
+        await unpublish(
+          {
+            collectionType,
+            model,
+            documentId,
+            params
+          },
+          !shouldKeepDraft
+        );
+      }
+    } : void 0,
+    variant: "danger",
+    position: ["panel", "table-row"]
+  };
+};
+UnpublishAction.type = "unpublish";
+const DiscardAction = ({
+  activeTab,
+  documentId,
+  model,
+  collectionType,
+  document
+}) => {
+  const { formatMessage } = useIntl();
+  const { schema } = useDoc();
+  const canUpdate = useDocumentRBAC("DiscardAction", ({ canUpdate: canUpdate2 }) => canUpdate2);
+  const { discard } = useDocumentActions();
+  const [{ query }] = useQueryParams();
+  const params = React.useMemo(() => buildValidParams(query), [query]);
+  if (!schema?.options?.draftAndPublish) {
+    return null;
+  }
+  return {
+    disabled: !canUpdate || activeTab === "published" || document?.status !== "modified",
+    label: formatMessage({
+      id: "content-manager.actions.discard.label",
+      defaultMessage: "Discard changes"
+    }),
+    icon: /* @__PURE__ */ jsx(StyledCrossCircle, {}),
+    position: ["panel", "table-row"],
+    variant: "danger",
+    dialog: {
+      type: "dialog",
+      title: formatMessage({
+        id: "app.components.ConfirmDialog.title",
+        defaultMessage: "Confirmation"
+      }),
+      content: /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 2, children: [
+        /* @__PURE__ */ jsx(WarningCircle, { width: "24px", height: "24px", fill: "danger600" }),
+        /* @__PURE__ */ jsx(Typography, { as: "p", variant: "omega", textAlign: "center", children: formatMessage({
+          id: "content-manager.actions.discard.dialog.body",
+          defaultMessage: "Are you sure?"
+        }) })
+      ] }),
+      onConfirm: async () => {
+        await discard({
+          collectionType,
+          model,
+          documentId,
+          params
+        });
+      }
+    }
+  };
+};
+DiscardAction.type = "discard";
+const StyledCrossCircle = styled(CrossCircle)`
+  path {
+    fill: currentColor;
+  }
+`;
+const DEFAULT_ACTIONS = [PublishAction, UpdateAction, UnpublishAction, DiscardAction];
+const intervals = ["years", "months", "days", "hours", "minutes", "seconds"];
+const RelativeTime = React.forwardRef(
+  ({ timestamp, customIntervals = [], ...restProps }, forwardedRef) => {
+    const { formatRelativeTime, formatDate, formatTime } = useIntl();
+    const interval = intervalToDuration({
+      start: timestamp,
+      end: Date.now()
+      // see https://github.com/date-fns/date-fns/issues/2891 – No idea why it's all partial it returns it every time.
+    });
+    const unit = intervals.find((intervalUnit) => {
+      return interval[intervalUnit] > 0 && Object.keys(interval).includes(intervalUnit);
+    });
+    const relativeTime = isPast(timestamp) ? -interval[unit] : interval[unit];
+    const customInterval = customIntervals.find(
+      (custom) => interval[custom.unit] < custom.threshold
+    );
+    const displayText = customInterval ? customInterval.text : formatRelativeTime(relativeTime, unit, { numeric: "auto" });
+    return /* @__PURE__ */ jsx(
+      "time",
+      {
+        ref: forwardedRef,
+        dateTime: timestamp.toISOString(),
+        role: "time",
+        title: `${formatDate(timestamp)} ${formatTime(timestamp)}`,
+        ...restProps,
+        children: displayText
+      }
+    );
+  }
+);
+const getDisplayName = ({
+  firstname,
+  lastname,
+  username,
+  email
+} = {}) => {
+  if (username) {
+    return username;
+  }
+  if (firstname) {
+    return `${firstname} ${lastname ?? ""}`.trim();
+  }
+  return email ?? "";
+};
+const capitalise = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+const DocumentStatus = ({ status = "draft", ...restProps }) => {
+  const statusVariant = status === "draft" ? "primary" : status === "published" ? "success" : "alternative";
+  return /* @__PURE__ */ jsx(Status, { ...restProps, showBullet: false, size: "S", variant: statusVariant, children: /* @__PURE__ */ jsx(Typography, { as: "span", variant: "omega", fontWeight: "bold", children: capitalise(status) }) });
+};
+const Header = ({ isCreating, status, title: documentTitle = "Untitled" }) => {
+  const { formatMessage } = useIntl();
+  const isCloning = useMatch(CLONE_PATH) !== null;
+  const title = isCreating ? formatMessage({
+    id: "content-manager.containers.edit.title.new",
+    defaultMessage: "Create an entry"
+  }) : documentTitle;
+  return /* @__PURE__ */ jsxs(Flex, { direction: "column", alignItems: "flex-start", paddingTop: 8, paddingBottom: 4, gap: 3, children: [
+    /* @__PURE__ */ jsx(BackButton, {}),
+    /* @__PURE__ */ jsxs(
+      Flex,
+      {
+        width: "100%",
+        justifyContent: "space-between",
+        paddingTop: 1,
+        gap: "80px",
+        alignItems: "flex-start",
+        children: [
+          /* @__PURE__ */ jsx(Typography, { variant: "alpha", as: "h1", children: title }),
+          /* @__PURE__ */ jsx(HeaderToolbar, {})
+        ]
+      }
+    ),
+    status ? /* @__PURE__ */ jsx(DocumentStatus, { status: isCloning ? "draft" : status }) : null
+  ] });
+};
+const HeaderToolbar = () => {
+  const { formatMessage } = useIntl();
+  const isCloning = useMatch(CLONE_PATH) !== null;
+  const [
+    {
+      query: { status = "draft" }
+    }
+  ] = useQueryParams();
+  const { model, id, document, meta, collectionType } = useDoc();
+  const plugins = useStrapiApp("HeaderToolbar", (state) => state.plugins);
+  return /* @__PURE__ */ jsxs(Flex, { gap: 2, children: [
+    /* @__PURE__ */ jsx(
+      DescriptionComponentRenderer,
+      {
+        props: {
+          activeTab: status,
+          model,
+          documentId: id,
+          document: isCloning ? void 0 : document,
+          meta: isCloning ? void 0 : meta,
+          collectionType
+        },
+        descriptions: plugins["content-manager"].apis.getHeaderActions(),
+        children: (actions2) => {
+          if (actions2.length > 0) {
+            return /* @__PURE__ */ jsx(HeaderActions, { actions: actions2 });
+          } else {
+            return null;
+          }
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      DescriptionComponentRenderer,
+      {
+        props: {
+          activeTab: status,
+          model,
+          documentId: id,
+          document: isCloning ? void 0 : document,
+          meta: isCloning ? void 0 : meta,
+          collectionType
+        },
+        descriptions: plugins["content-manager"].apis.getDocumentActions(),
+        children: (actions2) => {
+          const headerActions = actions2.filter((action) => {
+            const positions = Array.isArray(action.position) ? action.position : [action.position];
+            return positions.includes("header");
+          });
+          return /* @__PURE__ */ jsx(
+            DocumentActionsMenu,
+            {
+              actions: headerActions,
+              label: formatMessage({
+                id: "content-manager.containers.edit.header.more-actions",
+                defaultMessage: "More actions"
+              }),
+              children: /* @__PURE__ */ jsx(Information, { activeTab: status })
+            }
+          );
+        }
+      }
+    )
+  ] });
+};
+const Information = ({ activeTab }) => {
+  const { formatMessage } = useIntl();
+  const { document, meta } = useDoc();
+  if (!document || !document.id) {
+    return null;
+  }
+  const createAndUpdateDocument = activeTab === "draft" ? document : meta?.availableStatus.find((status) => status.publishedAt === null);
+  const publishDocument = activeTab === "published" ? document : meta?.availableStatus.find((status) => status.publishedAt !== null);
+  const creator = createAndUpdateDocument?.[CREATED_BY_ATTRIBUTE_NAME] ? getDisplayName(createAndUpdateDocument[CREATED_BY_ATTRIBUTE_NAME]) : null;
+  const updator = createAndUpdateDocument?.[UPDATED_BY_ATTRIBUTE_NAME] ? getDisplayName(createAndUpdateDocument[UPDATED_BY_ATTRIBUTE_NAME]) : null;
+  const information = [
+    {
+      isDisplayed: !!publishDocument?.[PUBLISHED_AT_ATTRIBUTE_NAME],
+      label: formatMessage({
+        id: "content-manager.containers.edit.information.last-published.label",
+        defaultMessage: "Last published"
+      }),
+      value: formatMessage(
+        {
+          id: "content-manager.containers.edit.information.last-published.value",
+          defaultMessage: `Published {time}{isAnonymous, select, true {} other { by {author}}}`
+        },
+        {
+          time: /* @__PURE__ */ jsx(RelativeTime, { timestamp: new Date(publishDocument?.[PUBLISHED_AT_ATTRIBUTE_NAME]) }),
+          isAnonymous: !publishDocument?.[PUBLISHED_BY_ATTRIBUTE_NAME],
+          author: publishDocument?.[PUBLISHED_BY_ATTRIBUTE_NAME] ? getDisplayName(publishDocument?.[PUBLISHED_BY_ATTRIBUTE_NAME]) : null
+        }
+      )
+    },
+    {
+      isDisplayed: !!createAndUpdateDocument?.[UPDATED_AT_ATTRIBUTE_NAME],
+      label: formatMessage({
+        id: "content-manager.containers.edit.information.last-draft.label",
+        defaultMessage: "Last draft"
+      }),
+      value: formatMessage(
+        {
+          id: "content-manager.containers.edit.information.last-draft.value",
+          defaultMessage: `Modified {time}{isAnonymous, select, true {} other { by {author}}}`
+        },
+        {
+          time: /* @__PURE__ */ jsx(
+            RelativeTime,
+            {
+              timestamp: new Date(createAndUpdateDocument?.[UPDATED_AT_ATTRIBUTE_NAME])
+            }
+          ),
+          isAnonymous: !updator,
+          author: updator
+        }
+      )
+    },
+    {
+      isDisplayed: !!createAndUpdateDocument?.[CREATED_AT_ATTRIBUTE_NAME],
+      label: formatMessage({
+        id: "content-manager.containers.edit.information.document.label",
+        defaultMessage: "Document"
+      }),
+      value: formatMessage(
+        {
+          id: "content-manager.containers.edit.information.document.value",
+          defaultMessage: `Created {time}{isAnonymous, select, true {} other { by {author}}}`
+        },
+        {
+          time: /* @__PURE__ */ jsx(
+            RelativeTime,
+            {
+              timestamp: new Date(createAndUpdateDocument?.[CREATED_AT_ATTRIBUTE_NAME])
+            }
+          ),
+          isAnonymous: !creator,
+          author: creator
+        }
+      )
+    }
+  ].filter((info) => info.isDisplayed);
+  return /* @__PURE__ */ jsx(
+    Flex,
+    {
+      borderWidth: "1px 0 0 0",
+      borderStyle: "solid",
+      borderColor: "neutral150",
+      direction: "column",
+      marginTop: 2,
+      as: "dl",
+      padding: 5,
+      gap: 3,
+      alignItems: "flex-start",
+      marginLeft: "-0.4rem",
+      marginRight: "-0.4rem",
+      width: "calc(100% + 8px)",
+      children: information.map((info) => /* @__PURE__ */ jsxs(Flex, { gap: 1, direction: "column", alignItems: "flex-start", children: [
+        /* @__PURE__ */ jsx(Typography, { as: "dt", variant: "pi", fontWeight: "bold", children: info.label }),
+        /* @__PURE__ */ jsx(Typography, { as: "dd", variant: "pi", textColor: "neutral600", children: info.value })
+      ] }, info.label))
+    }
+  );
+};
+const HeaderActions = ({ actions: actions2 }) => {
+  return /* @__PURE__ */ jsx(Flex, { children: actions2.map((action) => {
+    if ("options" in action) {
+      return /* @__PURE__ */ jsx(
+        SingleSelect,
+        {
+          size: "S",
+          disabled: action.disabled,
+          "aria-label": action.label,
+          onChange: action.onSelect,
+          value: action.value,
+          children: action.options.map(({ label, ...option }) => /* @__PURE__ */ jsx(SingleSelectOption, { ...option, children: label }, option.value))
+        },
+        action.id
+      );
+    } else {
+      return null;
+    }
+  }) });
+};
+const ConfigureTheViewAction = ({ collectionType, model }) => {
+  const navigate = useNavigate();
+  const { formatMessage } = useIntl();
+  return {
+    label: formatMessage({
+      id: "app.links.configure-view",
+      defaultMessage: "Configure the view"
+    }),
+    icon: /* @__PURE__ */ jsx(StyledCog, {}),
+    onClick: () => {
+      navigate(`../${collectionType}/${model}/configurations/edit`);
+    },
+    position: "header"
+  };
+};
+ConfigureTheViewAction.type = "configure-the-view";
+const StyledCog = styled(Cog)`
+  path {
+    fill: currentColor;
+  }
+`;
+const EditTheModelAction = ({ model }) => {
+  const navigate = useNavigate();
+  const { formatMessage } = useIntl();
+  return {
+    label: formatMessage({
+      id: "content-manager.link-to-ctb",
+      defaultMessage: "Edit the model"
+    }),
+    icon: /* @__PURE__ */ jsx(StyledPencil$1, {}),
+    onClick: () => {
+      navigate(`/plugins/content-type-builder/content-types/${model}`);
+    },
+    position: "header"
+  };
+};
+EditTheModelAction.type = "edit-the-model";
+const StyledPencil$1 = styled(Pencil)`
+  path {
+    fill: currentColor;
+  }
+`;
+const DeleteAction = ({ documentId, model, collectionType, document }) => {
+  const navigate = useNavigate();
+  const { formatMessage } = useIntl();
+  const listViewPathMatch = useMatch(LIST_PATH);
+  const canDelete = useDocumentRBAC("DeleteAction", (state) => state.canDelete);
+  const { delete: deleteAction } = useDocumentActions();
+  const { toggleNotification } = useNotification();
+  const setSubmitting = useForm("DeleteAction", (state) => state.setSubmitting);
+  return {
+    disabled: !canDelete || !document,
+    label: formatMessage({
+      id: "content-manager.actions.delete.label",
+      defaultMessage: "Delete document"
+    }),
+    icon: /* @__PURE__ */ jsx(StyledTrash, {}),
+    dialog: {
+      type: "dialog",
+      title: formatMessage({
+        id: "app.components.ConfirmDialog.title",
+        defaultMessage: "Confirmation"
+      }),
+      content: /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 2, children: [
+        /* @__PURE__ */ jsx(WarningCircle, { width: "24px", height: "24px", fill: "danger600" }),
+        /* @__PURE__ */ jsx(Typography, { as: "p", variant: "omega", textAlign: "center", children: formatMessage({
+          id: "content-manager.actions.delete.dialog.body",
+          defaultMessage: "Are you sure?"
+        }) })
+      ] }),
+      onConfirm: async () => {
+        if (!listViewPathMatch) {
+          setSubmitting(true);
+        }
+        try {
+          if (!documentId && collectionType !== SINGLE_TYPES) {
+            console.error(
+              "You're trying to delete a document without an id, this is likely a bug with Strapi. Please open an issue."
+            );
+            toggleNotification({
+              message: formatMessage({
+                id: "content-manager.actions.delete.error",
+                defaultMessage: "An error occurred while trying to delete the document."
+              }),
+              type: "danger"
+            });
+            return;
+          }
+          const res = await deleteAction({
+            documentId,
+            model,
+            collectionType,
+            params: {
+              locale: "*"
+            }
+          });
+          if (!("error" in res)) {
+            navigate({ pathname: `../${collectionType}/${model}` }, { replace: true });
+          }
+        } finally {
+          if (!listViewPathMatch) {
+            setSubmitting(false);
+          }
+        }
+      }
+    },
+    variant: "danger",
+    position: ["header", "table-row"]
+  };
+};
+DeleteAction.type = "delete";
+const StyledTrash = styled(Trash)`
+  path {
+    fill: currentColor;
+  }
+`;
+const DEFAULT_HEADER_ACTIONS = [EditTheModelAction, ConfigureTheViewAction, DeleteAction];
+const Panels = () => {
+  const isCloning = useMatch(CLONE_PATH) !== null;
+  const [
+    {
+      query: { status }
+    }
+  ] = useQueryParams({
+    status: "draft"
+  });
+  const { model, id, document, meta, collectionType } = useDoc();
+  const plugins = useStrapiApp("Panels", (state) => state.plugins);
+  const props = {
+    activeTab: status,
+    model,
+    documentId: id,
+    document: isCloning ? void 0 : document,
+    meta: isCloning ? void 0 : meta,
+    collectionType
+  };
+  return /* @__PURE__ */ jsx(Flex, { direction: "column", alignItems: "stretch", gap: 2, children: /* @__PURE__ */ jsx(
+    DescriptionComponentRenderer,
+    {
+      props,
+      descriptions: plugins["content-manager"].apis.getEditViewSidePanels(),
+      children: (panels) => panels.map(({ content, id: id2, ...description }) => /* @__PURE__ */ jsx(Panel, { ...description, children: content }, id2))
+    }
+  ) });
+};
+const ActionsPanel = () => {
+  const { formatMessage } = useIntl();
+  return {
+    title: formatMessage({
+      id: "content-manager.containers.edit.panels.default.title",
+      defaultMessage: "Document"
+    }),
+    content: /* @__PURE__ */ jsx(ActionsPanelContent, {})
+  };
+};
+ActionsPanel.type = "actions";
+const ActionsPanelContent = () => {
+  const isCloning = useMatch(CLONE_PATH) !== null;
+  const [
+    {
+      query: { status = "draft" }
+    }
+  ] = useQueryParams();
+  const { model, id, document, meta, collectionType } = useDoc();
+  const plugins = useStrapiApp("ActionsPanel", (state) => state.plugins);
+  const props = {
+    activeTab: status,
+    model,
+    documentId: id,
+    document: isCloning ? void 0 : document,
+    meta: isCloning ? void 0 : meta,
+    collectionType
+  };
+  return /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 2, width: "100%", children: [
+    /* @__PURE__ */ jsx(
+      DescriptionComponentRenderer,
+      {
+        props,
+        descriptions: plugins["content-manager"].apis.getDocumentActions(),
+        children: (actions2) => /* @__PURE__ */ jsx(DocumentActions, { actions: actions2 })
+      }
+    ),
+    /* @__PURE__ */ jsx(InjectionZone, { area: "editView.right-links", slug: model })
+  ] });
+};
+const Panel = React.forwardRef(({ children, title }, ref) => {
+  return /* @__PURE__ */ jsxs(
+    Flex,
+    {
+      ref,
+      as: "aside",
+      "aria-labelledby": "additional-information",
+      background: "neutral0",
+      borderColor: "neutral150",
+      hasRadius: true,
+      paddingBottom: 4,
+      paddingLeft: 4,
+      paddingRight: 4,
+      paddingTop: 4,
+      shadow: "tableShadow",
+      gap: 3,
+      direction: "column",
+      justifyContent: "stretch",
+      alignItems: "flex-start",
+      children: [
+        /* @__PURE__ */ jsx(Typography, { as: "h2", variant: "sigma", textTransform: "uppercase", children: title }),
+        children
+      ]
+    }
+  );
+});
+const DEFAULT_BULK_ACTIONS = [];
+const AutoCloneFailureModalBody = ({ prohibitedFields }) => {
+  const { formatMessage } = useIntl();
+  const getDefaultErrorMessage = (reason) => {
+    switch (reason) {
+      case "relation":
+        return "Duplicating the relation could remove it from the original entry.";
+      case "unique":
+        return "Identical values in a unique field are not allowed";
+      default:
+        return reason;
+    }
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Typography, { variant: "beta", children: formatMessage({
+      id: getTranslation("containers.list.autoCloneModal.title"),
+      defaultMessage: "This entry can't be duplicated directly."
+    }) }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 2, children: /* @__PURE__ */ jsx(Typography, { textColor: "neutral600", children: formatMessage({
+      id: getTranslation("containers.list.autoCloneModal.description"),
+      defaultMessage: "A new entry will be created with the same content, but you'll have to change the following fields to save it."
+    }) }) }),
+    /* @__PURE__ */ jsx(Flex, { marginTop: 6, gap: 2, direction: "column", alignItems: "stretch", children: prohibitedFields.map(([fieldPath, reason]) => /* @__PURE__ */ jsxs(
+      Flex,
+      {
+        direction: "column",
+        gap: 2,
+        alignItems: "flex-start",
+        borderColor: "neutral200",
+        hasRadius: true,
+        padding: 6,
+        children: [
+          /* @__PURE__ */ jsx(Flex, { direction: "row", as: "ol", children: fieldPath.map((pathSegment, index2) => /* @__PURE__ */ jsxs(Typography, { fontWeight: "semiBold", as: "li", children: [
+            pathSegment,
+            index2 !== fieldPath.length - 1 && /* @__PURE__ */ jsx(
+              ChevronRight,
+              {
+                fill: "neutral500",
+                height: "0.8rem",
+                width: "0.8rem",
+                style: { margin: "0 0.8rem" }
+              }
+            )
+          ] }, index2)) }),
+          /* @__PURE__ */ jsx(Typography, { as: "p", textColor: "neutral600", children: formatMessage({
+            id: getTranslation(`containers.list.autoCloneModal.error.${reason}`),
+            defaultMessage: getDefaultErrorMessage(reason)
+          }) })
+        ]
+      },
+      fieldPath.join()
+    )) })
+  ] });
+};
+const TableActions = ({ document }) => {
+  const { formatMessage } = useIntl();
+  const { model, collectionType } = useDoc();
+  const plugins = useStrapiApp("TableActions", (state) => state.plugins);
+  const props = {
+    activeTab: null,
+    model,
+    documentId: document.documentId,
+    collectionType,
+    document
+  };
+  return /* @__PURE__ */ jsx(
+    DescriptionComponentRenderer,
+    {
+      props,
+      descriptions: plugins["content-manager"].apis.getDocumentActions(),
+      children: (actions2) => {
+        const tableRowActions = actions2.filter((action) => {
+          const positions = Array.isArray(action.position) ? action.position : [action.position];
+          return positions.includes("table-row");
+        });
+        return /* @__PURE__ */ jsx(
+          DocumentActionsMenu,
+          {
+            actions: tableRowActions,
+            label: formatMessage({
+              id: "content-manager.containers.list.table.row-actions",
+              defaultMessage: "Row action"
+            }),
+            variant: "ghost"
+          }
+        );
+      }
+    }
+  );
+};
+const EditAction = ({ documentId }) => {
+  const navigate = useNavigate();
+  const { formatMessage } = useIntl();
+  const { canRead } = useDocumentRBAC("EditAction", ({ canRead: canRead2 }) => ({ canRead: canRead2 }));
+  const { toggleNotification } = useNotification();
+  const [{ query }] = useQueryParams();
+  return {
+    disabled: !canRead,
+    icon: /* @__PURE__ */ jsx(StyledPencil, {}),
+    label: formatMessage({
+      id: "content-manager.actions.edit.label",
+      defaultMessage: "Edit"
+    }),
+    position: "table-row",
+    onClick: async () => {
+      if (!documentId) {
+        console.error(
+          "You're trying to edit a document without an id, this is likely a bug with Strapi. Please open an issue."
+        );
+        toggleNotification({
+          message: formatMessage({
+            id: "content-manager.actions.edit.error",
+            defaultMessage: "An error occurred while trying to edit the document."
+          }),
+          type: "danger"
+        });
+        return;
+      }
+      navigate({
+        pathname: documentId,
+        search: stringify({
+          plugins: query.plugins
+        })
+      });
+    }
+  };
+};
+EditAction.type = "edit";
+const StyledPencil = styled(Pencil)`
+  path {
+    fill: currentColor;
+  }
+`;
+const CloneAction = ({ model, documentId }) => {
+  const navigate = useNavigate();
+  const { formatMessage } = useIntl();
+  const { canCreate } = useDocumentRBAC("CloneAction", ({ canCreate: canCreate2 }) => ({ canCreate: canCreate2 }));
+  const { toggleNotification } = useNotification();
+  const { autoClone } = useDocumentActions();
+  const [prohibitedFields, setProhibitedFields] = React.useState([]);
+  return {
+    disabled: !canCreate,
+    icon: /* @__PURE__ */ jsx(StyledDuplicate, {}),
+    label: formatMessage({
+      id: "content-manager.actions.clone.label",
+      defaultMessage: "Duplicate"
+    }),
+    position: "table-row",
+    onClick: async () => {
+      if (!documentId) {
+        console.error(
+          "You're trying to clone a document in the table without an id, this is likely a bug with Strapi. Please open an issue."
+        );
+        toggleNotification({
+          message: formatMessage({
+            id: "content-manager.actions.clone.error",
+            defaultMessage: "An error occurred while trying to clone the document."
+          }),
+          type: "danger"
+        });
+        return;
+      }
+      const res = await autoClone({ model, sourceId: documentId });
+      if ("data" in res) {
+        navigate(res.data.documentId);
+        return true;
+      }
+      if (isBaseQueryError(res.error) && res.error.details && typeof res.error.details === "object" && "prohibitedFields" in res.error.details && Array.isArray(res.error.details.prohibitedFields)) {
+        const prohibitedFields2 = res.error.details.prohibitedFields;
+        setProhibitedFields(prohibitedFields2);
+      }
+    },
+    dialog: {
+      type: "modal",
+      title: formatMessage({
+        id: "content-manager.containers.list.autoCloneModal.header",
+        defaultMessage: "Duplicate"
+      }),
+      content: /* @__PURE__ */ jsx(AutoCloneFailureModalBody, { prohibitedFields }),
+      footer: ({ onClose }) => {
+        return /* @__PURE__ */ jsxs(Flex, { justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsx(Button, { onClick: onClose, variant: "tertiary", children: formatMessage({
+            id: "cancel",
+            defaultMessage: "Cancel"
+          }) }),
+          /* @__PURE__ */ jsx(
+            LinkButton,
+            {
+              as: NavLink,
+              to: {
+                pathname: `clone/${documentId}`
+              },
+              children: formatMessage({
+                id: "content-manager.containers.list.autoCloneModal.create",
+                defaultMessage: "Create"
+              })
+            }
+          )
+        ] });
+      }
+    }
+  };
+};
+CloneAction.type = "clone";
+const StyledDuplicate = styled(Duplicate)`
+  path {
+    fill: currentColor;
+  }
+`;
+const DEFAULT_TABLE_ROW_ACTIONS = [EditAction, CloneAction];
+class ContentManagerPlugin {
+  /**
+   * The following properties are the stored ones provided by any plugins registering with
+   * the content-manager. The function calls however, need to be called at runtime in the
+   * application, so instead we collate them and run them later with the complete list incl.
+   * ones already registered & the context of the view.
+   */
+  bulkActions = [...DEFAULT_BULK_ACTIONS];
+  documentActions = [
+    ...DEFAULT_ACTIONS,
+    ...DEFAULT_TABLE_ROW_ACTIONS,
+    ...DEFAULT_HEADER_ACTIONS,
+    HistoryAction
+  ];
+  editViewSidePanels = [ActionsPanel];
+  headerActions = [];
+  constructor() {
+  }
+  addEditViewSidePanel(panels) {
+    if (Array.isArray(panels)) {
+      this.editViewSidePanels = [...this.editViewSidePanels, ...panels];
+    } else if (typeof panels === "function") {
+      this.editViewSidePanels = panels(this.editViewSidePanels);
+    } else {
+      throw new Error(
+        `Expected the \`panels\` passed to \`addEditViewSidePanel\` to be an array or a function, but received ${getPrintableType(
+          panels
+        )}`
+      );
+    }
+  }
+  addDocumentAction(actions2) {
+    if (Array.isArray(actions2)) {
+      this.documentActions = [...this.documentActions, ...actions2];
+    } else if (typeof actions2 === "function") {
+      this.documentActions = actions2(this.documentActions);
+    } else {
+      throw new Error(
+        `Expected the \`actions\` passed to \`addDocumentAction\` to be an array or a function, but received ${getPrintableType(
+          actions2
+        )}`
+      );
+    }
+  }
+  addDocumentHeaderAction(actions2) {
+    if (Array.isArray(actions2)) {
+      this.headerActions = [...this.headerActions, ...actions2];
+    } else if (typeof actions2 === "function") {
+      this.headerActions = actions2(this.headerActions);
+    } else {
+      throw new Error(
+        `Expected the \`actions\` passed to \`addDocumentHeaderAction\` to be an array or a function, but received ${getPrintableType(
+          actions2
+        )}`
+      );
+    }
+  }
+  addBulkAction(actions2) {
+    if (Array.isArray(actions2)) {
+      this.bulkActions = [...this.bulkActions, ...actions2];
+    } else if (typeof actions2 === "function") {
+      this.bulkActions = actions2(this.bulkActions);
+    } else {
+      throw new Error(
+        `Expected the \`actions\` passed to \`addBulkAction\` to be an array or a function, but received ${getPrintableType(
+          actions2
+        )}`
+      );
+    }
+  }
+  get config() {
+    return {
+      id: PLUGIN_ID,
+      name: "Content Manager",
+      injectionZones: INJECTION_ZONES,
+      apis: {
+        addBulkAction: this.addBulkAction.bind(this),
+        addDocumentAction: this.addDocumentAction.bind(this),
+        addDocumentHeaderAction: this.addDocumentHeaderAction.bind(this),
+        addEditViewSidePanel: this.addEditViewSidePanel.bind(this),
+        getBulkActions: () => this.bulkActions,
+        getDocumentActions: () => this.documentActions,
+        getEditViewSidePanels: () => this.editViewSidePanels,
+        getHeaderActions: () => this.headerActions
+      }
+    };
+  }
+}
+const getPrintableType = (value) => {
+  const nativeType = typeof value;
+  if (nativeType === "object") {
+    if (value === null)
+      return "null";
+    if (Array.isArray(value))
+      return "array";
+    if (value instanceof Object && value.constructor.name !== "Object") {
+      return value.constructor.name;
+    }
+  }
+  return nativeType;
+};
+const initialState = {
+  collectionTypeLinks: [],
+  components: [],
+  fieldSizes: {},
+  models: [],
+  singleTypeLinks: [],
+  isLoading: true
+};
+const appSlice = createSlice({
+  name: "app",
+  initialState,
+  reducers: {
+    setInitialData(state, action) {
+      const {
+        authorizedCollectionTypeLinks,
+        authorizedSingleTypeLinks,
+        components,
+        contentTypeSchemas,
+        fieldSizes
+      } = action.payload;
+      state.collectionTypeLinks = authorizedCollectionTypeLinks.filter(
+        ({ isDisplayed }) => isDisplayed
+      );
+      state.singleTypeLinks = authorizedSingleTypeLinks.filter(({ isDisplayed }) => isDisplayed);
+      state.components = components;
+      state.models = contentTypeSchemas;
+      state.fieldSizes = fieldSizes;
+      state.isLoading = false;
+    }
+  }
+});
+const { actions, reducer: reducer$1 } = appSlice;
+const { setInitialData } = actions;
+const reducer = combineReducers({
+  app: reducer$1
+});
+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 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 checkIfAttributeIsDisplayable = (attribute) => {
+  const { type } = attribute;
+  if (type === "relation") {
+    return !attribute.relation.toLowerCase().includes("morph");
+  }
+  return !["json", "dynamiczone", "richtext", "password", "blocks"].includes(type) && !!type;
+};
+const getMainField = (attribute, mainFieldName, { schemas, components }) => {
+  if (!mainFieldName) {
+    return void 0;
+  }
+  const mainFieldType = attribute.type === "component" ? components[attribute.component].attributes[mainFieldName].type : (
+    // @ts-expect-error – `targetModel` does exist on the attribute for a relation.
+    schemas.find((schema) => schema.uid === attribute.targetModel)?.attributes[mainFieldName].type
+  );
+  return {
+    name: mainFieldName,
+    type: mainFieldType ?? "string"
+  };
+};
+const DEFAULT_SETTINGS = {
+  bulkable: false,
+  filterable: false,
+  searchable: false,
+  pagination: false,
+  defaultSortBy: "",
+  defaultSortOrder: "asc",
+  mainField: "id",
+  pageSize: 10
+};
+const useDocumentLayout = (model) => {
+  const { schema, components } = useDocument({ model, collectionType: "" }, { skip: true });
+  const [{ query }] = useQueryParams();
+  const runHookWaterfall = useStrapiApp("useDocumentLayout", (state) => state.runHookWaterfall);
+  const { toggleNotification } = useNotification();
+  const { _unstableFormatAPIError: formatAPIError } = useAPIErrorHandler();
+  const { isLoading: isLoadingSchemas, schemas } = useContentTypeSchema();
+  const {
+    data,
+    isLoading: isLoadingConfigs,
+    error,
+    isFetching: isFetchingConfigs
+  } = useGetContentTypeConfigurationQuery(model);
+  const isLoading = isLoadingSchemas || isFetchingConfigs || isLoadingConfigs;
+  React.useEffect(() => {
+    if (error) {
+      toggleNotification({
+        type: "danger",
+        message: formatAPIError(error)
+      });
+    }
+  }, [error, formatAPIError, toggleNotification]);
+  const editLayout = React.useMemo(
+    () => data && !isLoading ? formatEditLayout(data, { schemas, schema, components }) : {
+      layout: [],
+      components: {},
+      metadatas: {},
+      options: {},
+      settings: DEFAULT_SETTINGS
+    },
+    [data, isLoading, schemas, schema, components]
+  );
+  const listLayout = React.useMemo(() => {
+    return data && !isLoading ? formatListLayout(data, { schemas, schema, components }) : {
+      layout: [],
+      metadatas: {},
+      options: {},
+      settings: DEFAULT_SETTINGS
+    };
+  }, [data, isLoading, schemas, schema, components]);
+  const { layout: edit } = React.useMemo(
+    () => runHookWaterfall(HOOKS.MUTATE_EDIT_VIEW_LAYOUT, {
+      layout: editLayout,
+      query
+    }),
+    [editLayout, query, runHookWaterfall]
+  );
+  return {
+    error,
+    isLoading,
+    edit,
+    list: listLayout
+  };
+};
+const useDocLayout = () => {
+  const { model } = useDoc();
+  return useDocumentLayout(model);
+};
+const formatEditLayout = (data, {
+  schemas,
+  schema,
+  components
+}) => {
+  let currentPanelIndex = 0;
+  const panelledEditAttributes = convertEditLayoutToFieldLayouts(
+    data.contentType.layouts.edit,
+    schema?.attributes,
+    data.contentType.metadatas,
+    { configurations: data.components, schemas: components },
+    schemas
+  ).reduce((panels, row) => {
+    if (row.some((field) => field.type === "dynamiczone")) {
+      panels.push([row]);
+      currentPanelIndex += 2;
+    } else {
+      if (!panels[currentPanelIndex]) {
+        panels.push([]);
+      }
+      panels[currentPanelIndex].push(row);
+    }
+    return panels;
+  }, []);
+  const componentEditAttributes = Object.entries(data.components).reduce(
+    (acc, [uid, configuration]) => {
+      acc[uid] = {
+        layout: convertEditLayoutToFieldLayouts(
+          configuration.layouts.edit,
+          components[uid].attributes,
+          configuration.metadatas
+        ),
+        settings: {
+          ...configuration.settings,
+          icon: components[uid].info.icon,
+          displayName: components[uid].info.displayName
+        }
+      };
+      return acc;
+    },
+    {}
+  );
+  const editMetadatas = Object.entries(data.contentType.metadatas).reduce(
+    (acc, [attribute, metadata]) => {
+      return {
+        ...acc,
+        [attribute]: metadata.edit
+      };
+    },
+    {}
+  );
+  return {
+    layout: panelledEditAttributes,
+    components: componentEditAttributes,
+    metadatas: editMetadatas,
+    settings: {
+      ...data.contentType.settings,
+      displayName: schema?.info.displayName
+    },
+    options: {
+      ...schema?.options,
+      ...schema?.pluginOptions,
+      ...data.contentType.options
+    }
+  };
+};
+const convertEditLayoutToFieldLayouts = (rows, attributes = {}, metadatas, components, schemas = []) => {
+  return rows.map(
+    (row) => row.map((field) => {
+      const attribute = attributes[field.name];
+      if (!attribute) {
+        return null;
+      }
+      const { edit: metadata } = metadatas[field.name];
+      const settings = attribute.type === "component" && components ? components.configurations[attribute.component].settings : {};
+      return {
+        attribute,
+        disabled: !metadata.editable,
+        hint: metadata.description,
+        label: metadata.label ?? "",
+        name: field.name,
+        // @ts-expect-error – mainField does exist on the metadata for a relation.
+        mainField: getMainField(attribute, metadata.mainField || settings.mainField, {
+          schemas,
+          components: components?.schemas ?? {}
+        }),
+        placeholder: metadata.placeholder ?? "",
+        required: attribute.required ?? false,
+        size: field.size,
+        unique: "unique" in attribute ? attribute.unique : false,
+        visible: metadata.visible ?? true,
+        type: attribute.type
+      };
+    }).filter((field) => field !== null)
+  );
+};
+const formatListLayout = (data, {
+  schemas,
+  schema,
+  components
+}) => {
+  const listMetadatas = Object.entries(data.contentType.metadatas).reduce(
+    (acc, [attribute, metadata]) => {
+      return {
+        ...acc,
+        [attribute]: metadata.list
+      };
+    },
+    {}
+  );
+  const listAttributes = convertListLayoutToFieldLayouts(
+    data.contentType.layouts.list,
+    schema?.attributes,
+    listMetadatas,
+    { configurations: data.components, schemas: components },
+    schemas
+  );
+  return {
+    layout: listAttributes,
+    settings: { ...data.contentType.settings, displayName: schema?.info.displayName },
+    metadatas: listMetadatas,
+    options: {
+      ...schema?.options,
+      ...schema?.pluginOptions,
+      ...data.contentType.options
+    }
+  };
+};
+const convertListLayoutToFieldLayouts = (columns, attributes = {}, metadatas, components, schemas = []) => {
+  return columns.map((name) => {
+    const attribute = attributes[name];
+    if (!attribute) {
+      return null;
+    }
+    const metadata = metadatas[name];
+    const settings = attribute.type === "component" && components ? components.configurations[attribute.component].settings : {};
+    return {
+      attribute,
+      label: metadata.label ?? "",
+      mainField: getMainField(attribute, metadata.mainField || settings.mainField, {
+        schemas,
+        components: components?.schemas ?? {}
+      }),
+      name,
+      searchable: metadata.searchable ?? true,
+      sortable: metadata.sortable ?? true
+    };
+  }).filter((field) => field !== null);
+};
+const index = {
+  register(app) {
+    const cm = new ContentManagerPlugin();
+    app.addReducers({
+      [contentManagerApi.reducerPath]: contentManagerApi.reducer,
+      [PLUGIN_ID]: reducer
+    });
+    app.addMiddlewares([() => contentManagerApi.middleware]);
+    app.addMenuLink({
+      to: PLUGIN_ID,
+      icon: Feather,
+      intlLabel: {
+        id: `content-manager.plugin.name`,
+        defaultMessage: "Content Manager"
+      },
+      permissions: [],
+      Component: () => import("./layout-Dnh0PNp9.mjs").then((mod) => ({ default: mod.Layout }))
+    });
+    app.registerPlugin(cm.config);
+  },
+  async registerTrads({ locales }) {
+    const importedTrads = await Promise.all(
+      locales.map((locale) => {
+        return __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "./translations/ar.json": () => import("./ar-CCEVvqGG.mjs"), "./translations/ca.json": () => import("./ca-5U32ON2v.mjs"), "./translations/cs.json": () => import("./cs-CM2aBUar.mjs"), "./translations/de.json": () => import("./de-C72KDNOl.mjs"), "./translations/en.json": () => import("./en-MBPul9Su.mjs"), "./translations/es.json": () => import("./es-CeXiYflN.mjs"), "./translations/eu.json": () => import("./eu-CdALomew.mjs"), "./translations/fr.json": () => import("./fr-CD9VFbPM.mjs"), "./translations/gu.json": () => import("./gu-CNpaMDpH.mjs"), "./translations/hi.json": () => import("./hi-Dwvd04m3.mjs"), "./translations/hu.json": () => import("./hu-CeYvaaO0.mjs"), "./translations/id.json": () => import("./id-BtwA9WJT.mjs"), "./translations/it.json": () => import("./it-BrVPqaf1.mjs"), "./translations/ja.json": () => import("./ja-CtsUxOvk.mjs"), "./translations/ko.json": () => import("./ko-HVQRlfUI.mjs"), "./translations/ml.json": () => import("./ml-BihZwQit.mjs"), "./translations/ms.json": () => import("./ms-m_WjyWx7.mjs"), "./translations/nl.json": () => import("./nl-D4R9gHx5.mjs"), "./translations/pl.json": () => import("./pl-sbx9mSt_.mjs"), "./translations/pt-BR.json": () => import("./pt-BR-C71iDxnh.mjs"), "./translations/pt.json": () => import("./pt-BsaFvS8-.mjs"), "./translations/ru.json": () => import("./ru-BE6A4Exp.mjs"), "./translations/sa.json": () => import("./sa-Dag0k-Z8.mjs"), "./translations/sk.json": () => import("./sk-BFg-R8qJ.mjs"), "./translations/sv.json": () => import("./sv-CUnfWGsh.mjs"), "./translations/th.json": () => import("./th-BqbI8lIT.mjs"), "./translations/tr.json": () => import("./tr-CgeK3wJM.mjs"), "./translations/uk.json": () => import("./uk-CR-zDhAY.mjs"), "./translations/vi.json": () => import("./vi-DUXIk_fw.mjs"), "./translations/zh-Hans.json": () => import("./zh-Hans-BPQcRIyH.mjs"), "./translations/zh.json": () => import("./zh-BWZspA60.mjs") }), `./translations/${locale}.json`).then(({ default: data }) => {
+          return {
+            data: prefixPluginTranslations(data, PLUGIN_ID),
+            locale
+          };
+        }).catch(() => {
+          return {
+            data: {},
+            locale
+          };
+        });
+      })
+    );
+    return Promise.resolve(importedTrads);
+  }
+};
+export {
+  ATTRIBUTE_TYPES_THAT_CANNOT_BE_MAIN_FIELD as A,
+  extractContentTypeComponents as B,
+  COLLECTION_TYPES as C,
+  DocumentStatus as D,
+  DEFAULT_SETTINGS as E,
+  convertEditLayoutToFieldLayouts as F,
+  useDocument as G,
+  HOOKS as H,
+  InjectionZone as I,
+  index as J,
+  useDocumentActions as K,
+  Panels as P,
+  RelativeTime as R,
+  SINGLE_TYPES as S,
+  TableActions as T,
+  useGetAllContentTypeSettingsQuery as a,
+  useDoc as b,
+  buildValidParams as c,
+  contentManagerApi as d,
+  useDocumentRBAC as e,
+  useDocumentLayout as f,
+  getTranslation as g,
+  createYupSchema as h,
+  Header as i,
+  PERMISSIONS as j,
+  DocumentRBAC as k,
+  DOCUMENT_META_FIELDS as l,
+  useDocLayout as m,
+  useContentTypeSchema as n,
+  useGetContentTypeConfigurationQuery as o,
+  CREATOR_FIELDS as p,
+  getMainField as q,
+  routes as r,
+  setInitialData as s,
+  getDisplayName as t,
+  useGetInitialDataQuery as u,
+  checkIfAttributeIsDisplayable as v,
+  useGetAllDocumentsQuery as w,
+  convertListLayoutToFieldLayouts as x,
+  capitalise as y,
+  useUpdateContentTypeConfigurationMutation as z
+};
+//# sourceMappingURL=index-DNVx8ssZ.mjs.map