@strapi/content-manager 0.0.0-experimental.008123965da692a55d02a1df63facc54077c6bde

package/dist/admin/src/pages/EditView/components/FormInputs/BlocksInput/Blocks/Quote.d.ts

@@ -0,0 +1,3 @@
+import { type BlocksStore } from '../BlocksEditor';
+declare const quoteBlocks: Pick<BlocksStore, 'quote'>;
+export { quoteBlocks };

package/dist/admin/src/pages/EditView/components/FormInputs/BlocksInput/BlocksContent.d.ts

@@ -0,0 +1,6 @@
+interface BlocksContentProps {
+    placeholder?: string;
+    ariaLabelId: string;
+}
+declare const BlocksContent: ({ placeholder, ariaLabelId }: BlocksContentProps) => import("react/jsx-runtime").JSX.Element;
+export { BlocksContent, BlocksContentProps };

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

@@ -0,0 +1,61 @@
+import * as React from 'react';
+import { type FieldValue } from '@strapi/admin/strapi-admin';
+import { MessageDescriptor } from 'react-intl';
+import { Editor } from 'slate';
+import { type RenderElementProps } from 'slate-react';
+import { type CSSProperties } from 'styled-components';
+import { type BlocksContentProps } from './BlocksContent';
+import { type ModifiersStore } from './Modifiers';
+import type { Schema } from '@strapi/types';
+interface BaseBlock {
+    renderElement: (props: RenderElementProps) => React.JSX.Element;
+    matchNode: (node: Schema.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;
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare function useBlocksEditorContext(consumerName: string): BlocksEditorContextValue & {
+    editor: Editor;
+};
+interface BlocksEditorProps extends Pick<FieldValue<Schema.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/pages/EditView/components/FormInputs/BlocksInput/BlocksInput.d.ts

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

package/dist/admin/src/pages/EditView/components/FormInputs/BlocksInput/BlocksToolbar.d.ts

@@ -0,0 +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, useConversionModal };

package/dist/admin/src/pages/EditView/components/FormInputs/BlocksInput/EditorLayout.d.ts

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

package/dist/admin/src/pages/EditView/components/FormInputs/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/pages/EditView/components/FormInputs/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/schema/attribute").BlocksValue;
+};
+export { withImages };

package/dist/admin/src/pages/EditView/components/FormInputs/BlocksInput/plugins/withLinks.d.ts

@@ -0,0 +1,9 @@
+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/schema/attribute").BlocksValue;
+};
+export { withLinks, type LinkEditor };

package/dist/admin/src/pages/EditView/components/FormInputs/BlocksInput/plugins/withStrapiSchema.d.ts

@@ -0,0 +1,8 @@
+import { Editor } from 'slate';
+/**
+ * This plugin is used to normalize the Slate document to match the Strapi schema.
+ */
+declare const withStrapiSchema: (editor: Editor) => Omit<import("slate").BaseEditor & import("slate-react").ReactEditor & import("slate-history").HistoryEditor & import("./withLinks").LinkEditor, "children"> & {
+    children: import("@strapi/types/dist/schema/attribute").BlocksValue;
+};
+export { withStrapiSchema };

package/dist/admin/src/pages/EditView/components/FormInputs/BlocksInput/utils/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const codeLanguages: {
+    value: string;
+    label: string;
+    decorate?: string;
+}[];

package/dist/admin/src/pages/EditView/components/FormInputs/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/schema/attribute").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/pages/EditView/components/FormInputs/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/pages/EditView/components/FormInputs/BlocksInput/utils/links.d.ts

@@ -0,0 +1,10 @@
+import { Editor } from 'slate';
+declare const removeLink: (editor: Editor) => void;
+declare const insertLink: (editor: Editor, { url }: {
+    url: string;
+}) => void;
+declare const editLink: (editor: Editor, link: {
+    url: string;
+    text: string;
+}) => void;
+export { insertLink, editLink, removeLink };

package/dist/admin/src/pages/EditView/components/FormInputs/BlocksInput/utils/types.d.ts

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

package/dist/admin/src/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/pages/EditView/components/FormInputs/Component/Input.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { InputProps } from '@strapi/admin/strapi-admin';
+import { EditFieldLayout } from '../../../../../hooks/useDocumentLayout';
+import { type InputRendererProps } from '../../InputRenderer';
+interface ComponentInputProps extends Omit<Extract<EditFieldLayout, {
+    type: 'component';
+}>, 'size' | 'hint'>, Pick<InputProps, 'hint'> {
+    labelAction?: React.ReactNode;
+    children: (props: InputRendererProps) => React.ReactNode;
+    /**
+     * We need layout to come from the props, and not via a hook, because Content History needs
+     * a way to modify the normal component layout to add hidden fields.
+     */
+    layout: EditFieldLayout[][];
+}
+declare const MemoizedComponentInput: React.MemoExoticComponent<({ label, required, name, attribute, disabled, labelAction, ...props }: ComponentInputProps) => import("react/jsx-runtime").JSX.Element>;
+export { MemoizedComponentInput as ComponentInput };
+export type { ComponentInputProps };

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

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

package/dist/admin/src/pages/EditView/components/FormInputs/Component/Repeatable.d.ts

@@ -0,0 +1,5 @@
+import type { ComponentInputProps } from './Input';
+type RepeatableComponentProps = Omit<ComponentInputProps, 'required' | 'label'>;
+declare const RepeatableComponent: ({ attribute, disabled, name, mainField, children, layout, }: RepeatableComponentProps) => import("react/jsx-runtime").JSX.Element;
+export { RepeatableComponent };
+export type { RepeatableComponentProps };

package/dist/admin/src/pages/EditView/components/FormInputs/ComponentContext.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="react" />
+interface ComponentContextValue {
+    /**
+     * The id of the component. It will be undefined if the component
+     * has not been created in the database yet. This could be on a new
+     * or existing entry.
+     */
+    id?: number;
+    /**
+     * The level of the component. This is used to determine the nesting
+     * of the component. The default is set to -1 so that the base level is 0
+     * for the top level component, and increases by 1 for each level of nesting.
+     */
+    level: number;
+    /**
+     * The uid of the component. This is used to determine the type of the
+     * component. Within an attribute, it is normally the `component` value.
+     * It will be undefined if the hook is not called within the confines
+     * of a provider.
+     */
+    uid?: string;
+    /**
+     * The type of component parent. It will be undefined if the hook
+     * is not called within the confines of a provider.
+     */
+    type?: 'dynamiczone' | 'repeatable' | 'component';
+}
+/**
+ * We use this component to wrap any individual component field in the Edit View,
+ * this could be a component field in a dynamic zone, a component within a repeatable space,
+ * or even nested components.
+ *
+ * We primarily need this to provide the component id to the components so that they can
+ * correctly fetch their relations.
+ */
+declare const ComponentProvider: {
+    (props: ComponentContextValue & {
+        children: import("react").ReactNode;
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+}, useComponent: <Selected, ShouldThrow extends boolean = true>(consumerName: string, selector: (value: ComponentContextValue) => Selected, shouldThrowOnMissingContext?: ShouldThrow | undefined) => ShouldThrow extends true ? Selected : Selected | undefined;
+export { ComponentProvider, useComponent };

package/dist/admin/src/pages/EditView/components/FormInputs/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/pages/EditView/components/FormInputs/DynamicZone/ComponentCard.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { ComponentIconProps } from '../../../../../components/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/pages/EditView/components/FormInputs/DynamicZone/ComponentCategory.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { Accordion } from '@strapi/design-system';
+interface ComponentCategoryProps {
+    category: string;
+    components?: Array<{
+        uid: string;
+        displayName: string;
+        icon?: string;
+    }>;
+    onAddComponent: (componentUid: string) => React.MouseEventHandler<HTMLButtonElement> & React.MouseEventHandler<HTMLDivElement>;
+    variant?: Accordion.Variant;
+}
+declare const ComponentCategory: ({ category, components, variant, onAddComponent, }: ComponentCategoryProps) => import("react/jsx-runtime").JSX.Element;
+export { ComponentCategory };
+export type { ComponentCategoryProps };

package/dist/admin/src/pages/EditView/components/FormInputs/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/pages/EditView/components/FormInputs/DynamicZone/DynamicComponent.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { type UseDragAndDropOptions } from '../../../../../hooks/useDragAndDrop';
+import { type InputRendererProps } from '../../InputRenderer';
+import type { ComponentPickerProps } from './ComponentPicker';
+interface DynamicComponentProps extends Pick<UseDragAndDropOptions, 'onGrabItem' | 'onDropItem' | 'onCancel'>, Pick<ComponentPickerProps, 'dynamicComponentsByCategory'> {
+    componentUid: string;
+    disabled?: boolean;
+    index: number;
+    name: string;
+    onAddComponent: (componentUid: string, index: number) => void;
+    onRemoveComponentClick: () => void;
+    onMoveComponent: (dragIndex: number, hoverIndex: number) => void;
+    children?: (props: InputRendererProps) => React.ReactNode;
+}
+declare const DynamicComponent: ({ componentUid, disabled, index, name, onRemoveComponentClick, onMoveComponent, onGrabItem, onDropItem, onCancel, dynamicComponentsByCategory, onAddComponent, children, }: DynamicComponentProps) => import("react/jsx-runtime").JSX.Element;
+export { DynamicComponent };
+export type { DynamicComponentProps };

package/dist/admin/src/pages/EditView/components/FormInputs/DynamicZone/DynamicZoneLabel.d.ts

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

package/dist/admin/src/pages/EditView/components/FormInputs/DynamicZone/Field.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { InputProps } from '@strapi/admin/strapi-admin';
+import { type EditFieldLayout } from '../../../../../hooks/useDocumentLayout';
+import { DynamicZoneLabelProps } from './DynamicZoneLabel';
+import type { InputRendererProps } from '../../InputRenderer';
+interface DynamicZoneContextValue {
+    isInDynamicZone: boolean;
+}
+declare const useDynamicZone: <Selected, ShouldThrow extends boolean = true>(consumerName: string, selector: (value: DynamicZoneContextValue) => Selected, shouldThrowOnMissingContext?: ShouldThrow | undefined) => ShouldThrow extends true ? Selected : Selected | undefined;
+interface DynamicZoneProps extends Omit<Extract<EditFieldLayout, {
+    type: 'dynamiczone';
+}>, 'size' | 'hint'>, Pick<InputProps, 'hint'>, Pick<DynamicZoneLabelProps, 'labelAction'> {
+    children?: (props: InputRendererProps) => React.ReactNode;
+}
+declare const DynamicZone: ({ attribute, disabled: disabledProp, hint, label, labelAction, name, required, children, }: DynamicZoneProps) => import("react/jsx-runtime").JSX.Element;
+export { DynamicZone, useDynamicZone };
+export type { DynamicZoneProps };

package/dist/admin/src/pages/EditView/components/FormInputs/NotAllowed.d.ts

@@ -0,0 +1,7 @@
+import type { InputProps } from '@strapi/admin/strapi-admin';
+import type { Schema } from '@strapi/types';
+interface NotAllowedInputProps extends Omit<InputProps, 'type'> {
+    type: Schema.Attribute.Kind;
+}
+declare const NotAllowedInput: ({ hint, label, required, name }: NotAllowedInputProps) => import("react/jsx-runtime").JSX.Element;
+export { NotAllowedInput };

package/dist/admin/src/pages/EditView/components/FormInputs/Relations/RelationModal.d.ts

@@ -0,0 +1,74 @@
+import * as React from 'react';
+import { type UseDocument } from '../../../../../hooks/useDocument';
+import { type DocumentMeta } from '../../../../../hooks/useDocumentContext';
+export declare function getCollectionType(url: string): string | undefined;
+interface State {
+    documentHistory: DocumentMeta[];
+    confirmDialogIntent: null | 'close' | 'back' | 'navigate' | DocumentMeta;
+    isModalOpen: boolean;
+    hasUnsavedChanges: boolean;
+    fieldToConnect?: string;
+    fieldToConnectUID?: string;
+}
+type Action = {
+    type: 'GO_TO_RELATION';
+    payload: {
+        document: DocumentMeta;
+        shouldBypassConfirmation: boolean;
+        fieldToConnect?: string;
+        fieldToConnectUID?: string;
+    };
+} | {
+    type: 'GO_BACK';
+    payload: {
+        shouldBypassConfirmation: boolean;
+    };
+} | {
+    type: 'GO_FULL_PAGE';
+} | {
+    type: 'GO_TO_CREATED_RELATION';
+    payload: {
+        document: DocumentMeta;
+        shouldBypassConfirmation: boolean;
+        fieldToConnect?: string;
+        fieldToConnectUID?: string;
+    };
+} | {
+    type: 'CANCEL_CONFIRM_DIALOG';
+} | {
+    type: 'CLOSE_MODAL';
+    payload: {
+        shouldBypassConfirmation: boolean;
+    };
+} | {
+    type: 'SET_HAS_UNSAVED_CHANGES';
+    payload: {
+        hasUnsavedChanges: boolean;
+    };
+};
+declare function reducer(state: State, action: Action): State;
+interface RelationModalContextValue {
+    state: State;
+    dispatch: React.Dispatch<Action>;
+    rootDocumentMeta: DocumentMeta;
+    currentDocumentMeta: DocumentMeta;
+    currentDocument: ReturnType<UseDocument>;
+    onPreview?: () => void;
+    isCreating: boolean;
+}
+declare const useRelationModal: <Selected, ShouldThrow extends boolean = true>(consumerName: string, selector: (value: RelationModalContextValue) => Selected, shouldThrowOnMissingContext?: ShouldThrow | undefined) => ShouldThrow extends true ? Selected : Selected | undefined;
+type RelationModalRendererProps = {
+    relation: DocumentMeta;
+    children: React.ReactNode;
+} | {
+    relation?: never;
+    children: (props: {
+        dispatch: (action: Action) => void;
+    }) => React.ReactNode;
+};
+/**
+ * Component responsible for rendering its children wrapped in a modal, form and context if needed
+ */
+declare const RelationModalRenderer: (props: RelationModalRendererProps) => import("react/jsx-runtime").JSX.Element;
+export { reducer, RelationModalRenderer, useRelationModal };
+export type { State, Action };

package/dist/admin/src/pages/EditView/components/FormInputs/Relations/Relations.d.ts

@@ -0,0 +1,45 @@
+import * as React from 'react';
+import { type InputProps } from '@strapi/admin/strapi-admin';
+import { FlexComponent } from '@strapi/design-system';
+import { type EditFieldLayout } from '../../../../../hooks/useDocumentLayout';
+import { RelationResult } from '../../../../../services/relations';
+type RelationPosition = (Pick<RelationResult, 'status' | 'locale'> & {
+    before: string;
+    end?: never;
+}) | {
+    end: boolean;
+    before?: never;
+    status?: never;
+    locale?: never;
+};
+interface Relation extends Pick<RelationResult, 'documentId' | 'id' | 'locale' | 'status'> {
+    href: string;
+    label: string;
+    position?: RelationPosition;
+    __temp_key__: string;
+    apiData?: {
+        documentId: RelationResult['documentId'];
+        id: RelationResult['id'];
+        locale?: RelationResult['locale'];
+        position: RelationPosition;
+        isTemporary?: boolean;
+    };
+}
+interface RelationsFieldProps extends Omit<Extract<EditFieldLayout, {
+    type: 'relation';
+}>, 'size' | 'hint'>, Pick<InputProps, 'hint'> {
+}
+export interface RelationsFormValue {
+    connect?: Relation[];
+    disconnect?: Pick<Relation, 'id'>[];
+}
+declare const FlexWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").FastOmit<Omit<Omit<import("@strapi/design-system").FlexProps<"div">, "ref"> & React.RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void) | React.RefObject<unknown> | null | undefined;
+}, never>> & Omit<FlexComponent, keyof React.Component<any, {}, any>>;
+declare const DisconnectButton: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").FastOmit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>>;
+declare const LinkEllipsis: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").FastOmit<Omit<Omit<import("@strapi/design-system").LinkProps<React.ElementType<any, keyof React.JSX.IntrinsicElements>>, "ref"> & React.RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void) | React.RefObject<unknown> | null | undefined;
+}, never>> & Omit<(<C extends React.ElementType<any, keyof React.JSX.IntrinsicElements> = "a">(props: React.PropsWithoutRef<import("@strapi/design-system").LinkProps<C>> & React.RefAttributes<unknown>) => React.ReactNode), keyof React.Component<any, {}, any>>;
+declare const MemoizedRelationsField: React.MemoExoticComponent<React.ForwardRefExoticComponent<RelationsFieldProps & React.RefAttributes<HTMLDivElement>>>;
+export { MemoizedRelationsField as RelationsInput, FlexWrapper, DisconnectButton, LinkEllipsis };
+export type { RelationsFieldProps };

package/dist/admin/src/pages/EditView/components/FormInputs/UID.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { type InputProps } from '@strapi/admin/strapi-admin';
+import type { Schema } from '@strapi/types';
+interface UIDInputProps extends Omit<InputProps, 'type'> {
+    attribute?: Pick<Schema.Attribute.UIDProperties, 'regex'>;
+    type: Schema.Attribute.TypeOf<Schema.Attribute.UID>;
+}
+declare const MemoizedUIDInput: React.MemoExoticComponent<React.ForwardRefExoticComponent<UIDInputProps & React.RefAttributes<any>>>;
+export { MemoizedUIDInput as UIDInput };
+export type { UIDInputProps };

package/dist/admin/src/pages/EditView/components/FormInputs/Wysiwyg/Editor.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { EditorFromTextArea } from 'codemirror5';
+import type { FieldValue, InputProps } from '@strapi/admin/strapi-admin';
+import 'codemirror5/addon/display/placeholder';
+interface EditorApi {
+    focus: () => void;
+    scrollIntoView: (args?: Parameters<HTMLElement['scrollIntoView']>[0]) => void;
+}
+interface EditorProps extends Omit<FieldValue, 'initialValue'>, Omit<InputProps, 'type' | 'label'> {
+    editorRef: React.MutableRefObject<EditorFromTextArea>;
+    isPreviewMode?: boolean;
+    isExpandMode?: boolean;
+    textareaRef: React.RefObject<HTMLTextAreaElement>;
+}
+declare const Editor: React.ForwardRefExoticComponent<EditorProps & React.RefAttributes<EditorApi>>;
+export { Editor };
+export type { EditorProps, EditorApi };

package/dist/admin/src/pages/EditView/components/FormInputs/Wysiwyg/EditorLayout.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+interface EditorLayoutProps {
+    children: React.ReactNode;
+    isExpandMode: boolean;
+    error?: string;
+    previewContent?: string;
+    onCollapse: () => void;
+}
+declare const EditorLayout: ({ children, isExpandMode, error, previewContent, onCollapse, }: EditorLayoutProps) => import("react/jsx-runtime").JSX.Element;
+declare const ExpandButton: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").FastOmit<Omit<Omit<import("@strapi/design-system").ButtonProps<React.ElementType<any, keyof React.JSX.IntrinsicElements>>, "ref"> & React.RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void) | React.RefObject<unknown> | null | undefined;
+}, never>> & Omit<(<C extends React.ElementType<any, keyof React.JSX.IntrinsicElements> = "button">(props: React.PropsWithoutRef<import("@strapi/design-system").ButtonProps<C>> & React.RefAttributes<unknown>) => React.ReactNode), keyof React.Component<any, {}, any>>;
+export { EditorLayout, ExpandButton };
+export type { EditorLayoutProps };

package/dist/admin/src/pages/EditView/components/FormInputs/Wysiwyg/Field.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { type InputProps } from '@strapi/admin/strapi-admin';
+import { EditorApi } from './Editor';
+import type { Schema } from '@strapi/types';
+interface WysiwygProps extends Omit<InputProps, 'type'> {
+    labelAction?: React.ReactNode;
+    type: Schema.Attribute.RichText['type'];
+}
+declare const MemoizedWysiwyg: React.MemoExoticComponent<React.ForwardRefExoticComponent<WysiwygProps & React.RefAttributes<EditorApi>>>;
+export { MemoizedWysiwyg as Wysiwyg };
+export type { WysiwygProps };

package/dist/admin/src/pages/EditView/components/FormInputs/Wysiwyg/PreviewWysiwyg.d.ts

@@ -0,0 +1,5 @@
+interface PreviewWysiwygProps {
+    data?: string;
+}
+declare const PreviewWysiwyg: ({ data }: PreviewWysiwygProps) => import("react/jsx-runtime").JSX.Element;
+export { PreviewWysiwyg };

package/dist/admin/src/pages/EditView/components/FormInputs/Wysiwyg/WysiwygFooter.d.ts

@@ -0,0 +1,7 @@
+import { ButtonProps } from '@strapi/design-system';
+interface WysiwygFooterProps {
+    onToggleExpand: ButtonProps['onClick'];
+}
+declare const WysiwygFooter: ({ onToggleExpand }: WysiwygFooterProps) => import("react/jsx-runtime").JSX.Element;
+export { WysiwygFooter };
+export type { WysiwygFooterProps };

package/dist/admin/src/pages/EditView/components/FormInputs/Wysiwyg/WysiwygNav.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { EditorFromTextArea } from 'codemirror5';
+interface WysiwygNavProps {
+    disabled?: boolean;
+    editorRef: React.MutableRefObject<EditorFromTextArea>;
+    isExpandMode?: boolean;
+    isPreviewMode?: boolean;
+    onToggleMediaLib: () => void;
+    onTogglePreviewMode?: () => void;
+}
+/**
+ * TODO: refactor this mess.
+ */
+declare const WysiwygNav: ({ disabled, editorRef, isPreviewMode, onToggleMediaLib, onTogglePreviewMode, }: WysiwygNavProps) => import("react/jsx-runtime").JSX.Element;
+export { WysiwygNav };
+export type { WysiwygNavProps };