@strapi/admin 4.20.5 → 5.0.0-alpha.1

package/dist/admin/src/content-manager/hooks/useDocument.d.ts

@@ -0,0 +1,85 @@
+/**
+ * This hook doesn't use a context provider because we fetch directly from the server,
+ * this sounds expensive but actually, it's really not. Because we have redux-toolkit-query
+ * being a cache layer so if nothing invalidates the cache, we don't fetch again.
+ */
+import { TranslationMessage } from '@strapi/helper-plugin';
+import { useGetDocumentQuery } from '../services/documents';
+import { ComponentsDictionary } from './useContentTypeSchema';
+import type { Contracts } from '@strapi/plugin-content-manager/_internal/shared';
+interface UseDocumentArgs {
+    collectionType: string;
+    model: string;
+    documentId?: string;
+    params?: object;
+}
+type UseDocumentOpts = Parameters<typeof useGetDocumentQuery>[1];
+type Document = Contracts.CollectionTypes.FindOne.Response['data'];
+type Schema = Contracts.ContentTypes.ContentType;
+type UseDocument = (args: UseDocumentArgs, opts?: UseDocumentOpts) => {
+    /**
+     * These are the schemas of the components used in the content type, organised
+     * by their uid.
+     */
+    components: ComponentsDictionary;
+    document?: Document;
+    meta?: Contracts.CollectionTypes.FindOne.Response['meta'];
+    isLoading: boolean;
+    /**
+     * This is the schema of the content type, it is not the same as the layout.
+     */
+    schema?: Schema;
+    validate: (document: Document) => null | Record<string, TranslationMessage>;
+};
+/**
+ * @alpha
+ * @public
+ * @description Returns a document based on the model, collection type & id passed as arguments.
+ * Also extracts its schema from the redux cache to be used for creating a validation schema.
+ * @example
+ * ```tsx
+ * const { id, model, collectionType } = useParams<{ id: string; model: string; collectionType: string }>();
+ *
+ * if(!model || !collectionType) return null;
+ *
+ * const { document, isLoading, validate } = useDocument({ documentId: id, model, collectionType, params: { locale: 'en-GB' } })
+ * const { update } = useDocumentActions()
+ *
+ * const onSubmit = async (document: Document) => {
+ *  const errors = validate(document);
+ *
+ *  if(errors) {
+ *      // handle errors
+ *  }
+ *
+ *  await update({ collectionType, model, id }, document)
+ * }
+ * ```
+ *
+ * @see {@link https://contributor.strapi.io/docs/core/content-manager/hooks/use-document} for more information
+ */
+declare const useDocument: UseDocument;
+/**
+ * @internal this hook uses the router to extract the model, collection type & id from the url.
+ * therefore, it shouldn't be used outside of the content-manager because it won't work as intended.
+ */
+declare const useDoc: () => {
+    /**
+     * These are the schemas of the components used in the content type, organised
+     * by their uid.
+     */
+    components: ComponentsDictionary;
+    document?: import("@strapi/types/dist/modules/documents").AnyDocument | undefined;
+    meta?: Contracts.CollectionTypes.DocumentMetadata | undefined;
+    isLoading: boolean;
+    /**
+     * This is the schema of the content type, it is not the same as the layout.
+     */
+    schema?: Contracts.ContentTypes.ContentType | undefined;
+    validate: (document: Document) => null | Record<string, TranslationMessage>;
+    collectionType: string;
+    model: string;
+    id: string | undefined;
+};
+export { useDocument, useDoc };
+export type { UseDocument, UseDocumentArgs, Document, Schema, ComponentsDictionary };

package/dist/admin/src/content-manager/hooks/useDocumentActions.d.ts

@@ -0,0 +1,102 @@
+import { SerializedError } from '@reduxjs/toolkit';
+import { TrackingEvent } from '../../features/Tracking';
+import { BaseQueryError } from '../../utils/baseQuery';
+import type { Document } from './useDocument';
+import type { Contracts } from '@strapi/plugin-content-manager/_internal/shared';
+type OperationResponse<TResponse extends {
+    data: any;
+    meta: any;
+    error?: any;
+}> = Pick<TResponse, 'data' | 'meta'> | {
+    error: BaseQueryError | SerializedError;
+};
+type UseDocumentActions = () => {
+    /**
+     * @description Attempts to clone a document based on the provided sourceId.
+     * This will return a list of the fields as an error if it's unable to clone.
+     * You most likely want to use the `clone` action instead.
+     */
+    autoClone: (args: {
+        model: string;
+        sourceId: string;
+    }) => Promise<OperationResponse<Contracts.CollectionTypes.AutoClone.Response>>;
+    clone: (args: {
+        model: string;
+        documentId: string;
+        params?: object;
+    }, document: Omit<Document, 'id'>, trackerProperty?: Extract<TrackingEvent, {
+        name: 'willCreateEntry' | 'didCreateEntry' | 'didNotCreateEntry';
+    }>['properties']) => Promise<OperationResponse<Contracts.CollectionTypes.Clone.Response>>;
+    create: (args: {
+        model: string;
+        params?: object;
+    }, document: Omit<Document, 'id'>, trackerProperty?: Extract<TrackingEvent, {
+        name: 'willCreateEntry' | 'didCreateEntry' | 'didNotCreateEntry';
+    }>['properties']) => Promise<OperationResponse<Contracts.CollectionTypes.Create.Response>>;
+    delete: (args: {
+        collectionType: string;
+        model: string;
+        documentId?: string;
+        params?: object;
+    }, trackerProperty?: Extract<TrackingEvent, {
+        name: 'willDeleteEntry' | 'didDeleteEntry' | 'didNotDeleteEntry';
+    }>['properties']) => Promise<OperationResponse<Contracts.CollectionTypes.Delete.Response>>;
+    discard: (args: {
+        collectionType: string;
+        model: string;
+        documentId?: string;
+        params?: object;
+    }) => Promise<OperationResponse<Contracts.CollectionTypes.Discard.Response>>;
+    getDocument: (args: {
+        collectionType: string;
+        model: string;
+        documentId?: string;
+        params?: object;
+    }) => Promise<Contracts.CollectionTypes.FindOne.Response | undefined>;
+    publish: (args: {
+        collectionType: string;
+        model: string;
+        documentId?: string;
+        params?: object;
+    }, document: Partial<Document>) => Promise<OperationResponse<Contracts.CollectionTypes.Publish.Response>>;
+    update: (args: {
+        collectionType: string;
+        model: string;
+        documentId?: string;
+        params?: object;
+    }, document: Partial<Document>, trackerProperty?: Extract<TrackingEvent, {
+        name: 'willEditEntry' | 'didEditEntry' | 'didNotEditEntry';
+    }>['properties']) => Promise<OperationResponse<Contracts.CollectionTypes.Update.Response>>;
+    unpublish: (args: {
+        collectionType: string;
+        model: string;
+        documentId?: string;
+        params?: object;
+    }, discardDraft?: boolean) => Promise<OperationResponse<Contracts.CollectionTypes.Unpublish.Response>>;
+};
+/**
+ * @alpha
+ * @public
+ * @description Contains all the operations that can be performed on a single document.
+ * Designed to be able to be used anywhere within a Strapi app. The hooks will handle
+ * notifications should the operation fail, however the response is always returned incase
+ * the user needs to handle side-effects.
+ * @example
+ * ```tsx
+ * import { Form } from '@strapi/admin/admin';
+ *
+ * const { id, model, collectionType } = useParams<{ id: string; model: string; collectionType: string }>();
+ * const { update } = useDocumentActions();
+ *
+ * const handleSubmit = async (data) => {
+ *  await update({ collectionType, model, documentId: id }, data);
+ * }
+ *
+ * return <Form method="PUT" onSubmit={handleSubmit} />
+ * ```
+ *
+ * @see {@link https://contributor.strapi.io/docs/core/content-manager/hooks/use-document-operations} for more information
+ */
+declare const useDocumentActions: UseDocumentActions;
+export { useDocumentActions };
+export type { UseDocumentActions, OperationResponse };

package/dist/admin/src/content-manager/hooks/useDocumentLayout.d.ts

@@ -0,0 +1,138 @@
+import { SerializedError } from '@reduxjs/toolkit';
+import { BaseQueryError } from '../../utils/baseQuery';
+import { type ComponentsDictionary, type Document, type Schema } from './useDocument';
+import type { Filters } from '../../components/Filters';
+import type { InputProps } from '../../components/FormInputs/types';
+import type { Table } from '../../components/Table';
+import type { Contracts } from '@strapi/plugin-content-manager/_internal/shared';
+import type { Attribute } from '@strapi/types';
+type LayoutOptions = Schema['options'] & Schema['pluginOptions'] & object;
+interface LayoutSettings extends Contracts.ContentTypes.Settings {
+    displayName?: string;
+    icon?: never;
+}
+interface ListFieldLayout extends Table.Header<Document, ListFieldLayout>, Pick<Filters.Filter, 'mainField'> {
+    attribute: Attribute.Any | {
+        type: 'custom';
+    };
+}
+interface ListLayout {
+    layout: ListFieldLayout[];
+    components?: never;
+    metadatas: {
+        [K in keyof Contracts.ContentTypes.Metadatas]: Contracts.ContentTypes.Metadatas[K]['list'];
+    };
+    options: LayoutOptions;
+    settings: LayoutSettings;
+}
+interface EditFieldSharedProps extends Omit<InputProps, 'hint' | 'label' | 'type'>, Pick<Filters.Filter, 'mainField'> {
+    hint?: string;
+    label: string;
+    size: number;
+    unique?: boolean;
+    visible?: boolean;
+}
+/**
+ * Map over all the types in Attribute Types and use that to create a union of new types where the attribute type
+ * is under the property attribute and the type is under the property type.
+ */
+type EditFieldLayout = {
+    [K in Attribute.Kind]: EditFieldSharedProps & {
+        attribute: Extract<Attribute.Any, {
+            type: K;
+        }>;
+        type: K;
+    };
+}[Attribute.Kind];
+interface EditLayout {
+    layout: Array<Array<EditFieldLayout[]>>;
+    components: {
+        [uid: string]: {
+            layout: Array<EditFieldLayout[]>;
+            settings: Contracts.Components.ComponentConfiguration['settings'] & {
+                displayName?: string;
+                icon?: string;
+            };
+        };
+    };
+    metadatas: {
+        [K in keyof Contracts.ContentTypes.Metadatas]: Contracts.ContentTypes.Metadatas[K]['edit'];
+    };
+    options: LayoutOptions;
+    settings: LayoutSettings;
+}
+type UseDocumentLayout = (model: string) => {
+    error?: BaseQueryError | SerializedError;
+    isLoading: boolean;
+    /**
+     * This is the layout for the edit view,
+     */
+    edit: EditLayout;
+    list: ListLayout;
+};
+declare const DEFAULT_SETTINGS: {
+    bulkable: boolean;
+    filterable: boolean;
+    searchable: boolean;
+    pagination: boolean;
+    defaultSortBy: string;
+    defaultSortOrder: string;
+    mainField: string;
+    pageSize: number;
+};
+/**
+ * @alpha
+ * @description This hook is used to get the layouts for either the edit view or list view of a specific content-type
+ * including the layouts for the components used in the content-type. It also runs the mutation hook waterfall so the data
+ * is consistent wherever it is used. It's a light wrapper around the `useDocument` hook, but provides the `skip` option a document
+ * is not fetched, however, it does fetch the schemas & components if they do not already exist in the cache.
+ *
+ * If the fetch fails, it will display a notification to the user.
+ *
+ * @example
+ * ```tsx
+ * const { model } = useParams<{ model: string }>();
+ * const { edit: { schema: layout } } = useDocumentLayout(model);
+ *
+ * return layout.map(panel => panel.map(row => row.map(field => <Field {...field} />)))
+ * ```
+ *
+ */
+declare const useDocumentLayout: UseDocumentLayout;
+/**
+ * @internal this hook uses the internal useDoc hook, as such it shouldn't be used outside of the
+ * content-manager because it won't work as intended.
+ */
+declare const useDocLayout: () => {
+    error?: BaseQueryError | SerializedError | undefined;
+    isLoading: boolean;
+    /**
+     * This is the layout for the edit view,
+     */
+    edit: EditLayout;
+    list: ListLayout;
+};
+type LayoutData = Contracts.ContentTypes.FindContentTypeConfiguration.Response['data'];
+/**
+ * @internal
+ * @description takes the edit layout from either a content-type or a component
+ * and formats it into a generic object that can be used to correctly render
+ * the form fields.
+ */
+declare const convertEditLayoutToFieldLayouts: (rows: LayoutData['contentType']['layouts']['edit'], attributes: import("@strapi/types/dist/types/core/schemas").Attributes | undefined, metadatas: Contracts.ContentTypes.Metadatas, components?: {
+    configurations: Record<string, Contracts.Components.ComponentConfiguration>;
+    schemas: ComponentsDictionary;
+} | undefined, schemas?: Schema[]) => EditFieldLayout[][];
+/**
+ * @internal
+ * @description takes the columns from the list view configuration and formats them into a generic object
+ * combinining metadata and attribute data.
+ *
+ * @note We do use this to reformat the list of strings when updating the displayed headers for the list view.
+ */
+declare const convertListLayoutToFieldLayouts: (columns: LayoutData['contentType']['layouts']['list'], attributes: import("@strapi/types/dist/types/core/schemas").Attributes | undefined, metadatas: ListLayout['metadatas'], components?: {
+    configurations: Record<string, Contracts.Components.ComponentConfiguration>;
+    schemas: ComponentsDictionary;
+} | undefined, schemas?: Schema[]) => ListFieldLayout[];
+export { useDocLayout, useDocumentLayout, convertListLayoutToFieldLayouts, convertEditLayoutToFieldLayouts, DEFAULT_SETTINGS, };
+export type { EditLayout, EditFieldLayout, ListLayout, ListFieldLayout, UseDocumentLayout };

package/dist/admin/src/content-manager/hooks/useDragAndDrop.d.ts

@@ -23,7 +23,7 @@ interface UseDragAndDropOptions<TIndex extends number | Array<number> = number,
     dropSensitivity?: (typeof DROP_SENSITIVITY)[keyof typeof DROP_SENSITIVITY];
 }
 type Identifier = ReturnType<HandlerManager['getHandlerId']>;
-type UseDragAndDropReturn = [
+type UseDragAndDropReturn<Element extends HTMLElement = HTMLElement> = [
     props: {
         handlerId: Identifier;
         isDragging: boolean;
@@ -31,7 +31,7 @@ type UseDragAndDropReturn = [
         isOverDropTarget: boolean;
         direction: (typeof DIRECTIONS)[keyof typeof DIRECTIONS] | null;
     },
-    objectRef: React.RefObject<HTMLElement>,
+    objectRef: React.RefObject<Element>,
     dropRef: ConnectDropTarget,
     dragRef: ConnectDragSource,
     dragPreviewRef: ConnectDragPreview
@@ -44,5 +44,8 @@ declare const useDragAndDrop: <TIndex extends number | number[], TItem extends {
     [key: string]: unknown;
     index: TIndex;
     id?: Entity.ID | undefined;
-}>(active: boolean, { type, index, item, onStart, onEnd, onGrabItem, onDropItem, onCancel, onMoveItem, dropSensitivity, }: UseDragAndDropOptions<TIndex, TItem>) => UseDragAndDropReturn;
+} = {
+    [key: string]: unknown;
+    index: TIndex;
+}, Element_1 extends HTMLElement = HTMLElement>(active: boolean, { type, index, item, onStart, onEnd, onGrabItem, onDropItem, onCancel, onMoveItem, dropSensitivity, }: UseDragAndDropOptions<TIndex, TItem>) => UseDragAndDropReturn<Element_1>;
 export { useDragAndDrop, UseDragAndDropReturn, UseDragAndDropOptions, DIRECTIONS, DROP_SENSITIVITY, };

package/dist/admin/src/content-manager/hooks/useSyncRbac.d.ts

@@ -1,28 +1,15 @@
-import { Permission } from '@strapi/helper-plugin';
-import type { RBACState } from '../../components/RBACProvider';
-declare const useSyncRbac: (query: {
+import type { Permission } from '@strapi/helper-plugin';
+type UseSyncRbac = (uid: string, query: {
     plugins?: object;
-}, collectionTypeUID: string, containerName?: string) => {
-    isValid: boolean;
-    permissions: Permission[] | null;
+}, containerName?: string) => {
+    isLoading: boolean;
+    isError: boolean;
+    permissions?: Permission[];
 };
-interface SyncRbacState {
-    permissions: RBACState['collectionTypesRelatedPermissions'][string][string] | null;
-}
-declare const SET_PERMISSIONS = "ContentManager/RBACManager/SET_PERMISSIONS";
-declare const RESET_PERMISSIONS = "ContentManager/RBACManager/RESET_PERMISSIONS";
-interface SetPermissionsAction {
-    type: typeof SET_PERMISSIONS;
-    permissions: RBACState['collectionTypesRelatedPermissions'][string];
-    __meta__?: {
-        plugins: object;
-        containerName: string;
-    };
-}
-interface ResetPermissionsAction {
-    type: typeof RESET_PERMISSIONS;
-}
-type Action = SetPermissionsAction | ResetPermissionsAction;
-declare const reducer: (state: SyncRbacState | undefined, action: Action) => SyncRbacState;
-export { useSyncRbac, reducer };
-export type { SyncRbacState, RBACState };
+/**
+ * TODO: figure out how to get rid of this. It's a bit of a weird hack to mutate permissions only
+ * for the content-manager, if we devise a better way to handle RBAC in the entire app then this
+ * can probably go...
+ */
+declare const useSyncRbac: UseSyncRbac;
+export { useSyncRbac };

package/dist/admin/src/content-manager/layout.d.ts

@@ -0,0 +1,16 @@
+import { AnyAction } from '@reduxjs/toolkit';
+import type { ContentManagerLink } from './hooks/useContentManagerInitData';
+import type { Contracts } from '@strapi/plugin-content-manager/_internal/shared';
+declare const Layout: () => import("react/jsx-runtime").JSX.Element;
+export declare const SET_INIT_DATA = "ContentManager/App/SET_INIT_DATA";
+interface ContentManagerAppState {
+    collectionTypeLinks: ContentManagerLink[];
+    components: Contracts.Init.GetInitData.Response['data']['components'];
+    fieldSizes: Contracts.Init.GetInitData.Response['data']['fieldSizes'];
+    models: Contracts.Init.GetInitData.Response['data']['contentTypes'];
+    singleTypeLinks: ContentManagerLink[];
+    isLoading: boolean;
+}
+declare const reducer: (state: ContentManagerAppState | undefined, action: AnyAction) => ContentManagerAppState;
+export { Layout, reducer };
+export type { ContentManagerAppState };

package/dist/admin/src/content-manager/modules/rbac.d.ts

@@ -0,0 +1,14 @@
+import type { Permission } from '@strapi/helper-plugin';
+interface SyncRbacState {
+    permissions: Permission[] | undefined;
+}
+declare const reducer: import("redux").Reducer<SyncRbacState>;
+declare const setPermissions: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    permissions: Record<string, Permission[]>;
+    __meta__?: {
+        plugins?: object | undefined;
+        containerName: string;
+    } | undefined;
+}, "rbac/setPermissions">, resetPermissions: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"rbac/resetPermissions">;
+export { reducer, setPermissions, resetPermissions };
+export type { SyncRbacState };

package/dist/admin/src/content-manager/modules/reducers.d.ts

@@ -0,0 +1,4 @@
+declare const reducer: import("redux").Reducer<import("redux").CombinedState<{
+    rbac: import("./rbac").SyncRbacState;
+}>, import("redux").AnyAction>;
+export { reducer };

package/dist/admin/src/content-manager/pages/ComponentConfigurationPage.d.ts

@@ -0,0 +1,3 @@
+declare const ComponentConfigurationPage: () => import("react/jsx-runtime").JSX.Element;
+declare const ProtectedComponentConfigurationPage: () => import("react/jsx-runtime").JSX.Element;
+export { ComponentConfigurationPage, ProtectedComponentConfigurationPage };

package/dist/admin/src/content-manager/pages/EditConfigurationPage.d.ts

@@ -0,0 +1,3 @@
+declare const EditConfigurationPage: () => import("react/jsx-runtime").JSX.Element;
+declare const ProtectedEditConfigurationPage: () => import("react/jsx-runtime").JSX.Element;
+export { ProtectedEditConfigurationPage, EditConfigurationPage };

package/dist/admin/src/content-manager/pages/EditView/EditViewPage.d.ts

@@ -1,18 +1,3 @@
-import { Permission, AllowedActions } from '@strapi/helper-plugin';
-import { RouteComponentProps } from 'react-router-dom';
-interface EditViewPageParams {
-    collectionType: string;
-    slug: string;
-    id?: string;
-    origin?: string;
-}
-interface EditViewPageProps extends RouteComponentProps<EditViewPageParams> {
-    allowedActions: AllowedActions;
-    userPermissions?: Permission[];
-}
-declare const EditViewPage: ({ allowedActions, history: { goBack }, match: { params: { slug, collectionType, id, origin }, }, userPermissions, }: EditViewPageProps) => import("react/jsx-runtime").JSX.Element | null;
-interface ProtectedEditViewPageProps extends Omit<EditViewPageProps, 'allowedActions'> {
-}
-declare const ProtectedEditViewPage: ({ userPermissions, ...restProps }: ProtectedEditViewPageProps) => import("react/jsx-runtime").JSX.Element;
+declare const EditViewPage: () => import("react/jsx-runtime").JSX.Element;
+declare const ProtectedEditViewPage: () => import("react/jsx-runtime").JSX.Element;
 export { EditViewPage, ProtectedEditViewPage };
-export type { EditViewPageProps, EditViewPageParams, ProtectedEditViewPageProps };

package/dist/admin/src/content-manager/pages/EditView/components/DocumentActions.d.ts

@@ -0,0 +1,68 @@
+import * as React from 'react';
+import { DocumentActionComponent } from '../../../../core/apis/content-manager';
+type DocumentActionPosition = 'panel' | 'header' | 'table-row';
+interface DocumentActionDescription {
+    label: string;
+    onClick?: (event: React.SyntheticEvent) => Promise<boolean | void> | boolean | void;
+    icon?: React.ReactNode;
+    /**
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * @default 'panel'
+     * @description Where the action should be rendered.
+     */
+    position?: DocumentActionPosition | DocumentActionPosition[];
+    dialog?: DialogOptions | NotificationOptions | ModalOptions;
+    /**
+     * @default 'secondary'
+     */
+    variant?: 'default' | 'secondary' | 'danger' | 'success';
+}
+interface DialogOptions {
+    type: 'dialog';
+    title: string;
+    content?: React.ReactNode;
+    onConfirm?: () => void | Promise<void>;
+    onCancel?: () => void | Promise<void>;
+}
+interface NotificationOptions {
+    type: 'notification';
+    title: string;
+    link?: {
+        label: string;
+        url: string;
+        target?: string;
+    };
+    content?: string;
+    onClose?: () => void;
+    status?: 'info' | 'warning' | 'softWarning' | 'success';
+    timeout?: number;
+}
+interface ModalOptions {
+    type: 'modal';
+    title: string;
+    content: React.ReactNode;
+    footer: React.ComponentType<{
+        onClose: () => void;
+    }> | React.ReactNode;
+    onClose?: () => void;
+}
+interface Action extends DocumentActionDescription {
+    id: string;
+}
+interface DocumentActionsProps {
+    actions: Action[];
+}
+declare const DocumentActions: ({ actions }: DocumentActionsProps) => import("react/jsx-runtime").JSX.Element | null;
+interface DocumentActionsMenuProps {
+    actions: Action[];
+    children?: React.ReactNode;
+    label?: string;
+    variant?: 'ghost' | 'tertiary';
+}
+declare const DocumentActionsMenu: ({ actions, children, label, variant, }: DocumentActionsMenuProps) => import("react/jsx-runtime").JSX.Element;
+declare const DEFAULT_ACTIONS: DocumentActionComponent[];
+export { DocumentActions, DocumentActionsMenu, DEFAULT_ACTIONS };
+export type { DocumentActionDescription, DialogOptions, NotificationOptions, ModalOptions };

package/dist/admin/src/content-manager/pages/EditView/components/DocumentStatus.d.ts

@@ -0,0 +1,16 @@
+import { StatusProps } from '@strapi/design-system';
+interface DocumentStatusProps extends Omit<StatusProps, 'children' | 'showBullet' | 'size' | 'variant'> {
+    /**
+     * The status of the document (draft, published, etc.)
+     * @default 'draft'
+     */
+    status?: string;
+}
+/**
+ * @internal
+ * @description Displays the status of a document (draft, published, etc.)
+ * and automatically calculates the appropriate variant for the status.
+ */
+declare const DocumentStatus: ({ status, ...restProps }: DocumentStatusProps) => import("react/jsx-runtime").JSX.Element;
+export { DocumentStatus };
+export type { DocumentStatusProps };

package/dist/admin/src/content-manager/pages/EditView/components/FormInputs/BlocksInput/BlocksEditor.d.ts

@@ -0,0 +1,61 @@
+import * as React from 'react';
+import { type Attribute } from '@strapi/types';
+import { MessageDescriptor } from 'react-intl';
+import { Editor } from 'slate';
+import { type RenderElementProps } from 'slate-react';
+import { type CSSProperties } from 'styled-components';
+import { FieldValue } from '../../../../../../components/Form';
+import { type BlocksContentProps } from './BlocksContent';
+import { type ModifiersStore } from './Modifiers';
+interface BaseBlock {
+    renderElement: (props: RenderElementProps) => React.JSX.Element;
+    matchNode: (node: Attribute.BlocksNode) => boolean;
+    handleConvert?: (editor: Editor) => void | (() => React.JSX.Element);
+    handleEnterKey?: (editor: Editor) => void;
+    handleBackspaceKey?: (editor: Editor, event: React.KeyboardEvent<HTMLElement>) => void;
+    handleTab?: (editor: Editor) => void;
+    snippets?: string[];
+    dragHandleTopMargin?: CSSProperties['marginTop'];
+}
+interface NonSelectorBlock extends BaseBlock {
+    isInBlocksSelector: false;
+}
+interface SelectorBlock extends BaseBlock {
+    isInBlocksSelector: true;
+    icon: React.ComponentType;
+    label: MessageDescriptor;
+}
+type NonSelectorBlockKey = 'list-item' | 'link';
+declare const selectorBlockKeys: readonly ["paragraph", "heading-one", "heading-two", "heading-three", "heading-four", "heading-five", "heading-six", "list-ordered", "list-unordered", "image", "quote", "code"];
+type SelectorBlockKey = (typeof selectorBlockKeys)[number];
+declare const isSelectorBlockKey: (key: unknown) => key is "code" | "image" | "paragraph" | "quote" | "heading-one" | "heading-two" | "heading-three" | "heading-four" | "heading-five" | "heading-six" | "list-ordered" | "list-unordered";
+type BlocksStore = {
+    [K in SelectorBlockKey]: SelectorBlock;
+} & {
+    [K in NonSelectorBlockKey]: NonSelectorBlock;
+};
+interface BlocksEditorContextValue {
+    blocks: BlocksStore;
+    modifiers: ModifiersStore;
+    disabled: boolean;
+    name: string;
+    setLiveText: (text: string) => void;
+    isExpandedMode: boolean;
+}
+declare const BlocksEditorProvider: {
+    (props: BlocksEditorContextValue & {
+        children: React.ReactNode;
+    }): JSX.Element;
+    displayName: string;
+};
+declare function useBlocksEditorContext(consumerName: string): BlocksEditorContextValue & {
+    editor: Editor;
+};
+interface BlocksEditorProps extends Pick<FieldValue<Attribute.BlocksValue>, 'onChange' | 'value' | 'error'>, BlocksContentProps {
+    disabled?: boolean;
+    name: string;
+}
+declare const BlocksEditor: React.ForwardRefExoticComponent<BlocksEditorProps & React.RefAttributes<{
+    focus: () => void;
+}>>;
+export { type BlocksStore, type SelectorBlockKey, BlocksEditor, BlocksEditorProvider, useBlocksEditorContext, isSelectorBlockKey, };

package/dist/admin/src/content-manager/pages/EditView/components/FormInputs/BlocksInput/BlocksInput.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { InputProps } from '../../../../../../components/FormInputs/types';
+import type { Attribute } from '@strapi/types';
+interface BlocksInputProps extends Omit<InputProps, 'type'> {
+    type: Attribute.Blocks['type'];
+}
+declare const BlocksInput: React.ForwardRefExoticComponent<BlocksInputProps & React.RefAttributes<{
+    focus: () => void;
+}>>;
+export { BlocksInput };

package/dist/admin/src/content-manager/pages/EditView/components/FormInputs/Component/Initializer.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+interface InitializerProps {
+    disabled?: boolean;
+    name: string;
+    onClick?: React.MouseEventHandler<HTMLButtonElement> & React.MouseEventHandler<HTMLDivElement>;
+}
+declare const Initializer: ({ disabled, name, onClick }: InitializerProps) => import("react/jsx-runtime").JSX.Element;
+export { Initializer };
+export type { InitializerProps };

package/dist/admin/src/content-manager/pages/EditView/components/FormInputs/Component/Input.d.ts

@@ -0,0 +1,9 @@
+import { InputProps } from '../../../../../../components/Form';
+import { EditFieldLayout } from '../../../../../hooks/useDocumentLayout';
+interface ComponentInputProps extends Omit<Extract<EditFieldLayout, {
+    type: 'component';
+}>, 'size' | 'hint'>, Pick<InputProps, 'hint'> {
+}
+declare const ComponentInput: ({ label, required, name, attribute, disabled, ...props }: ComponentInputProps) => import("react/jsx-runtime").JSX.Element;
+export { ComponentInput };
+export type { ComponentInputProps };

package/dist/admin/src/content-manager/pages/EditView/components/FormInputs/Component/NonRepeatable.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentInputProps } from './Input';
+interface NonRepeatableComponentProps extends Omit<ComponentInputProps, 'required' | 'label'> {
+}
+declare const NonRepeatableComponent: ({ attribute, name }: NonRepeatableComponentProps) => import("react/jsx-runtime").JSX.Element;
+export { NonRepeatableComponent };
+export type { NonRepeatableComponentProps };