@strapi/admin 4.20.4 → 5.0.0-alpha.0

package/dist/_chunks/zh-cZop7tV1.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"zh-cZop7tV1.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/admin/src/components/AuthenticatedApp.d.ts

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

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

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

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

@@ -1,19 +0,0 @@
-import * as React from 'react';
-import { type MessageDescriptor } from 'react-intl';
-import { HintProps } from '../Hint';
-import { BlocksEditor } from './BlocksEditor';
-interface BlocksInputProps extends Omit<React.ComponentPropsWithoutRef<typeof BlocksEditor>, 'placeholder'>, Pick<HintProps, 'hint'> {
-    intlLabel: MessageDescriptor;
-    attribute: {
-        type: string;
-        [key: string]: unknown;
-    };
-    placeholder?: MessageDescriptor;
-    description?: MessageDescriptor;
-    labelAction?: React.ReactNode;
-    required?: boolean;
-}
-declare const BlocksInput: React.ForwardRefExoticComponent<BlocksInputProps & React.RefAttributes<{
-    focus: () => void;
-}>>;
-export { BlocksInput };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,9 +0,0 @@
-interface HintProps {
-    id?: string;
-    error?: string;
-    name: string;
-    hint?: string;
-}
-declare const Hint: ({ id, error, name, hint }: HintProps) => import("react/jsx-runtime").JSX.Element | null;
-export { Hint };
-export type { HintProps };

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

@@ -1,16 +0,0 @@
-import * as React from 'react';
-import { TextInputProps } from '@strapi/design-system';
-import { CMEditViewDataManagerContextValue, TranslationMessage } from '@strapi/helper-plugin';
-interface InputUIDProps extends Pick<TextInputProps, 'disabled' | 'error' | 'hint' | 'labelAction' | 'required'>, Required<Pick<CMEditViewDataManagerContextValue, 'onChange'>> {
-    contentTypeUID: string;
-    intlLabel: TranslationMessage;
-    name: string;
-    placeholder?: TranslationMessage;
-    value: string;
-}
-declare const InputUID: React.ForwardRefExoticComponent<InputUIDProps & React.RefAttributes<{
-    inputWrapperRef: React.MutableRefObject<HTMLDivElement>;
-    input: React.MutableRefObject<HTMLInputElement>;
-}>>;
-export { InputUID };
-export type { InputUIDProps };

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

@@ -1,11 +0,0 @@
-import * as React from 'react';
-import { LazyComponentStore } from '../hooks/useLazyComponents';
-import { EditLayoutRow } from '../utils/layouts';
-interface InputProps extends Pick<EditLayoutRow, 'fieldSchema' | 'metadatas' | 'queryInfos' | 'size'> {
-    componentUid?: string;
-    keys: string;
-    labelAction?: React.ReactNode;
-    customFieldInputs: LazyComponentStore;
-}
-declare const Inputs: ({ componentUid, fieldSchema, keys, labelAction, metadatas, queryInfos, size, customFieldInputs, }: InputProps) => import("react/jsx-runtime").JSX.Element | null;
-export { Inputs };

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

@@ -1,9 +0,0 @@
-interface NonRepeatableComponentProps {
-    componentUid: string;
-    isFromDynamicZone?: boolean;
-    isNested?: boolean;
-    name: string;
-}
-declare const NonRepeatableComponent: ({ componentUid, isFromDynamicZone, isNested, name, }: NonRepeatableComponentProps) => import("react/jsx-runtime").JSX.Element;
-export { NonRepeatableComponent };
-export type { NonRepeatableComponentProps };

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

@@ -1,62 +0,0 @@
-import * as React from 'react';
-import { FlexProps, ComboboxProps } from '@strapi/design-system';
-import { ListChildComponentProps } from 'react-window';
-import { UseDragAndDropOptions } from '../../hooks/useDragAndDrop';
-import type { NormalizedRelation } from './utils/normalizeRelations';
-import type { Contracts } from '@strapi/plugin-content-manager/_internal/shared';
-import type { Entity } from '@strapi/types';
-interface RelationInputProps extends Pick<ComboboxProps, 'disabled' | 'error' | 'id' | 'labelAction' | 'placeholder' | 'required'>, Pick<RelationItemProps, 'onCancel' | 'onDropItem' | 'onGrabItem' | 'iconButtonAriaLabel'> {
-    canReorder: boolean;
-    description: ComboboxProps['hint'];
-    numberOfRelationsToDisplay: number;
-    label: string;
-    labelLoadMore?: string;
-    labelDisconnectRelation: string;
-    listAriaDescription: string;
-    liveText: string;
-    loadingMessage: string;
-    name: string;
-    noRelationsMessage: string;
-    onRelationConnect: (relation: Contracts.Relations.RelationResult) => void;
-    onRelationLoadMore: () => void;
-    onRelationDisconnect: (relation: NormalizedRelation) => void;
-    onRelationReorder?: (currentIndex: number, newIndex: number) => void;
-    onSearchNextPage: () => void;
-    onSearch: (searchTerm?: string) => void;
-    publicationStateTranslations: {
-        draft: string;
-        published: string;
-    };
-    relations: {
-        data: NormalizedRelation[];
-        isLoading: boolean;
-        isFetchingNextPage: boolean;
-        hasNextPage?: boolean;
-    };
-    searchResults: {
-        data: NormalizedRelation[];
-        isLoading: boolean;
-        hasNextPage?: boolean;
-    };
-    size: number;
-}
-declare const RelationInput: ({ canReorder, description, disabled, error, iconButtonAriaLabel, id, name, numberOfRelationsToDisplay, label, labelAction, labelLoadMore, labelDisconnectRelation, listAriaDescription, liveText, loadingMessage, onCancel, onDropItem, onGrabItem, noRelationsMessage, onRelationConnect, onRelationLoadMore, onRelationDisconnect, onRelationReorder, onSearchNextPage, onSearch, placeholder, publicationStateTranslations, required, relations: paginatedRelations, searchResults, size, }: RelationInputProps) => import("react/jsx-runtime").JSX.Element;
-declare const DisconnectButton: import("styled-components").StyledComponent<"button", import("styled-components").DefaultTheme, {}, never>;
-declare const LinkEllipsis: import("styled-components").StyledComponent<React.ForwardRefExoticComponent<import("@strapi/design-system/Link/Link.js").LinkProps & React.RefAttributes<HTMLAnchorElement>>, import("styled-components").DefaultTheme, {}, never>;
-interface RelationItemProps extends Pick<UseDragAndDropOptions, 'onCancel' | 'onDropItem' | 'onGrabItem'>, Omit<FlexProps, 'id' | 'style'>, Pick<ListChildComponentProps, 'style' | 'index'> {
-    ariaDescribedBy: string;
-    canDrag: boolean;
-    children: React.ReactNode;
-    displayValue: string;
-    disabled: boolean;
-    endAction: React.ReactNode;
-    iconButtonAriaLabel: string;
-    id: Entity.ID;
-    name: string;
-    status?: NormalizedRelation['publicationState'];
-    updatePositionOfRelation: UseDragAndDropOptions['onMoveItem'];
-}
-declare const FlexWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, FlexProps<"div">, never>;
-declare const ChildrenWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, FlexProps<"div">, never>;
-export { RelationInput, FlexWrapper, ChildrenWrapper, LinkEllipsis, DisconnectButton };
-export type { RelationInputProps };

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

@@ -1,26 +0,0 @@
-import { MessageDescriptor } from 'react-intl';
-import { RelationInputProps } from './RelationInput';
-declare const PUBLICATION_STATES: {
-    readonly DRAFT: "draft";
-    readonly PUBLISHED: "published";
-};
-interface RelationInputDataManagerProps extends Pick<RelationInputProps, 'description' | 'error' | 'labelAction' | 'name' | 'required' | 'size'> {
-    componentUid?: string;
-    editable?: boolean;
-    intlLabel: MessageDescriptor;
-    isUserAllowedToEditField?: boolean;
-    isUserAllowedToReadField?: boolean;
-    mainField: {
-        name: string;
-    };
-    placeholder?: MessageDescriptor;
-    queryInfos: {
-        defaultParams?: object;
-        shouldDisplayRelationLink?: boolean;
-    };
-    relationType: string;
-    targetModel: string;
-}
-declare const RelationInputDataManager: ({ componentUid, name, error, editable, description, intlLabel, isUserAllowedToEditField, isUserAllowedToReadField, labelAction, mainField, placeholder, queryInfos: { defaultParams, shouldDisplayRelationLink }, required, relationType, size, targetModel, }: RelationInputDataManagerProps) => import("react/jsx-runtime").JSX.Element;
-export { RelationInputDataManager, PUBLICATION_STATES };
-export type { RelationInputDataManagerProps };