@akbarsafari00/bonyan-content-manager 5.52.1-fa.2

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

@@ -0,0 +1,83 @@
+import * as React from 'react';
+import { type UseDocument } from '../../../../../hooks/useDocument';
+import { type DocumentMeta } from '../../../../../hooks/useDocumentContext';
+import type { RelationOpenMode } from '../../../../../../../shared/contracts/content-types';
+import type { AnyData } from '../../../utils/data';
+export declare function getCollectionType(url: string): string | undefined;
+declare const getFullPageUrl: (currentDocumentMeta: DocumentMeta) => string;
+interface State {
+    documentHistory: DocumentMeta[];
+    confirmDialogIntent: null | 'close' | 'back' | 'navigate' | DocumentMeta;
+    isModalOpen: boolean;
+    hasUnsavedChanges: boolean;
+    fieldToConnect?: string;
+    fieldToConnectUID?: string;
+    getParentFormValues?: () => AnyData;
+}
+type Action = {
+    type: 'GO_TO_RELATION';
+    payload: {
+        document: DocumentMeta;
+        shouldBypassConfirmation: boolean;
+        fieldToConnect?: string;
+        fieldToConnectUID?: string;
+        getParentFormValues?: () => AnyData;
+    };
+} | {
+    type: 'GO_BACK';
+    payload: {
+        shouldBypassConfirmation: boolean;
+    };
+} | {
+    type: 'GO_FULL_PAGE';
+} | {
+    type: 'GO_TO_CREATED_RELATION';
+    payload: {
+        document: DocumentMeta;
+        shouldBypassConfirmation: boolean;
+        fieldToConnect?: string;
+        fieldToConnectUID?: string;
+        getParentFormValues?: () => AnyData;
+    };
+} | {
+    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;
+    relationOpenMode: RelationOpenMode;
+}
+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;
+        relationOpenMode: RelationOpenMode;
+    }) => 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;
+declare const generateCreateUrl: (currentDocumentMeta: DocumentMeta) => string;
+export { reducer, RelationModalRenderer, useRelationModal, getFullPageUrl, generateCreateUrl };
+export type { State, Action, RelationOpenMode };

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

@@ -0,0 +1,57 @@
+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;
+    start?: never;
+    end?: never;
+}) | {
+    start: boolean;
+    before?: never;
+    end?: never;
+    status?: never;
+    locale?: never;
+} | {
+    end: boolean;
+    before?: never;
+    start?: 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' | 'status'>[];
+}
+declare const FlexWrapper: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<Omit<Omit<import("@strapi/design-system").FlexProps<"div">, "ref"> & React.RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void | React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | React.RefObject<unknown> | null | undefined;
+}, never> & Partial<Pick<Omit<Omit<import("@strapi/design-system").FlexProps<"div">, "ref"> & React.RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void | React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | React.RefObject<unknown> | null | undefined;
+}, never>>> & string & Omit<FlexComponent, keyof React.Component<any, {}, any>>;
+declare const DisconnectButton: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never> & Partial<Pick<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>>> & string;
+declare const LinkEllipsis: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").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.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | React.RefObject<unknown> | null | undefined;
+}, never> & Partial<Pick<Omit<Omit<import("@strapi/design-system").LinkProps<React.ElementType<any, keyof React.JSX.IntrinsicElements>>, "ref"> & React.RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void | React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | React.RefObject<unknown> | null | undefined;
+}, never>>> & string & 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<HTMLInputElement>>>;
+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<string>, '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,16 @@
+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/dist/types").IStyledComponentBase<"web", import("styled-components").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.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | React.RefObject<unknown> | null | undefined;
+}, never> & Partial<Pick<Omit<Omit<import("@strapi/design-system").ButtonProps<React.ElementType<any, keyof React.JSX.IntrinsicElements>>, "ref"> & React.RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void | React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | React.RefObject<unknown> | null | undefined;
+}, never>>> & string & 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,21 @@
+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;
+}
+interface WysiwygPreviewToggleButtonProps {
+    isPreviewMode?: boolean;
+    onTogglePreviewMode: () => void;
+}
+declare const WysiwygPreviewToggleButton: ({ isPreviewMode, onTogglePreviewMode, }: WysiwygPreviewToggleButtonProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * TODO: refactor this mess.
+ */
+declare const WysiwygNav: ({ disabled, editorRef, isPreviewMode, onToggleMediaLib, onTogglePreviewMode, }: WysiwygNavProps) => import("react/jsx-runtime").JSX.Element;
+export { WysiwygNav, WysiwygPreviewToggleButton };
+export type { WysiwygNavProps, WysiwygPreviewToggleButtonProps };

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

@@ -0,0 +1,49 @@
+import { IconButtonComponent } from '@strapi/design-system';
+export declare const MainButtons: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<Omit<Omit<import("@strapi/design-system").FlexProps<"div">, "ref"> & import("react").RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void) | React.RefObject<unknown> | null | undefined;
+}, never> & {
+    as?: import("styled-components").WebTarget | undefined;
+    forwardedAs?: import("styled-components").WebTarget | undefined;
+}, never> & Partial<Pick<import("styled-components").FastOmit<Omit<Omit<import("@strapi/design-system").FlexProps<"div">, "ref"> & import("react").RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void) | React.RefObject<unknown> | null | undefined;
+}, never> & {
+    as?: import("styled-components").WebTarget | undefined;
+    forwardedAs?: import("styled-components").WebTarget | undefined;
+}, never>>> & string;
+export declare const MoreButton: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("@strapi/design-system").TransientBoxProps & {
+    children?: React.ReactNode;
+} & import("@strapi/design-system/dist/types").AsProp<"button"> & Omit<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "children" | keyof import("@strapi/design-system/dist/types").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
+    ref?: ((instance: HTMLButtonElement | null) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<HTMLButtonElement> | null | undefined;
+} & import("@strapi/design-system").TransientFlexProps & Pick<import("@strapi/design-system").ButtonProps, "type" | "size" | "variant"> & {
+    children: React.ReactNode;
+    disabled?: boolean;
+    label: string;
+    onClick?: React.MouseEventHandler<HTMLButtonElement>;
+    withTooltip?: boolean;
+}, never> & Partial<Pick<import("@strapi/design-system").TransientBoxProps & {
+    children?: React.ReactNode;
+} & import("@strapi/design-system/dist/types").AsProp<"button"> & Omit<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "children" | keyof import("@strapi/design-system/dist/types").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
+    ref?: ((instance: HTMLButtonElement | null) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<HTMLButtonElement> | null | undefined;
+} & import("@strapi/design-system").TransientFlexProps & Pick<import("@strapi/design-system").ButtonProps, "type" | "size" | "variant"> & {
+    children: React.ReactNode;
+    disabled?: boolean;
+    label: string;
+    onClick?: React.MouseEventHandler<HTMLButtonElement>;
+    withTooltip?: boolean;
+}, never>>> & string & Omit<IconButtonComponent, keyof import("react").Component<any, {}, any>>;
+export declare const IconButtonGroupMargin: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<Omit<Omit<import("@strapi/design-system").FlexProps<"div">, "ref"> & import("react").RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void) | React.RefObject<unknown> | null | undefined;
+}, never> & {
+    as?: import("styled-components").WebTarget | undefined;
+    forwardedAs?: import("styled-components").WebTarget | undefined;
+}, never> & Partial<Pick<import("styled-components").FastOmit<Omit<Omit<import("@strapi/design-system").FlexProps<"div">, "ref"> & import("react").RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void) | React.RefObject<unknown> | null | undefined;
+}, never> & {
+    as?: import("styled-components").WebTarget | undefined;
+    forwardedAs?: import("styled-components").WebTarget | undefined;
+}, never>>> & string;
+export declare const ExpandButton: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<Omit<Omit<import("@strapi/design-system").ButtonProps<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>>, "ref"> & import("react").RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<unknown> | null | undefined;
+}, never> & Partial<Pick<Omit<Omit<import("@strapi/design-system").ButtonProps<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>>, "ref"> & import("react").RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<unknown> | null | undefined;
+}, never>>> & string & 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 import("react").Component<any, {}, any>>;

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

@@ -0,0 +1,5 @@
+import CodeMirror from 'codemirror5';
+declare function newlineAndIndentContinueMarkdownList(cm: CodeMirror.Editor): {
+    toString(): "CodeMirror.PASS";
+} | undefined;
+export { newlineAndIndentContinueMarkdownList };

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

@@ -0,0 +1,4 @@
+import Markdown from 'markdown-it';
+import 'highlight.js/styles/solarized-dark.css';
+declare const md: Markdown;
+export { md };

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

@@ -0,0 +1,2 @@
+declare const sanitize: (html: string) => string;
+export { sanitize };

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

@@ -0,0 +1,22 @@
+import { MutableRefObject } from 'react';
+import CodeMirror from 'codemirror5';
+export declare const replaceText: (markdownName: string, textToChange: string) => string;
+export declare const insertText: (markdownName: string) => {
+    editedText: string;
+    selection: {
+        start: number;
+        end: number;
+    };
+};
+export declare const insertListOrTitle: (markdown: string) => string;
+export declare const markdownHandler: (editor: MutableRefObject<CodeMirror.EditorFromTextArea>, markdownType: string) => void;
+export declare const listHandler: (editor: MutableRefObject<CodeMirror.EditorFromTextArea>, listType: string) => void;
+export declare const titleHandler: (editor: MutableRefObject<CodeMirror.EditorFromTextArea>, titleType: string) => void;
+type FileToInsert = {
+    alt: string;
+    url: string;
+    mime: string;
+};
+export declare const insertFile: (editor: MutableRefObject<CodeMirror.EditorFromTextArea>, files: FileToInsert[]) => void;
+export declare const quoteAndCodeHandler: (editor: MutableRefObject<CodeMirror.EditorFromTextArea>, markdownType: string) => void;
+export {};

package/dist/admin/src/pages/EditView/components/FormLayout.d.ts

@@ -0,0 +1,56 @@
+import * as React from 'react';
+import { Grid } from '@strapi/design-system';
+import { EditLayout } from '../../../hooks/useDocumentLayout';
+import type { UseDocument } from '../../../hooks/useDocument';
+export declare const ResponsiveGridRoot: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<Omit<import("@strapi/design-system").TransientBoxProps & {
+    children?: React.ReactNode;
+} & import("@strapi/design-system/dist/types").AsProp<React.ElementType<any, keyof React.JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
+    ref?: any;
+} & {
+    gridCols?: number;
+    gap?: import("@strapi/design-system").ResponsiveThemeProperty<"spaces", "gap">;
+}, "ref"> & {
+    ref?: any;
+}, never> & Partial<Pick<Omit<import("@strapi/design-system").TransientBoxProps & {
+    children?: React.ReactNode;
+} & import("@strapi/design-system/dist/types").AsProp<React.ElementType<any, keyof React.JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
+    ref?: any;
+} & {
+    gridCols?: number;
+    gap?: import("@strapi/design-system").ResponsiveThemeProperty<"spaces", "gap">;
+}, "ref"> & {
+    ref?: any;
+}, never>>> & string & Omit<Grid.Component<"div">, keyof React.Component<any, {}, any>>;
+export declare const ResponsiveGridItem: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<Omit<import("@strapi/design-system").TransientBoxProps & {
+    children?: React.ReactNode;
+} & import("@strapi/design-system/dist/types").AsProp<React.ElementType<any, keyof React.JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
+    ref?: any;
+} & import("@strapi/design-system").TransientFlexProps & {
+    col?: number;
+    s?: number;
+    xs?: number;
+    m?: number;
+}, "ref"> & {
+    ref?: any;
+}, "col"> & {
+    col: number;
+}, never> & Partial<Pick<import("styled-components").FastOmit<Omit<import("@strapi/design-system").TransientBoxProps & {
+    children?: React.ReactNode;
+} & import("@strapi/design-system/dist/types").AsProp<React.ElementType<any, keyof React.JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
+    ref?: any;
+} & import("@strapi/design-system").TransientFlexProps & {
+    col?: number;
+    s?: number;
+    xs?: number;
+    m?: number;
+}, "ref"> & {
+    ref?: any;
+}, "col"> & {
+    col: number;
+}, never>>> & string & Omit<Grid.ItemComponent<"div">, keyof React.Component<any, {}, any>>;
+interface FormLayoutProps extends Pick<EditLayout, 'layout'> {
+    hasBackground?: boolean;
+    document: ReturnType<UseDocument>;
+}
+declare const FormLayout: React.MemoExoticComponent<({ layout, document, hasBackground }: FormLayoutProps) => import("react/jsx-runtime").JSX.Element>;
+export { FormLayout, FormLayoutProps };

package/dist/admin/src/pages/EditView/components/Header.d.ts

@@ -0,0 +1,50 @@
+import * as React from 'react';
+import type { DocumentActionComponent } from '../../../content-manager';
+interface HeaderProps {
+    isCreating?: boolean;
+    status?: 'draft' | 'published' | 'modified';
+    title?: string;
+}
+declare const Header: ({ isCreating, status, title: documentTitle }: HeaderProps) => import("react/jsx-runtime").JSX.Element;
+interface DialogOptions {
+    type: 'dialog';
+    title: string;
+    content?: React.ReactNode;
+    footer?: React.ReactNode;
+}
+interface HeaderActionDescription {
+    disabled?: boolean;
+    label: string;
+    icon?: React.ReactNode;
+    type?: 'icon' | 'default';
+    onClick?: (event: React.SyntheticEvent) => Promise<boolean | void> | boolean | void;
+    dialog?: DialogOptions;
+    options?: Array<{
+        disabled?: boolean;
+        label: string;
+        startIcon?: React.ReactNode;
+        textValue?: string;
+        value: string;
+        /**
+         * @internal
+         * @description
+         * Internal SelectOption renderer used to display the status of AI translation background jobs
+         */
+        _render?: () => React.ReactNode;
+    }>;
+    /**
+     * @internal
+     * @description
+     * Internal document header action to display the status of AI translation background jobs
+     */
+    _status?: {
+        message: React.ReactNode;
+        tooltip?: React.ReactNode;
+    };
+    onSelect?: (value: string) => void;
+    value?: string;
+    customizeContent?: (value: string) => React.ReactNode;
+}
+declare const DEFAULT_HEADER_ACTIONS: DocumentActionComponent[];
+export { Header, DEFAULT_HEADER_ACTIONS };
+export type { HeaderProps, HeaderActionDescription };

package/dist/admin/src/pages/EditView/components/InputRenderer.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { type UseDocument } from '../../../hooks/useDocument';
+import type { EditFieldLayout } from '../../../hooks/useDocumentLayout';
+import type { Schema } from '@strapi/types';
+import type { DistributiveOmit } from 'react-redux';
+type InputRendererProps = DistributiveOmit<EditFieldLayout, 'size'> & {
+    document?: ReturnType<UseDocument>;
+};
+declare const useFieldHint: (hint: React.ReactNode, attribute: Schema.Attribute.AnyAttribute) => string | number | boolean | import("react/jsx-runtime").JSX.Element | Iterable<React.ReactNode> | (string | import("react/jsx-runtime").JSX.Element | React.ReactElement<any, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | React.ReactPortal)[] | null | undefined;
+/**
+ * Conditionally routes the exported InputRender component towards ConditionalInputRenderer
+ * (when there's a JSON logic condition on the attribute, or BaseInputRenderer otherwise.
+ * We do this because rendering a conditional field requires access to the values of
+ * other form fields, which causes many re-renders and performance issues on complex content
+ * types. By splitting the component into two, we isolate the performance issue to
+ * conditional fields only, not all edit view fields.
+ */
+declare const MemoizedInputRenderer: React.MemoExoticComponent<(props: InputRendererProps) => import("react/jsx-runtime").JSX.Element>;
+export type { InputRendererProps };
+export { MemoizedInputRenderer as InputRenderer, useFieldHint };

package/dist/admin/src/pages/EditView/components/Panels.d.ts

@@ -0,0 +1,22 @@
+import * as React from 'react';
+import type { PanelComponent } from '../../../content-manager';
+interface PanelDescription {
+    title: string;
+    content: React.ReactNode;
+}
+declare const Panels: ({ withActions }: {
+    withActions?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const ActionsPanel: PanelComponent;
+declare const ActionsPanelContent: () => import("react/jsx-runtime").JSX.Element;
+declare const usePanelsContext: <Selected, ShouldThrow extends boolean = true>(consumerName: string, selector: (value: {
+    visiblePanels: (PanelDescription & {
+        id: string;
+    })[];
+    setVisiblePanels: React.Dispatch<React.SetStateAction<(PanelDescription & {
+        id: string;
+    })[]>>;
+}) => Selected, shouldThrowOnMissingContext?: ShouldThrow | undefined) => ShouldThrow extends true ? Selected : Selected | undefined;
+declare const PanelsProvider: ({ children }: React.PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
+export { Panels, ActionsPanel, ActionsPanelContent, PanelsProvider, usePanelsContext };
+export type { PanelDescription };

package/dist/admin/src/pages/EditView/utils/data.d.ts

@@ -0,0 +1,57 @@
+import type { ComponentsDictionary, Document } from '../../../hooks/useDocument';
+import type { Schema } from '@strapi/types';
+type PartialSchema = Partial<Schema.Schema> & Pick<Schema.Schema, 'attributes'>;
+type AnyData = Omit<Document, 'id'>;
+/**
+ * @internal
+ * @description Returns the direct parent object for a dot-separated path.
+ */
+declare const getDirectParent: (data: unknown, path: string) => unknown;
+/**
+ * @internal Removes all the fields that are not allowed.
+ */
+declare const removeProhibitedFields: (prohibitedFields: Schema.Attribute.Kind[]) => (schema: PartialSchema, components?: ComponentsDictionary) => (data?: AnyData) => AnyData;
+/**
+ * @internal
+ * @description Sets all relation values to an empty array.
+ */
+declare const prepareRelations: (schema: PartialSchema, components?: ComponentsDictionary) => (data?: AnyData) => AnyData;
+/**
+ * @internal
+ * @description Adds a `__temp_key__` to each component and dynamiczone item. This gives us
+ * a stable identifier regardless of its ids etc. that we can then use for drag and drop.
+ */
+declare const prepareTempKeys: (schema: PartialSchema, components?: ComponentsDictionary) => (data?: AnyData) => AnyData;
+/**
+ * @internal
+ * @description Fields that don't exist in the schema like createdAt etc. are only on the first level (not nested),
+ * as such we don't need to traverse the components to remove them.
+ */
+declare const removeFieldsThatDontExistOnSchema: (schema: PartialSchema) => (data: AnyData) => AnyData;
+/**
+ * @internal
+ * @description Takes a document data structure (this could be from the API or a default form structure)
+ * and applies consistent data transformations to it. This is also used when we add new components to the
+ * form to ensure the data is correctly prepared from their default state e.g. relations are set to an empty array.
+ */
+declare const transformDocument: (schema: PartialSchema, components?: ComponentsDictionary) => (document: AnyData) => AnyData;
+type HandleOptions = {
+    schema?: Schema.ContentType | Schema.Component;
+    initialValues?: AnyData;
+    components?: Record<string, Schema.Component>;
+};
+type RemovedFieldPath = string;
+/**
+ * Removes values from the data object if their corresponding attribute has a
+ * visibility condition that evaluates to false.
+ *
+ * @param data - The data object to filter based on visibility
+ * @param options - Schema, initialValues, and components
+ * @returns Object with filtered data and list of removed attribute paths
+ */
+declare const handleInvisibleAttributes: (data: AnyData, { schema, initialValues, components }: HandleOptions) => {
+    data: AnyData;
+    removedAttributes: RemovedFieldPath[];
+};
+export { removeProhibitedFields, prepareRelations, prepareTempKeys, removeFieldsThatDontExistOnSchema, transformDocument, handleInvisibleAttributes, getDirectParent, };
+export type { AnyData };

package/dist/admin/src/pages/EditView/utils/draftRelationCounts.d.ts

@@ -0,0 +1,27 @@
+import type { Component } from '../../../../../shared/contracts/components';
+import type { ComponentsDictionary, Schema } from '../../../hooks/useDocument';
+export interface DraftRelationCounts {
+    unpublishedRelations: number;
+    draftM2mLinks: number;
+}
+export declare const EMPTY_DRAFT_RELATION_COUNTS: DraftRelationCounts;
+export declare const isBidirectionalManyToMany: (attribute: Schema["attributes"][string]) => boolean;
+export declare const mergeDraftRelationCounts: (left: DraftRelationCounts, right: DraftRelationCounts) => DraftRelationCounts;
+export declare const clampDraftRelationCounts: (counts: DraftRelationCounts) => DraftRelationCounts;
+export declare const normalizeDraftRelationCounts: (payload: unknown) => DraftRelationCounts;
+export declare const resolveDraftRelationCounts: (documentId: string | undefined, modified: boolean, localCounts: DraftRelationCounts, serverCounts: DraftRelationCounts) => DraftRelationCounts;
+export interface DraftRelationsPublishState {
+    hasUnpublishedRelations: boolean;
+    hasDraftM2mLinks: boolean;
+    hasDraftRelations: boolean;
+    isM2mOnlyDraftRelations: boolean;
+    dialogVariant: 'default' | 'danger';
+    bodyIcon: 'default' | 'danger';
+    confirmLabel: 'publish' | 'publish-without-relations';
+}
+export declare const getDraftRelationsPublishState: (counts: DraftRelationCounts) => DraftRelationsPublishState;
+/**
+ * Counts draft relations in unsaved form values, excluding self-referential relations
+ * (preserved on publish via document-service self-referential-relations).
+ */
+export declare const countLocalDraftRelations: (data: Record<string, unknown>, schema: Schema | Component | undefined, components: ComponentsDictionary, contentTypeUid: string) => DraftRelationCounts;

package/dist/admin/src/pages/EditView/utils/forms.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentsDictionary, Document } from '../../../hooks/useDocument';
+import type { Schema } from '@strapi/types';
+type AnyData = Omit<Document, 'id'>;
+/**
+ * @internal Using the content-type schema & the components dictionary of the content-type,
+ * creates a form with pre-filled default values. This is used when creating a new entry.
+ */
+declare const createDefaultForm: (contentType: Schema.Schema, components?: ComponentsDictionary) => AnyData;
+export { createDefaultForm };

package/dist/admin/src/pages/EditView/utils/keyboardShortcuts.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The document actions that can be triggered with a keyboard shortcut from the edit view.
+ */
+export type EditViewShortcut = 'save' | 'publish';
+/**
+ * Resolves the document action intended by a keyboard event in the edit view.
+ *
+ * The platform modifier (`Cmd` on macOS, `Ctrl` on Windows/Linux) is always required so the
+ * shortcuts never collide with a plain `Enter` (new line in a textarea, native form submit in a
+ * single-line input).
+ *
+ * - `Cmd/Ctrl + Enter`         → save (draft)
+ * - `Cmd/Ctrl + S`             → save (draft) — common editor alias
+ * - `Cmd/Ctrl + Shift + Enter` → publish
+ *
+ * Returns `null` when the event does not match any shortcut.
+ */
+export declare const getEditViewShortcut: (event: KeyboardEvent) => EditViewShortcut | null;

package/dist/admin/src/pages/ListConfiguration/ListConfigurationPage.d.ts

@@ -0,0 +1,10 @@
+import { type ListFieldLayout, type ListLayout } from '../../hooks/useDocumentLayout';
+interface FormData extends Pick<ListLayout, 'settings'> {
+    layout: Array<Pick<ListFieldLayout, 'sortable' | 'name'> & {
+        label: string;
+    }>;
+}
+declare const ListConfiguration: () => import("react/jsx-runtime").JSX.Element;
+declare const ProtectedListConfiguration: () => import("react/jsx-runtime").JSX.Element;
+export { ProtectedListConfiguration, ListConfiguration };
+export type { FormData };

package/dist/admin/src/pages/ListConfiguration/components/DraggableCard.d.ts

@@ -0,0 +1,12 @@
+import type { ListFieldLayout } from '../../../hooks/useDocumentLayout';
+type DraggableCardProps = Omit<ListFieldLayout, 'label'> & {
+    label: string;
+    index: number;
+    isDraggingSibling: boolean;
+    onMoveField: (dragIndex: number, hoverIndex: number) => void;
+    onRemoveField: () => void;
+    setIsDraggingSibling: (isDragging: boolean) => void;
+};
+declare const DraggableCard: ({ attribute, index, isDraggingSibling, label, name, onMoveField, onRemoveField, setIsDraggingSibling, }: DraggableCardProps) => import("react/jsx-runtime").JSX.Element;
+export { DraggableCard };
+export type { DraggableCardProps };