@strapi/admin 4.16.1 → 4.17.0

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

@@ -1,9 +1,43 @@
 import * as React from 'react';
 import { type Attribute } from '@strapi/types';
 import { MessageDescriptor } from 'react-intl';
-import { type Editor } from 'slate';
+import { Editor } from 'slate';
+import { type RenderElementProps } from 'slate-react';
+import { type CSSProperties } from 'styled-components';
+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;
+    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" | "quote" | "paragraph" | "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 & {
@@ -31,4 +65,4 @@ interface BlocksEditorProps {
 declare const BlocksEditor: React.ForwardRefExoticComponent<BlocksEditorProps & React.RefAttributes<{
     focus: () => void;
 }>>;
-export { BlocksEditor, BlocksEditorProvider, useBlocksEditorContext };
+export { type BlocksStore, type SelectorBlockKey, BlocksEditor, BlocksEditorProvider, useBlocksEditorContext, isSelectorBlockKey, };

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

@@ -1,7 +1,8 @@
 import * as React from 'react';
 import { type MessageDescriptor } from 'react-intl';
+import { HintProps } from '../Hint';
 import { BlocksEditor } from './BlocksEditor';
-interface BlocksInputProps extends React.ComponentPropsWithoutRef<typeof BlocksEditor> {
+interface BlocksInputProps extends React.ComponentPropsWithoutRef<typeof BlocksEditor>, Pick<HintProps, 'hint'> {
     intlLabel: MessageDescriptor;
     attribute: {
         type: string;
@@ -10,7 +11,6 @@ interface BlocksInputProps extends React.ComponentPropsWithoutRef<typeof BlocksE
     description?: MessageDescriptor;
     labelAction?: React.ReactNode;
     required?: boolean;
-    hint?: string | string[];
 }
 declare const BlocksInput: React.ForwardRefExoticComponent<BlocksInputProps & React.RefAttributes<{
     focus: () => void;

package/dist/admin/src/content-manager/components/BlocksInput/BlocksToolbar.d.ts

@@ -1,2 +1,10 @@
+import * as React from 'react';
+/**
+ * Handles the modal component that may be returned by a block when converting it
+ */
+declare function useConversionModal(): {
+    modalElement: React.JSX.Element | null;
+    handleConversionResult: (renderModal: void | (() => React.JSX.Element) | undefined) => void;
+};
 declare const BlocksToolbar: () => import("react/jsx-runtime").JSX.Element;
-export { BlocksToolbar };
+export { BlocksToolbar, useConversionModal };

package/dist/admin/src/content-manager/components/BlocksInput/EditorLayout.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+interface EditorLayoutProps {
+    children: React.ReactNode;
+    error?: string;
+    onCollapse: () => void;
+    disabled: boolean;
+    ariaDescriptionId: string;
+}
+declare const EditorLayout: ({ children, error, disabled, onCollapse, ariaDescriptionId, }: EditorLayoutProps) => import("react/jsx-runtime").JSX.Element;
+export { EditorLayout };

package/dist/admin/src/content-manager/components/BlocksInput/Modifiers.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { type MessageDescriptor } from 'react-intl';
+import { Editor, Text } from 'slate';
+type ModifierKey = Exclude<keyof Text, 'type' | 'text'>;
+type ModifiersStore = {
+    [K in ModifierKey]: {
+        icon: React.ComponentType;
+        isValidEventKey: (event: React.KeyboardEvent<HTMLElement>) => boolean;
+        label: MessageDescriptor;
+        checkIsActive: (editor: Editor) => boolean;
+        handleToggle: (editor: Editor) => void;
+        renderLeaf: (children: React.JSX.Element | string) => React.JSX.Element;
+    };
+};
+declare const modifiers: ModifiersStore;
+export { type ModifiersStore, modifiers };

package/dist/admin/src/content-manager/components/BlocksInput/plugins/withImages.d.ts

@@ -0,0 +1,11 @@
+import { type Editor } from 'slate';
+/**
+ * Images are void elements. They handle the rendering of their children instead of Slate.
+ * See the Slate documentation for more information:
+ * - https://docs.slatejs.org/api/nodes/element#void-vs-not-void
+ * - https://docs.slatejs.org/api/nodes/element#rendering-void-elements
+ */
+declare const withImages: (editor: Editor) => Omit<import("slate").BaseEditor & import("slate-react").ReactEditor & import("slate-history").HistoryEditor & import("./withLinks").LinkEditor, "children"> & {
+    children: import("@strapi/types/dist/types/core/attributes").BlocksValue;
+};
+export { withImages };

package/dist/admin/src/content-manager/components/BlocksInput/plugins/withLinks.d.ts

@@ -1,6 +1,7 @@
 import { type BaseEditor, Path, Editor } from 'slate';
 interface LinkEditor extends BaseEditor {
     lastInsertedLinkPath: Path | null;
+    shouldSaveLinkPath: boolean;
 }
 declare const withLinks: (editor: Editor) => Omit<BaseEditor & import("slate-react").ReactEditor & import("slate-history").HistoryEditor & LinkEditor, "children"> & {
     children: import("@strapi/types/dist/types/core/attributes").BlocksValue;

package/dist/admin/src/content-manager/components/BlocksInput/utils/conversions.d.ts

@@ -0,0 +1,13 @@
+import { type Element, type Path, Editor } from 'slate';
+/**
+ * Extracts some logic that is common to most blocks' handleConvert functions.
+ * @returns The path of the converted block
+ */
+declare const baseHandleConvert: <T extends import("@strapi/types/dist/types/core/attributes").BlocksNode>(editor: Editor, attributesToSet: Partial<T> & {
+    type: T["type"];
+}) => void | Path;
+/**
+ * Set all attributes except type and children to null so that Slate deletes them
+ */
+declare const getAttributesToClear: (element: Element) => Record<string, null>;
+export { baseHandleConvert, getAttributesToClear };

package/dist/admin/src/content-manager/components/BlocksInput/utils/enterKey.d.ts

@@ -0,0 +1,6 @@
+import { Editor } from 'slate';
+/**
+ * Inserts a line break the first time the user presses enter, and exits the node the second time.
+ */
+declare const pressEnterTwiceToExit: (editor: Editor) => void;
+export { pressEnterTwiceToExit };

package/dist/admin/src/content-manager/components/BlocksInput/utils/types.d.ts

@@ -1,6 +1,10 @@
+import { type Attribute } from '@strapi/types';
 import { type Element, Node } from 'slate';
-export type Block<T extends Element['type']> = Extract<Node, {
+type Block<T extends Element['type']> = Extract<Node, {
     type: T;
 }>;
-export declare const getEntries: <T extends object>(object: T) => [keyof T, T[keyof T]][];
-export declare const getKeys: <T extends object>(object: T) => (keyof T)[];
+declare const getEntries: <T extends object>(object: T) => [keyof T, T[keyof T]][];
+declare const getKeys: <T extends object>(object: T) => (keyof T)[];
+declare const isLinkNode: (element: Element) => element is Attribute.LinkInlineNode;
+declare const isListNode: (element: Element) => element is Attribute.ListBlockNode;
+export { type Block, getEntries, getKeys, isLinkNode, isListNode };

package/dist/admin/src/content-manager/components/ComponentIcon.d.ts

@@ -0,0 +1,8 @@
+import type { Schema } from '@strapi/types';
+interface ComponentIconProps {
+    showBackground?: boolean;
+    icon?: Schema.ContentTypeInfo['icon'];
+}
+declare const ComponentIcon: ({ showBackground, icon }: ComponentIconProps) => import("react/jsx-runtime").JSX.Element;
+export { ComponentIcon };
+export type { ComponentIconProps };

package/dist/admin/src/content-manager/components/ComponentInitializer.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { TranslationMessage } from '@strapi/helper-plugin';
+interface ComponentInitializerProps {
+    error?: TranslationMessage;
+    isReadOnly?: boolean;
+    onClick: React.MouseEventHandler<HTMLButtonElement> & React.MouseEventHandler<HTMLDivElement>;
+}
+declare const ComponentInitializer: ({ error, isReadOnly, onClick }: ComponentInitializerProps) => import("react/jsx-runtime").JSX.Element;
+export { ComponentInitializer };
+export type { ComponentInitializerProps };

package/dist/admin/src/content-manager/components/ContentTypeFormWrapper.d.ts

@@ -0,0 +1,32 @@
+import * as React from 'react';
+import { TrackingEvent } from '@strapi/helper-plugin';
+import type { EditViewPageParams } from '../pages/EditView/EditViewPage';
+import type { EntityData } from '../sharedReducers/crud/reducer';
+import type { Contracts } from '@strapi/plugin-content-manager/_internal/shared';
+interface RenderChildProps {
+    componentsDataStructure: Record<string, any>;
+    contentTypeDataStructure: Record<string, any>;
+    data: EntityData | null;
+    isCreatingEntry: boolean;
+    isLoadingForData: boolean;
+    onDelete: (trackerProperty: Extract<TrackingEvent, {
+        name: 'willDeleteEntry' | 'didDeleteEntry' | 'didNotDeleteEntry';
+    }>['properties']) => Promise<Contracts.SingleTypes.Delete.Response>;
+    onPost: (body: Contracts.SingleTypes.CreateOrUpdate.Request['body'], trackerProperty: Extract<TrackingEvent, {
+        name: 'willCreateEntry' | 'didCreateEntry' | 'didNotCreateEntry';
+    }>['properties']) => Promise<Contracts.SingleTypes.CreateOrUpdate.Response>;
+    onDraftRelationCheck: () => Promise<Contracts.SingleTypes.CountDraftRelations.Response['data']>;
+    onPublish: () => Promise<Contracts.SingleTypes.Publish.Response>;
+    onPut: (body: Contracts.SingleTypes.CreateOrUpdate.Request['body'], trackerProperty: Extract<TrackingEvent, {
+        name: 'willEditEntry' | 'didEditEntry' | 'didNotEditEntry';
+    }>['properties']) => Promise<Contracts.SingleTypes.CreateOrUpdate.Response>;
+    onUnpublish: () => Promise<void>;
+    redirectionLink: string;
+    status: string;
+}
+interface ContentTypeFormWrapperProps extends EditViewPageParams {
+    children: (props: RenderChildProps) => React.JSX.Element;
+}
+declare const ContentTypeFormWrapper: ({ children, slug, id, origin, collectionType, }: ContentTypeFormWrapperProps) => React.JSX.Element;
+export { ContentTypeFormWrapper };
+export type { ContentTypeFormWrapperProps, RenderChildProps };

package/dist/admin/src/content-manager/components/DragPreviews/CardDragPreview.d.ts

@@ -0,0 +1,7 @@
+interface CardDragPreviewProps {
+    labelField: string;
+    isSibling?: boolean;
+}
+declare const CardDragPreview: ({ labelField, isSibling }: CardDragPreviewProps) => import("react/jsx-runtime").JSX.Element;
+export { CardDragPreview };
+export type { CardDragPreviewProps };

package/dist/admin/src/content-manager/components/DragPreviews/ComponentDragPreview.d.ts

@@ -0,0 +1,6 @@
+interface ComponentDragPreviewProps {
+    displayedValue: string;
+}
+declare const ComponentDragPreview: ({ displayedValue }: ComponentDragPreviewProps) => import("react/jsx-runtime").JSX.Element;
+export { ComponentDragPreview };
+export type { ComponentDragPreviewProps };

package/dist/admin/src/content-manager/components/DragPreviews/RelationDragPreview.d.ts

@@ -0,0 +1,9 @@
+import { PUBLICATION_STATES } from '../Relations/RelationInputDataManager';
+interface RelationDragPreviewProps {
+    status: typeof PUBLICATION_STATES.DRAFT | typeof PUBLICATION_STATES.PUBLISHED;
+    displayedValue: string;
+    width: number;
+}
+declare const RelationDragPreview: ({ status, displayedValue, width }: RelationDragPreviewProps) => import("react/jsx-runtime").JSX.Element;
+export { RelationDragPreview };
+export type { RelationDragPreviewProps };

package/dist/admin/src/content-manager/components/DynamicZone/AddComponentButton.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+interface AddComponentButtonProps {
+    children: React.ReactNode;
+    hasError?: boolean;
+    isDisabled?: boolean;
+    isOpen?: boolean;
+    onClick: React.MouseEventHandler<HTMLButtonElement> & React.MouseEventHandler<HTMLDivElement>;
+}
+declare const AddComponentButton: ({ hasError, isDisabled, isOpen, children, onClick, }: AddComponentButtonProps) => import("react/jsx-runtime").JSX.Element;
+export { AddComponentButton };
+export type { AddComponentButtonProps };

package/dist/admin/src/content-manager/components/DynamicZone/ComponentCard.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { ComponentIconProps } from '../ComponentIcon';
+interface ComponentCardProps extends Pick<ComponentIconProps, 'icon'> {
+    children: React.ReactNode;
+    onClick?: React.MouseEventHandler<HTMLButtonElement> & React.MouseEventHandler<HTMLDivElement>;
+}
+declare const ComponentCard: ({ children, onClick, icon }: ComponentCardProps) => import("react/jsx-runtime").JSX.Element;
+export { ComponentCard };
+export type { ComponentCardProps };

package/dist/admin/src/content-manager/components/DynamicZone/ComponentCategory.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { AccordionVariant } from '@strapi/design-system';
+import type { FormattedComponentLayout } from '../../utils/layouts';
+import type { Attribute } from '@strapi/types';
+interface ComponentCategoryProps {
+    category: string;
+    components?: Array<Pick<FormattedComponentLayout, 'info' | 'attributes'> & {
+        componentUid: Attribute.DynamicZone['components'][number];
+    }>;
+    isOpen?: boolean;
+    onAddComponent: (componentUid: string) => React.MouseEventHandler<HTMLButtonElement> & React.MouseEventHandler<HTMLDivElement>;
+    onToggle: (category: string) => void;
+    variant?: AccordionVariant;
+}
+declare const ComponentCategory: ({ category, components, variant, isOpen, onAddComponent, onToggle, }: ComponentCategoryProps) => import("react/jsx-runtime").JSX.Element;
+export { ComponentCategory };
+export type { ComponentCategoryProps };

package/dist/admin/src/content-manager/components/DynamicZone/ComponentPicker.d.ts

@@ -0,0 +1,9 @@
+import { ComponentCategoryProps } from './ComponentCategory';
+interface ComponentPickerProps {
+    dynamicComponentsByCategory?: Record<string, NonNullable<ComponentCategoryProps['components']>>;
+    isOpen?: boolean;
+    onClickAddComponent: (componentUid: string) => void;
+}
+declare const ComponentPicker: ({ dynamicComponentsByCategory, isOpen, onClickAddComponent, }: ComponentPickerProps) => import("react/jsx-runtime").JSX.Element | null;
+export { ComponentPicker };
+export type { ComponentPickerProps };

package/dist/admin/src/content-manager/components/DynamicZone/DynamicComponent.d.ts

@@ -0,0 +1,15 @@
+import { type UseDragAndDropOptions } from '../../hooks/useDragAndDrop';
+import type { ComponentPickerProps } from './ComponentPicker';
+interface DynamicComponentProps extends Pick<UseDragAndDropOptions, 'onGrabItem' | 'onDropItem' | 'onCancel'>, Pick<ComponentPickerProps, 'dynamicComponentsByCategory'> {
+    componentUid: string;
+    formErrors?: Record<string, unknown>;
+    index?: number;
+    isFieldAllowed?: boolean;
+    name: string;
+    onAddComponent?: (componentUid: string, index: number) => void;
+    onRemoveComponentClick: () => void;
+    onMoveComponent: (dragIndex: number, hoverIndex: number) => void;
+}
+declare const DynamicComponent: ({ componentUid, formErrors, index, isFieldAllowed, name, onRemoveComponentClick, onMoveComponent, onGrabItem, onDropItem, onCancel, dynamicComponentsByCategory, onAddComponent, }: DynamicComponentProps) => import("react/jsx-runtime").JSX.Element;
+export { DynamicComponent };
+export type { DynamicComponentProps };

package/dist/admin/src/content-manager/components/DynamicZone/DynamicZoneLabel.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { MessageDescriptor } from 'react-intl';
+interface DynamicZoneLabelProps {
+    label?: string;
+    labelAction?: React.ReactNode;
+    name: string;
+    numberOfComponents?: number;
+    required?: boolean;
+    intlDescription?: MessageDescriptor;
+}
+declare const DynamicZoneLabel: ({ label, labelAction, name, numberOfComponents, required, intlDescription, }: DynamicZoneLabelProps) => import("react/jsx-runtime").JSX.Element;
+export { DynamicZoneLabel };
+export type { DynamicZoneLabelProps };

package/dist/admin/src/content-manager/components/DynamicZone/Field.d.ts

@@ -0,0 +1,32 @@
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import type { EditLayoutRow } from '../../utils/layouts';
+import type { Attribute } from '@strapi/types';
+interface DynamicZoneProps extends Pick<EditLayoutRow, 'metadatas'> {
+    name: string;
+    fieldSchema?: Attribute.DynamicZone;
+    labelAction?: React.ReactNode;
+}
+declare const DynamicZone: {
+    ({ name, labelAction, fieldSchema, metadatas }: DynamicZoneProps): import("react/jsx-runtime").JSX.Element;
+    defaultProps: {
+        fieldSchema: {};
+        labelAction: null;
+    };
+    propTypes: {
+        fieldSchema: PropTypes.Requireable<PropTypes.InferProps<{
+            components: PropTypes.Requireable<any[]>;
+            max: PropTypes.Requireable<number>;
+            min: PropTypes.Requireable<number>;
+            required: PropTypes.Requireable<boolean>;
+        }>>;
+        labelAction: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        metadatas: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+            description: PropTypes.Requireable<string>;
+            label: PropTypes.Requireable<string>;
+        }>>>;
+        name: PropTypes.Validator<string>;
+    };
+};
+export { DynamicZone };
+export type { DynamicZoneProps };

package/dist/admin/src/content-manager/components/EditViewDataManagerProvider/Provider.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { AllowedActions } from '@strapi/helper-plugin';
+import { RenderChildProps } from '../ContentTypeFormWrapper';
+import type { EntityData } from '../../sharedReducers/crud/reducer';
+interface EditViewDataManagerProviderProps extends Pick<RenderChildProps, 'componentsDataStructure' | 'contentTypeDataStructure' | 'isCreatingEntry' | 'isLoadingForData' | 'onDraftRelationCheck' | 'onPost' | 'onPublish' | 'onPut' | 'onUnpublish' | 'status'> {
+    allowedActions: AllowedActions;
+    createActionAllowedFields: string[];
+    children: React.ReactNode;
+    from: RenderChildProps['redirectionLink'];
+    initialValues: EntityData | null;
+    isSingleType: boolean;
+    readActionAllowedFields: string[];
+    redirectToPreviousPage: () => void;
+    slug: string;
+    updateActionAllowedFields: string[];
+}
+declare const EditViewDataManagerProvider: ({ allowedActions: { canRead, canUpdate }, children, componentsDataStructure, contentTypeDataStructure, createActionAllowedFields, from, initialValues, isCreatingEntry, isLoadingForData, isSingleType, onPost, onPublish, onDraftRelationCheck, onPut, onUnpublish, readActionAllowedFields, redirectToPreviousPage, slug, status, updateActionAllowedFields, }: EditViewDataManagerProviderProps) => import("react/jsx-runtime").JSX.Element | null;
+export { EditViewDataManagerProvider };

package/dist/admin/src/content-manager/components/EditViewDataManagerProvider/reducer.d.ts

@@ -0,0 +1,150 @@
+import type { FormattedComponentLayout, FormattedContentTypeLayout } from '../../utils/layouts';
+import type { Attribute, Entity } from '@strapi/types';
+interface EditViewDataManagerState {
+    componentsDataStructure: Record<string, any>;
+    contentTypeDataStructure: Record<string, any>;
+    formErrors: Record<string, any>;
+    initialData: Record<string, Attribute.GetValue<Attribute.Any>>;
+    modifiedData: Record<string, Attribute.GetValue<Attribute.Any>>;
+    shouldCheckErrors: boolean;
+    modifiedDZName: string | null;
+    publishConfirmation: {
+        show: boolean;
+        draftCount: number;
+    };
+}
+declare const initialState: {
+    componentsDataStructure: {};
+    contentTypeDataStructure: {};
+    formErrors: {};
+    initialData: {};
+    modifiedData: {};
+    shouldCheckErrors: false;
+    modifiedDZName: null;
+    publishConfirmation: {
+        show: false;
+        draftCount: number;
+    };
+};
+interface AddNonRepeatableComponentToFieldAction {
+    type: 'ADD_NON_REPEATABLE_COMPONENT_TO_FIELD';
+    componentLayoutData: FormattedComponentLayout;
+    allComponents: Record<string, FormattedComponentLayout>;
+    keys: string[];
+}
+interface AddComponentToDynamicZoneAction {
+    type: 'ADD_COMPONENT_TO_DYNAMIC_ZONE';
+    componentLayoutData: FormattedComponentLayout;
+    allComponents: Record<string, FormattedComponentLayout>;
+    keys: string[];
+    shouldCheckErrors: boolean;
+    position?: number;
+}
+interface AddRepeatableComponentToFieldAction extends Omit<AddComponentToDynamicZoneAction, 'type'> {
+    type: 'ADD_REPEATABLE_COMPONENT_TO_FIELD';
+}
+interface LoadRelationAction {
+    type: 'LOAD_RELATION';
+    initialDataPath: string[];
+    modifiedDataPath: string[];
+    value: Omit<RelationData, '__temp_key__'>[];
+}
+interface ConnectRelationAction {
+    type: 'CONNECT_RELATION';
+    keys: string[];
+    value: Omit<RelationData, '__temp_key__'>;
+    toOneRelation?: boolean;
+}
+interface DisconnectRelationAction {
+    type: 'DISCONNECT_RELATION';
+    keys: string[];
+    id: Entity.ID;
+}
+interface MoveComponentFieldAction {
+    type: 'MOVE_COMPONENT_FIELD';
+    keys: string[];
+    oldIndex: number;
+    newIndex: number;
+}
+interface MoveComponentUpAction {
+    type: 'MOVE_COMPONENT_UP';
+    currentIndex: number;
+    dynamicZoneName: string;
+    shouldCheckErrors: boolean;
+}
+interface MoveComponentDownAction extends Omit<MoveComponentUpAction, 'type'> {
+    type: 'MOVE_COMPONENT_DOWN';
+}
+interface MoveFieldAction {
+    type: 'MOVE_FIELD';
+    keys: string[];
+    dragIndex: number;
+    overIndex: number;
+}
+interface InitFormAction {
+    type: 'INIT_FORM';
+    initialValues: Record<string, any>;
+    components: Record<string, FormattedComponentLayout>;
+    attributes: FormattedContentTypeLayout['attributes'];
+    setModifiedDataOnly?: boolean;
+}
+interface OnChangeAction {
+    type: 'ON_CHANGE';
+    keys: string[];
+    value: Attribute.GetValue<Attribute.Any>;
+    shouldSetInitialValue?: boolean;
+}
+interface RemoveComponentFromDynamicZoneAction {
+    type: 'REMOVE_COMPONENT_FROM_DYNAMIC_ZONE';
+    dynamicZoneName: string;
+    index: number;
+    shouldCheckErrors: boolean;
+}
+interface RemoveComponentFromFieldAction {
+    type: 'REMOVE_COMPONENT_FROM_FIELD';
+    keys: string[];
+}
+interface RemovePasswordFieldAction {
+    type: 'REMOVE_PASSWORD_FIELD';
+    keys: string[];
+}
+interface RemoveRepeatableFieldAction {
+    type: 'REMOVE_REPEATABLE_FIELD';
+    keys: string[];
+}
+interface ReorderRelationAction {
+    type: 'REORDER_RELATION';
+    keys: string[];
+    oldIndex: number;
+    newIndex: number;
+}
+interface SetDefaultDataStructuresAction {
+    type: 'SET_DEFAULT_DATA_STRUCTURES';
+    componentsDataStructure: Record<string, any>;
+    contentTypeDataStructure: Record<string, any>;
+}
+interface SetFormErrorsAction {
+    type: 'SET_FORM_ERRORS';
+    errors: Record<string, any>;
+}
+interface TriggerFormValidationAction {
+    type: 'TRIGGER_FORM_VALIDATION';
+}
+interface SetPublishConfirmationAction {
+    type: 'SET_PUBLISH_CONFIRMATION';
+    publishConfirmation: {
+        show: boolean;
+        draftCount: number;
+    };
+}
+interface ResetPublishConfirmationAction {
+    type: 'RESET_PUBLISH_CONFIRMATION';
+}
+type Action = AddNonRepeatableComponentToFieldAction | AddComponentToDynamicZoneAction | AddRepeatableComponentToFieldAction | LoadRelationAction | ConnectRelationAction | DisconnectRelationAction | MoveComponentFieldAction | MoveComponentUpAction | MoveComponentDownAction | MoveFieldAction | InitFormAction | OnChangeAction | RemoveComponentFromDynamicZoneAction | RemoveComponentFromFieldAction | RemovePasswordFieldAction | RemoveRepeatableFieldAction | ReorderRelationAction | SetDefaultDataStructuresAction | SetFormErrorsAction | TriggerFormValidationAction | SetPublishConfirmationAction | ResetPublishConfirmationAction;
+export interface RelationData {
+    id: Entity.ID;
+    __temp_key__: number;
+}
+declare const reducer: (state: EditViewDataManagerState, action: Action) => EditViewDataManagerState;
+export { reducer, initialState };
+export type { EditViewDataManagerState };

package/dist/admin/src/content-manager/components/EditViewDataManagerProvider/utils/cleanData.d.ts

@@ -0,0 +1,6 @@
+import type { FormattedComponentLayout, FormattedContentTypeLayout } from '../../../utils/layouts';
+declare const cleanData: ({ browserState, serverState, }: {
+    browserState: Record<string, any>;
+    serverState: Record<string, any>;
+}, currentSchema: FormattedContentTypeLayout, componentsSchema: Record<string, FormattedComponentLayout>) => Record<string, any>;
+export { cleanData };

package/dist/admin/src/content-manager/components/EditViewDataManagerProvider/utils/findAllAndReplace.d.ts

@@ -0,0 +1,33 @@
+import type { FormattedComponentLayout } from '../../../utils/layouts';
+import type { Attribute } from '@strapi/types';
+type ReplacementFn<TData extends Record<string, any>, TKey extends keyof TData, TReplacementValue> = (data: TData[TKey], args: {
+    path: string[];
+    parent: TData;
+}) => TReplacementValue;
+/**
+ * This function will recursively find everything and replace it with a value
+ * based on the boolean return of the predicate function e.g. `type === 'relation'`.
+ *
+ * If you provide a function it will call that function with data value you're replacing with
+ * a second argument with the path to the value and it's parent.
+ *
+ * It's original use was for the preperation of action items for the INIT_FORM action. It requires
+ * knowledge of the `components` in the entity, however `components` doesn't change nor does the predicate
+ * function so we don't need to pass it everytime hence why it's curried.
+ *
+ */
+declare const findAllAndReplaceSetup: <TReplacementValue, TData extends Record<string, any> = Record<string, any>>(components: Record<string, FormattedComponentLayout>, predicate?: (value: FormattedComponentLayout['attributes'][string], args: {
+    path: string[];
+    parent: Attribute.Any | {
+        [key: string]: Attribute.Any;
+    };
+}) => boolean, replacement?: TReplacementValue | ReplacementFn<TData, keyof TData, TReplacementValue> | undefined) => <TData_1 extends Record<string, any> = Record<string, any>>(data: TData_1, attributes: {
+    [key: string]: Attribute.Any;
+}, { ignoreFalseyValues, path, parent, }?: {
+    ignoreFalseyValues?: boolean | undefined;
+    path?: string[] | undefined;
+    parent?: Attribute.Any | {
+        [key: string]: Attribute.Any;
+    } | undefined;
+}) => Record<string, any>;
+export { findAllAndReplaceSetup as findAllAndReplace };

package/dist/admin/src/content-manager/components/EditViewDataManagerProvider/utils/getAPIInnerError.d.ts

@@ -0,0 +1,6 @@
+import type { ApiError, TranslationMessage } from '@strapi/helper-plugin';
+import type { AxiosError } from 'axios';
+declare const getAPIInnerError: (error: AxiosError<{
+    error: ApiError;
+}, any>) => Record<string, TranslationMessage>;
+export { getAPIInnerError };

package/dist/admin/src/content-manager/components/EditViewDataManagerProvider/utils/moveFields.d.ts

@@ -0,0 +1,2 @@
+declare const moveFields: <TValue>(initialValue: TValue[], from: number, to: number, value: TValue) => TValue[];
+export { moveFields };

package/dist/admin/src/content-manager/components/FieldComponent.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { TranslationMessage } from '@strapi/helper-plugin';
+interface FieldComponentProps {
+    componentUid: string;
+    intlLabel?: TranslationMessage;
+    isFromDynamicZone?: boolean;
+    isRepeatable?: boolean;
+    isNested?: boolean;
+    labelAction?: React.ReactNode;
+    max?: number;
+    min?: number;
+    name: string;
+    required?: boolean;
+}
+declare const FieldComponent: ({ componentUid, intlLabel, isFromDynamicZone, isRepeatable, isNested, labelAction, max, min, name, required, }: FieldComponentProps) => import("react/jsx-runtime").JSX.Element;
+export { FieldComponent };