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

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

@@ -0,0 +1,93 @@
+import * as React from 'react';
+import { NotificationConfig } from '@strapi/admin/strapi-admin';
+import { ButtonProps } from '@strapi/design-system';
+import type { DocumentActionComponent } from '../../../content-manager';
+type PublishConfirmDialogScope = 'panel' | 'preview' | 'relation-modal';
+declare const openPublishConfirmDialog: (scope: PublishConfirmDialogScope) => void;
+type DocumentActionPosition = 'panel' | 'header' | 'table-row' | 'preview' | 'relation-modal';
+interface DocumentActionDescription {
+    label: string;
+    type?: 'publish' | 'update' | 'unpublish' | 'discard';
+    onClick?: (event: React.SyntheticEvent) => Promise<boolean | void> | boolean | void;
+    icon?: React.ReactNode;
+    /**
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * @default 'panel'
+     * @description Where the action should be rendered.
+     */
+    position?: DocumentActionPosition | DocumentActionPosition[];
+    dialog?: DialogOptions | NotificationOptions | ModalOptions;
+    /**
+     * @default 'secondary'
+     */
+    variant?: ButtonProps['variant'];
+    loading?: ButtonProps['loading'];
+    /**
+     * When set on a publish action with a dialog, registers an opener for the keyboard shortcut.
+     */
+    publishConfirmScope?: PublishConfirmDialogScope;
+}
+interface DialogOptions {
+    type: 'dialog';
+    title: string;
+    content?: React.ReactNode;
+    /**
+     * When set, centers a warning icon above the dialog body (bulk publish / delete pattern).
+     */
+    bodyIcon?: 'danger' | 'default';
+    variant?: ButtonProps['variant'];
+    confirmLabel?: string;
+    onConfirm?: () => void | Promise<void>;
+    onCancel?: () => void | Promise<void>;
+}
+interface NotificationOptions {
+    type: 'notification';
+    title: string;
+    link?: {
+        label: string;
+        url: string;
+        target?: string;
+    };
+    content?: string;
+    onClose?: () => void;
+    status?: NotificationConfig['type'];
+    timeout?: number;
+}
+interface ModalOptions {
+    type: 'modal';
+    title: string;
+    content: React.ComponentType<{
+        onClose: () => void;
+    }> | React.ReactNode;
+    footer?: React.ComponentType<{
+        onClose: () => void;
+    }> | React.ReactNode;
+    onClose?: () => void;
+}
+interface Action extends DocumentActionDescription {
+    id: string;
+}
+interface DocumentActionsProps {
+    actions: Action[];
+}
+declare const DocumentActions: ({ actions }: DocumentActionsProps) => import("react/jsx-runtime").JSX.Element | null;
+interface DocumentActionButtonProps extends Omit<Action, 'type'> {
+    buttonType?: 'button' | 'submit' | 'reset';
+    type?: DocumentActionDescription['type'];
+}
+declare const DocumentActionButton: ({ buttonType, ...action }: DocumentActionButtonProps) => import("react/jsx-runtime").JSX.Element;
+interface DocumentActionsMenuProps {
+    actions: Action[];
+    children?: React.ReactNode;
+    label?: string;
+    variant?: 'ghost' | 'tertiary';
+}
+declare const DocumentActionsMenu: ({ actions, children, label, variant, }: DocumentActionsMenuProps) => import("react/jsx-runtime").JSX.Element;
+declare const PublishAction: DocumentActionComponent;
+declare const UpdateAction: DocumentActionComponent;
+declare const DEFAULT_ACTIONS: DocumentActionComponent[];
+export { DocumentActions, DocumentActionsMenu, DocumentActionButton, PublishAction, UpdateAction, DEFAULT_ACTIONS, openPublishConfirmDialog, };
+export type { DocumentActionDescription, DocumentActionPosition, DialogOptions, NotificationOptions, ModalOptions, };

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

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

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

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { Menu } from '@strapi/design-system';
+export interface ObservedComponent {
+    toolbar: React.ReactNode;
+    menu: React.ReactNode;
+    key: string;
+}
+export declare const EditorToolbarObserver: ({ observedComponents, menuTriggerVariant, }: {
+    observedComponents: ObservedComponent[];
+    menuTriggerVariant?: Menu.TriggerProps["variant"];
+}) => import("react/jsx-runtime").JSX.Element[];

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

@@ -0,0 +1,58 @@
+import { BaseRange, NodeEntry } from 'slate';
+import { type BlocksStore } from '../BlocksEditor';
+import 'prismjs/themes/prism-solarizedlight.css';
+import 'prismjs/components/prism-asmatmel';
+import 'prismjs/components/prism-bash';
+import 'prismjs/components/prism-basic';
+import 'prismjs/components/prism-c';
+import 'prismjs/components/prism-clojure';
+import 'prismjs/components/prism-cobol';
+import 'prismjs/components/prism-cpp';
+import 'prismjs/components/prism-csharp';
+import 'prismjs/components/prism-dart';
+import 'prismjs/components/prism-docker';
+import 'prismjs/components/prism-elixir';
+import 'prismjs/components/prism-erlang';
+import 'prismjs/components/prism-fortran';
+import 'prismjs/components/prism-fsharp';
+import 'prismjs/components/prism-go';
+import 'prismjs/components/prism-graphql';
+import 'prismjs/components/prism-groovy';
+import 'prismjs/components/prism-haskell';
+import 'prismjs/components/prism-haxe';
+import 'prismjs/components/prism-ini';
+import 'prismjs/components/prism-java';
+import 'prismjs/components/prism-javascript';
+import 'prismjs/components/prism-jsx';
+import 'prismjs/components/prism-json';
+import 'prismjs/components/prism-julia';
+import 'prismjs/components/prism-kotlin';
+import 'prismjs/components/prism-latex';
+import 'prismjs/components/prism-lua';
+import 'prismjs/components/prism-markdown';
+import 'prismjs/components/prism-matlab';
+import 'prismjs/components/prism-makefile';
+import 'prismjs/components/prism-objectivec';
+import 'prismjs/components/prism-perl';
+import 'prismjs/components/prism-php';
+import 'prismjs/components/prism-powershell';
+import 'prismjs/components/prism-python';
+import 'prismjs/components/prism-r';
+import 'prismjs/components/prism-ruby';
+import 'prismjs/components/prism-rust';
+import 'prismjs/components/prism-sas';
+import 'prismjs/components/prism-scala';
+import 'prismjs/components/prism-scheme';
+import 'prismjs/components/prism-sql';
+import 'prismjs/components/prism-stata';
+import 'prismjs/components/prism-swift';
+import 'prismjs/components/prism-typescript';
+import 'prismjs/components/prism-tsx';
+import 'prismjs/components/prism-vbnet';
+import 'prismjs/components/prism-yaml';
+type BaseRangeCustom = BaseRange & {
+    className: string;
+};
+export declare const decorateCode: ([node, path]: NodeEntry) => BaseRangeCustom[];
+declare const codeBlocks: Pick<BlocksStore, 'code'>;
+export { codeBlocks };

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

@@ -0,0 +1,3 @@
+import { type BlocksStore } from '../BlocksEditor';
+declare const headingBlocks: Pick<BlocksStore, 'heading-one' | 'heading-two' | 'heading-three' | 'heading-four' | 'heading-five' | 'heading-six'>;
+export { headingBlocks };

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

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

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

@@ -0,0 +1,11 @@
+import { BaseEditor, Editor, Path } from 'slate';
+import { type BlocksStore } from '../BlocksEditor';
+declare const insertLink: (editor: Editor, { url }: {
+    url: string;
+}) => void;
+declare const linkBlocks: Pick<BlocksStore, 'link'>;
+export interface LinkEditor extends BaseEditor {
+    lastInsertedLinkPath: Path | null;
+    shouldSaveLinkPath: boolean;
+}
+export { linkBlocks, insertLink };

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

@@ -0,0 +1,3 @@
+import { type BlocksStore } from '../BlocksEditor';
+declare const listBlocks: Pick<BlocksStore, 'list-ordered' | 'list-unordered' | 'list-item'>;
+export { listBlocks };

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

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

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,83 @@
+import * as React from 'react';
+import { type FieldValue } from '@strapi/admin/strapi-admin';
+import { MessageDescriptor } from 'react-intl';
+import { Editor, type Descendant, Element } 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 CustomNode extends Omit<Schema.Attribute.BlocksNode, 'type'> {
+    type: Schema.Attribute.BlocksNode['type'] | string;
+    level?: number;
+    format?: string;
+}
+interface BaseBlock {
+    renderElement: (props: RenderElementProps) => React.JSX.Element;
+    /** Function to check if a given node is of this type of block */
+    matchNode: (node: Schema.Attribute.BlocksNode | CustomNode) => boolean;
+    handleConvert?: (editor: Editor) => void | (() => React.JSX.Element);
+    handleEnterKey?: (editor: Editor) => void;
+    handleBackspaceKey?: (editor: Editor, event: React.KeyboardEvent<HTMLElement>) => void;
+    handleTab?: (editor: Editor) => void;
+    handleShiftTab?: (editor: Editor) => void;
+    snippets?: string[];
+    /** Adjust the vertical positioning of the drag-to-reorder grip icon */
+    dragHandleTopMargin?: CSSProperties['marginTop'];
+    /** A Slate plugin: function that will wrap the editor creation */
+    plugin?: (editor: Editor) => Editor;
+    /**
+     * Function that checks if an element should be draggable
+     * @default () => true */
+    isDraggable?: (element: Element) => boolean;
+}
+export interface NonSelectorBlock extends BaseBlock {
+    isInBlocksSelector?: false;
+}
+export 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 SelectorBlockKey;
+type BlocksStore = {
+    [K in SelectorBlockKey]: SelectorBlock;
+} & {
+    [K in NonSelectorBlockKey]: NonSelectorBlock;
+};
+type RichTextBlocksStore = Partial<BlocksStore> & Record<string, SelectorBlock | NonSelectorBlock>;
+interface BlocksEditorContextValue {
+    blocks: RichTextBlocksStore;
+    modifiers: ModifiersStore;
+    disabled: boolean;
+    name: string;
+    setLiveText: (text: string) => void;
+    isExpandedMode: boolean;
+    /** Push debounced Slate → form sync immediately (e.g. on Editable blur before Save). */
+    flushPendingFormSync: () => void;
+}
+declare const BlocksEditorProvider: {
+    (props: BlocksEditorContextValue & {
+        children: React.ReactNode;
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare function useBlocksEditorContext(consumerName: string): BlocksEditorContextValue & {
+    editor: Editor;
+};
+/**
+ * Normalize the blocks state to null if the editor state is considered empty,
+ * otherwise return the state
+ */
+declare const normalizeBlocksState: (editor: Editor, value: Schema.Attribute.BlocksValue | Descendant[]) => Schema.Attribute.BlocksValue | Descendant[] | null;
+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 RichTextBlocksStore, type SelectorBlockKey, BlocksEditor, BlocksEditorProvider, useBlocksEditorContext, isSelectorBlockKey, normalizeBlocksState, };

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/DefaultBlocksStore.d.ts

@@ -0,0 +1,3 @@
+import { BlocksStore } from './BlocksEditor';
+declare const defaultBlocksStore: BlocksStore;
+export { defaultBlocksStore };

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/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("../Blocks/Link").LinkEditor, "children"> & {
+    children: import("@strapi/types/dist/schema/attribute/index.js").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 Element>(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/types.d.ts

@@ -0,0 +1,8 @@
+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 function isNonNullable<T>(value: T): value is NonNullable<T>;
+export { type Block, getEntries, getKeys, isNonNullable };

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: ReadonlyArray<ReadonlyArray<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,6 @@
+import * as React from 'react';
+import type { ComponentInputProps } from './Input';
+type NonRepeatableComponentProps = Omit<ComponentInputProps, 'required' | 'label'>;
+declare const MemoizedNonRepeatableComponent: React.MemoExoticComponent<({ attribute, name, children, layout, }: NonRepeatableComponentProps) => import("react/jsx-runtime").JSX.Element>;
+export { MemoizedNonRepeatableComponent as NonRepeatableComponent };
+export type { NonRepeatableComponentProps };

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

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

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

@@ -0,0 +1,41 @@
+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: 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 | string;
+    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,17 @@
+import * as React from 'react';
+import { Accordion } from '@strapi/design-system';
+import type { Struct } from '@strapi/types';
+interface ComponentCategoryProps {
+    category: string;
+    components?: Array<{
+        uid: string;
+        displayName: string;
+        icon?: string;
+        preview?: Struct.PreviewImageValue;
+    }>;
+    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,28 @@
+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: (index: number) => void;
+    onMoveComponent: (dragIndex: number, hoverIndex: number) => void;
+    totalLength: number;
+    children?: (props: InputRendererProps) => React.ReactNode;
+    /**
+     * When true, the component's accordion will be forced open and scrolled into view.
+     * Used by the parent DynamicZone to auto-expand newly added components.
+     */
+    forceOpen?: boolean;
+    /**
+     * Called after the forceOpen has been handled (accordion opened + scrolled),
+     * so the parent can clear the forced state.
+     */
+    onForceOpenHandled?: () => void;
+}
+declare const MemoizedDynamicComponent: React.MemoExoticComponent<({ componentUid, disabled, index, name, onRemoveComponentClick, onMoveComponent, onGrabItem, onDropItem, onCancel, dynamicComponentsByCategory, onAddComponent, totalLength, children, forceOpen, onForceOpenHandled, }: DynamicComponentProps) => import("react/jsx-runtime").JSX.Element>;
+export { MemoizedDynamicComponent as 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 };