@strapi/admin 4.18.0 → 4.18.1-beta.1

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,32 @@
+declare const iconByTypes: {
+    biginteger: import("react/jsx-runtime").JSX.Element;
+    boolean: import("react/jsx-runtime").JSX.Element;
+    date: import("react/jsx-runtime").JSX.Element;
+    datetime: import("react/jsx-runtime").JSX.Element;
+    decimal: import("react/jsx-runtime").JSX.Element;
+    email: import("react/jsx-runtime").JSX.Element;
+    enum: import("react/jsx-runtime").JSX.Element;
+    enumeration: import("react/jsx-runtime").JSX.Element;
+    file: import("react/jsx-runtime").JSX.Element;
+    files: import("react/jsx-runtime").JSX.Element;
+    float: import("react/jsx-runtime").JSX.Element;
+    integer: import("react/jsx-runtime").JSX.Element;
+    media: import("react/jsx-runtime").JSX.Element;
+    number: import("react/jsx-runtime").JSX.Element;
+    relation: import("react/jsx-runtime").JSX.Element;
+    string: import("react/jsx-runtime").JSX.Element;
+    text: import("react/jsx-runtime").JSX.Element;
+    richtext: import("react/jsx-runtime").JSX.Element;
+    time: import("react/jsx-runtime").JSX.Element;
+    timestamp: import("react/jsx-runtime").JSX.Element;
+    json: import("react/jsx-runtime").JSX.Element;
+    uid: import("react/jsx-runtime").JSX.Element;
+    component: import("react/jsx-runtime").JSX.Element;
+    dynamiczone: import("react/jsx-runtime").JSX.Element;
+};
+interface FieldTypeIconProps {
+    type: keyof typeof iconByTypes;
+    customFieldUid?: string;
+}
+declare const FieldTypeIcon: ({ type, customFieldUid }: FieldTypeIconProps) => import("react/jsx-runtime").JSX.Element | null;
+export { FieldTypeIcon };

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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,11 @@
+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/LeftMenu.d.ts

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

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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,62 @@
+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

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

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

@@ -0,0 +1,31 @@
+import { NormalizeRelationArgs, NormalizedRelation } from './utils/normalizeRelations';
+import type { Contracts } from '@strapi/plugin-content-manager/_internal/shared';
+interface UseRelationArgs {
+    relation: {
+        enabled: boolean;
+        endpoint: string;
+        normalizeArguments: NormalizeRelationArgs;
+        onLoad: (data: NormalizedRelation[]) => void;
+        pageParams?: Record<string, any>;
+        pageGoal?: number;
+    };
+    search: {
+        endpoint: string;
+        pageParams?: Record<string, any>;
+    };
+}
+declare const useRelation: (cacheKey: any[] | undefined, { relation, search }: UseRelationArgs) => {
+    relations: import("react-query").UseInfiniteQueryResult<{
+        pagination: {
+            page: number;
+            pageSize: number;
+            pageCount: number;
+            total: number;
+        } | undefined;
+        results: Contracts.Relations.RelationResult[];
+    } | null, unknown>;
+    search: import("react-query").UseInfiniteQueryResult<Contracts.Relations.FindAvailable.Response | null, unknown>;
+    searchFor: (term: string, options?: object) => void;
+};
+export { useRelation };
+export type { UseRelationArgs };

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

@@ -0,0 +1,2 @@
+import { RelationData } from '../../EditViewDataManagerProvider/reducer';
+export declare const diffRelations: (browserStateRelations?: RelationData[], serverStateRelations?: RelationData[]) => [connected: import("@strapi/types/dist/types/core/entity").ID[], disconnected: import("@strapi/types/dist/types/core/entity").ID[]];

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

@@ -0,0 +1,2 @@
+import { Entity } from '@strapi/types';
+export declare function getRelationLink(targetModel: string, id?: Entity.ID): string;

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

@@ -0,0 +1,13 @@
+import type { Contracts } from '@strapi/plugin-content-manager/_internal/shared';
+export interface NormalizeRelationArgs {
+    shouldAddLink: boolean;
+    mainFieldName: string;
+    targetModel: string;
+}
+export type NormalizedRelation = Contracts.Relations.RelationResult & {
+    href?: string;
+    mainField: string;
+    publicationState?: false | 'published' | 'draft';
+};
+export declare const normalizeRelation: (relation: Contracts.Relations.RelationResult, { shouldAddLink, mainFieldName, targetModel }: NormalizeRelationArgs) => NormalizedRelation;
+export declare const normalizeRelations: (relations: Contracts.Relations.RelationResult[], args: NormalizeRelationArgs) => NormalizedRelation[];