@strapi/admin 4.16.2 → 4.17.1

package/dist/admin/src/content-manager/contexts/models.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+declare const ModelsContext: React.Context<{
+    refetchData: () => Promise<void>;
+}>;
+export { ModelsContext };

package/dist/admin/src/content-manager/hooks/useContentManagerInitData.d.ts

@@ -0,0 +1,29 @@
+import { Permission } from '@strapi/helper-plugin';
+import { Contracts } from '@strapi/plugin-content-manager/_internal/shared';
+interface ContentManagerLink {
+    permissions: Permission[];
+    search: string | null;
+    kind: string;
+    title: string;
+    to: string;
+    uid: string;
+    name: string;
+    isDisplayed: boolean;
+}
+/**
+ * TODO: refactor this whole thing.
+ */
+declare const useContentManagerInitData: () => {
+    refetchData: () => Promise<void>;
+    collectionTypeLinks: ContentManagerLink[];
+    components: Contracts.Components.Component[];
+    fieldSizes: Record<string, {
+        default: number;
+        isResizeable: boolean;
+    }>;
+    models: Contracts.ContentTypes.ContentType[];
+    singleTypeLinks: ContentManagerLink[];
+    status: "error" | "loading" | "resolved";
+};
+export { useContentManagerInitData };
+export type { ContentManagerLink };

package/dist/admin/src/content-manager/hooks/useContentTypeLayout.d.ts

@@ -0,0 +1,6 @@
+declare const useContentTypeLayout: () => {
+    getComponentLayout: (componentUid: string) => import("../utils/layouts").FormattedComponentLayout;
+    components: Record<string, import("../utils/layouts").FormattedComponentLayout>;
+    contentType: import("../utils/layouts").FormattedContentTypeLayout | null;
+};
+export { useContentTypeLayout };

package/dist/admin/src/content-manager/hooks/useDragAndDrop.d.ts

@@ -0,0 +1,48 @@
+import * as React from 'react';
+import { type HandlerManager, type ConnectDragSource, type ConnectDropTarget, type ConnectDragPreview } from 'react-dnd';
+import { type UseKeyboardDragAndDropCallbacks } from './useKeyboardDragAndDrop';
+import type { Entity } from '@strapi/types';
+declare const DIRECTIONS: {
+    readonly UPWARD: "upward";
+    readonly DOWNWARD: "downward";
+};
+declare const DROP_SENSITIVITY: {
+    readonly REGULAR: "regular";
+    readonly IMMEDIATE: "immediate";
+};
+interface UseDragAndDropOptions<TIndex extends number | Array<number> = number, TItem extends {
+    index: TIndex;
+} = {
+    index: TIndex;
+}> extends UseKeyboardDragAndDropCallbacks<TIndex> {
+    type?: string;
+    index: TIndex;
+    item?: TItem;
+    onStart?: () => void;
+    onEnd?: () => void;
+    dropSensitivity?: (typeof DROP_SENSITIVITY)[keyof typeof DROP_SENSITIVITY];
+}
+type Identifier = ReturnType<HandlerManager['getHandlerId']>;
+type UseDragAndDropReturn = [
+    props: {
+        handlerId: Identifier;
+        isDragging: boolean;
+        handleKeyDown: (event: React.KeyboardEvent<HTMLButtonElement>) => void;
+        isOverDropTarget: boolean;
+        direction: (typeof DIRECTIONS)[keyof typeof DIRECTIONS] | null;
+    },
+    objectRef: React.RefObject<HTMLElement>,
+    dropRef: ConnectDropTarget,
+    dragRef: ConnectDragSource,
+    dragPreviewRef: ConnectDragPreview
+];
+/**
+ * A utility hook abstracting the general drag and drop hooks from react-dnd.
+ * Centralising the same behaviours and by default offering keyboard support.
+ */
+declare const useDragAndDrop: <TIndex extends number | number[], TItem extends {
+    [key: string]: unknown;
+    index: TIndex;
+    id?: Entity.ID | undefined;
+}>(active: boolean, { type, index, item, onStart, onEnd, onGrabItem, onDropItem, onCancel, onMoveItem, dropSensitivity, }: UseDragAndDropOptions<TIndex, TItem>) => UseDragAndDropReturn;
+export { useDragAndDrop, UseDragAndDropReturn, UseDragAndDropOptions, DIRECTIONS, DROP_SENSITIVITY, };

package/dist/admin/src/content-manager/hooks/useFindRedirectionLink.d.ts

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

package/dist/admin/src/content-manager/hooks/useKeyboardDragAndDrop.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+export type UseKeyboardDragAndDropCallbacks<TIndex extends number | Array<number> = number> = {
+    onCancel?: (index: TIndex) => void;
+    onDropItem?: (currentIndex: TIndex, newIndex?: TIndex) => void;
+    onGrabItem?: (index: TIndex) => void;
+    onMoveItem?: (newIndex: TIndex, currentIndex: TIndex) => void;
+};
+/**
+ * Utility hook designed to implement keyboard accessibile drag and drop by
+ * returning an onKeyDown handler to be passed to the drag icon button.
+ *
+ * @internal - You should use `useDragAndDrop` instead.
+ */
+export declare const useKeyboardDragAndDrop: <TIndex extends number | number[] = number>(active: boolean, index: TIndex, { onCancel, onDropItem, onGrabItem, onMoveItem }: UseKeyboardDragAndDropCallbacks<TIndex>) => React.KeyboardEventHandler<HTMLButtonElement>;

package/dist/admin/src/content-manager/hooks/useLayouts.d.ts

@@ -0,0 +1,10 @@
+import { Contracts } from '@strapi/plugin-content-manager/_internal/shared';
+declare const useContentTypeLayout: (contentTypeUID: string) => {
+    isLoading: boolean;
+    layout: import("../utils/layouts").FormattedLayouts | null;
+    updateLayout: <TPageData>(options?: (import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("react-query").QueryObserverResult<{
+        contentType: Contracts.ContentTypes.Configuration;
+        components: Record<string, Contracts.Components.ComponentConfiguration>;
+    }, unknown>>;
+};
+export { useContentTypeLayout };

package/dist/admin/src/content-manager/hooks/useLazyComponents.d.ts

@@ -0,0 +1,13 @@
+import { ComponentType } from 'react';
+type LazyComponentStore = Record<string, ComponentType | undefined>;
+interface UseLazyComponentsReturn {
+    isLazyLoading: boolean;
+    lazyComponentStore: LazyComponentStore;
+    cleanup: () => void;
+}
+/**
+ * @description A hook to lazy load custom field components
+ */
+declare const useLazyComponents: (componentUids?: string[]) => UseLazyComponentsReturn;
+export { useLazyComponents };
+export type { UseLazyComponentsReturn, LazyComponentStore };

package/dist/admin/src/content-manager/hooks/usePrev.d.ts

@@ -0,0 +1 @@
+export declare const usePrev: <T>(value: T) => T | undefined;

package/dist/admin/src/content-manager/hooks/useSyncRbac.d.ts

@@ -0,0 +1,28 @@
+import { Permission } from '@strapi/helper-plugin';
+import type { RBACState } from '../../components/RBACProvider';
+declare const useSyncRbac: (query: {
+    plugins?: object;
+}, collectionTypeUID: string, containerName?: string) => {
+    isValid: boolean;
+    permissions: Permission[] | null;
+};
+interface SyncRbacState {
+    permissions: RBACState['collectionTypesRelatedPermissions'][string][string] | null;
+}
+declare const SET_PERMISSIONS = "ContentManager/RBACManager/SET_PERMISSIONS";
+declare const RESET_PERMISSIONS = "ContentManager/RBACManager/RESET_PERMISSIONS";
+interface SetPermissionsAction {
+    type: typeof SET_PERMISSIONS;
+    permissions: RBACState['collectionTypesRelatedPermissions'][string];
+    __meta__?: {
+        plugins: object;
+        containerName: string;
+    };
+}
+interface ResetPermissionsAction {
+    type: typeof RESET_PERMISSIONS;
+}
+type Action = SetPermissionsAction | ResetPermissionsAction;
+declare const reducer: (state: SyncRbacState | undefined, action: Action) => SyncRbacState;
+export { useSyncRbac, reducer };
+export type { SyncRbacState, RBACState };

package/dist/admin/src/content-manager/pages/App.d.ts

@@ -0,0 +1,47 @@
+import type { ContentManagerLink } from '../hooks/useContentManagerInitData';
+import type { Contracts } from '@strapi/plugin-content-manager/_internal/shared';
+declare const App: () => import("react/jsx-runtime").JSX.Element;
+declare const GET_INIT_DATA = "ContentManager/App/GET_INIT_DATA";
+declare const RESET_INIT_DATA = "ContentManager/App/RESET_INIT_DATA";
+declare const SET_INIT_DATA = "ContentManager/App/SET_INIT_DATA";
+interface GetInitDataAction {
+    type: typeof GET_INIT_DATA;
+}
+interface ResetInitDataAction {
+    type: typeof RESET_INIT_DATA;
+}
+interface SetInitDataAction {
+    type: typeof SET_INIT_DATA;
+    data: {
+        authorizedCollectionTypeLinks: ContentManagerAppState['collectionTypeLinks'];
+        authorizedSingleTypeLinks: ContentManagerAppState['singleTypeLinks'];
+        components: ContentManagerAppState['components'];
+        contentTypeSchemas: ContentManagerAppState['models'];
+        fieldSizes: ContentManagerAppState['fieldSizes'];
+    };
+}
+type Action = GetInitDataAction | ResetInitDataAction | SetInitDataAction;
+interface ContentManagerAppState {
+    collectionTypeLinks: ContentManagerLink[];
+    components: Contracts.Init.GetInitData.Response['data']['components'];
+    fieldSizes: Contracts.Init.GetInitData.Response['data']['fieldSizes'];
+    models: Contracts.Init.GetInitData.Response['data']['contentTypes'];
+    singleTypeLinks: ContentManagerLink[];
+    status: 'loading' | 'resolved' | 'error';
+}
+declare const selectSchemas: ((state: {
+    readonly admin_app: import("../../reducer").AppState;
+    readonly rbacProvider: import("../../components/RBACProvider").RBACState;
+    readonly 'content-manager_app': ContentManagerAppState;
+    readonly 'content-manager_listView': import("./ListViewLayoutManager").ListViewLayoutManagerState;
+    readonly 'content-manager_rbacManager': import("../hooks/useSyncRbac").SyncRbacState;
+    readonly 'content-manager_editViewLayoutManager': import("./EditViewLayoutManager").EditViewLayoutManagerState;
+    readonly 'content-manager_editViewCrudReducer': import("../sharedReducers/crud/reducer").CrudState;
+}) => (Contracts.Components.Component | Contracts.ContentTypes.ContentType)[]) & import("reselect").OutputSelectorFields<(args_0: ContentManagerAppState) => (Contracts.Components.Component | Contracts.ContentTypes.ContentType)[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+declare const reducer: (state: ContentManagerAppState | undefined, action: Action) => ContentManagerAppState;
+export { App, reducer, selectSchemas };
+export type { ContentManagerAppState };

package/dist/admin/src/content-manager/pages/CollectionTypePages.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This component renders all the routes for either multiple or single content types
+ * including the settings views available.
+ */
+import { RouteComponentProps } from 'react-router-dom';
+interface CollectionTypePagesProps extends RouteComponentProps<{
+    collectionType: string;
+    slug: string;
+}> {
+}
+declare const CollectionTypePages: (props: CollectionTypePagesProps) => import("react/jsx-runtime").JSX.Element;
+export { CollectionTypePages };

package/dist/admin/src/content-manager/pages/ComponentSettingsView.d.ts

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

package/dist/admin/src/content-manager/pages/EditView/EditViewPage.d.ts

@@ -0,0 +1,18 @@
+import { Permission, AllowedActions } from '@strapi/helper-plugin';
+import { RouteComponentProps } from 'react-router-dom';
+interface EditViewPageParams {
+    collectionType: string;
+    slug: string;
+    id?: string;
+    origin?: string;
+}
+interface EditViewPageProps extends RouteComponentProps<EditViewPageParams> {
+    allowedActions: AllowedActions;
+    userPermissions?: Permission[];
+}
+declare const EditViewPage: ({ allowedActions, history: { goBack }, match: { params: { slug, collectionType, id, origin }, }, userPermissions, }: EditViewPageProps) => import("react/jsx-runtime").JSX.Element | null;
+interface ProtectedEditViewPageProps extends Omit<EditViewPageProps, 'allowedActions'> {
+}
+declare const ProtectedEditViewPage: ({ userPermissions, ...restProps }: ProtectedEditViewPageProps) => import("react/jsx-runtime").JSX.Element;
+export { EditViewPage, ProtectedEditViewPage };
+export type { EditViewPageProps, EditViewPageParams, ProtectedEditViewPageProps };

package/dist/admin/src/content-manager/pages/EditView/components/DeleteLink.d.ts

@@ -0,0 +1,6 @@
+import type { RenderChildProps } from '../../../components/ContentTypeFormWrapper';
+interface DeleteLinkProps {
+    onDelete: RenderChildProps['onDelete'];
+}
+declare const DeleteLink: ({ onDelete }: DeleteLinkProps) => import("react/jsx-runtime").JSX.Element;
+export { DeleteLink };

package/dist/admin/src/content-manager/pages/EditView/components/DraftAndPublishBadge.d.ts

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

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

@@ -0,0 +1,7 @@
+import { AllowedActions } from '@strapi/helper-plugin';
+interface HeaderProps {
+    allowedActions: AllowedActions;
+}
+declare const Header: ({ allowedActions: { canUpdate, canCreate, canPublish } }: HeaderProps) => import("react/jsx-runtime").JSX.Element;
+export { Header };
+export type { HeaderProps };

package/dist/admin/src/content-manager/pages/EditView/components/Information.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+interface RootProps {
+    children: React.ReactNode;
+}
+export declare const Information: {
+    Root: ({ children }: RootProps) => import("react/jsx-runtime").JSX.Element;
+    Title: () => import("react/jsx-runtime").JSX.Element;
+    Body: () => import("react/jsx-runtime").JSX.Element;
+};
+export {};

package/dist/admin/src/content-manager/pages/EditView/components/InformationBoxCE.d.ts

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

package/dist/admin/src/content-manager/pages/EditViewLayoutManager.d.ts

@@ -0,0 +1,26 @@
+import { ProtectedEditViewPageProps } from './EditView/EditViewPage';
+import type { FormattedLayouts } from '../utils/layouts';
+interface EditViewLayoutManagerProps extends ProtectedEditViewPageProps {
+    layout: FormattedLayouts;
+}
+declare const EditViewLayoutManager: ({ layout, ...rest }: EditViewLayoutManagerProps) => import("react/jsx-runtime").JSX.Element;
+declare const RESET_PROPS = "ContentManager/EditViewLayoutManager/RESET_PROPS";
+interface ResetPropsAction {
+    type: typeof RESET_PROPS;
+}
+declare const SET_LAYOUT = "ContentManager/EditViewLayoutManager/SET_LAYOUT";
+interface SetLayoutAction {
+    type: typeof SET_LAYOUT;
+    layout: EditViewLayoutManagerProps['layout'];
+    query: object;
+}
+interface EditViewLayoutManagerState {
+    currentLayout: {
+        components: EditViewLayoutManagerProps['layout']['components'];
+        contentType: EditViewLayoutManagerProps['layout']['contentType'] | null;
+    };
+}
+type Action = ResetPropsAction | SetLayoutAction;
+declare const reducer: (state: EditViewLayoutManagerState | undefined, action: Action) => EditViewLayoutManagerState;
+export { EditViewLayoutManager, reducer };
+export type { EditViewLayoutManagerProps, EditViewLayoutManagerState };

package/dist/admin/src/content-manager/pages/ListView/ListViewPage.d.ts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import { Permission } from '@strapi/helper-plugin';
+import { Contracts } from '@strapi/plugin-content-manager/_internal/shared';
+import { FormattedLayouts, ListLayoutRow } from '../../utils/layouts';
+interface TableHeader extends Omit<ListLayoutRow, 'metadatas'> {
+    metadatas: ListLayoutRow['metadatas'] & {
+        label: string;
+    };
+    cellFormatter?: (data: Contracts.CollectionTypes.Find.Response['results'][number], header: Omit<TableHeader, 'cellFormatter'>) => React.ReactNode;
+}
+interface ListViewPageProps {
+    canCreate?: boolean;
+    canDelete?: boolean;
+    canRead?: boolean;
+    canPublish?: boolean;
+    layout: FormattedLayouts;
+    slug: string;
+}
+declare const ListViewPage: ({ canCreate, canDelete, canRead, canPublish, layout, slug, }: ListViewPageProps) => import("react/jsx-runtime").JSX.Element | null;
+interface ProtectedListViewPageProps extends ListViewPageProps {
+    permissions?: Permission[] | null;
+}
+declare const ProtectedListViewPage: ({ permissions, ...restProps }: ProtectedListViewPageProps) => import("react/jsx-runtime").JSX.Element;
+export { ListViewPage, ProtectedListViewPage };
+export type { ListViewPageProps, ProtectedListViewPageProps, TableHeader };

package/dist/admin/src/content-manager/pages/ListView/components/AdminUsersFilter.d.ts

@@ -0,0 +1,6 @@
+import { ComboboxProps } from '@strapi/design-system';
+interface AdminUsersFilterProps extends Pick<ComboboxProps, 'value' | 'onChange'> {
+}
+declare const AdminUsersFilter: ({ value, onChange }: AdminUsersFilterProps) => import("react/jsx-runtime").JSX.Element;
+export { AdminUsersFilter };
+export type { AdminUsersFilterProps };

package/dist/admin/src/content-manager/pages/ListView/components/BulkActions/Buttons.d.ts

@@ -0,0 +1,27 @@
+import { Entity } from '@strapi/types';
+import PropTypes from 'prop-types';
+interface BulkActionButtonsProps {
+    showPublish?: boolean;
+    showDelete?: boolean;
+    onConfirmDeleteAll: (ids: Entity.ID[]) => Promise<void>;
+    onConfirmUnpublishAll: (ids: Entity.ID[]) => Promise<void>;
+    refetchData: () => void;
+}
+declare const BulkActionButtons: {
+    ({ showPublish, showDelete, onConfirmDeleteAll, onConfirmUnpublishAll, refetchData, }: BulkActionButtonsProps): import("react/jsx-runtime").JSX.Element;
+    defaultProps: {
+        showPublish: boolean;
+        showDelete: boolean;
+        onConfirmDeleteAll(): void;
+        onConfirmUnpublishAll(): void;
+        refetchData(): void;
+    };
+    propTypes: {
+        showPublish: PropTypes.Requireable<boolean>;
+        showDelete: PropTypes.Requireable<boolean>;
+        onConfirmDeleteAll: PropTypes.Requireable<(...args: any[]) => any>;
+        onConfirmUnpublishAll: PropTypes.Requireable<(...args: any[]) => any>;
+        refetchData: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+};
+export { BulkActionButtons };

package/dist/admin/src/content-manager/pages/ListView/components/BulkActions/ConfirmBulkActionDialog.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { DialogFooterProps } from '@strapi/design-system';
+interface ConfirmBulkActionDialogProps extends Pick<DialogFooterProps, 'endAction'> {
+    onToggleDialog: () => void;
+    isOpen?: boolean;
+    dialogBody: React.ReactNode;
+}
+declare const ConfirmBulkActionDialog: ({ onToggleDialog, isOpen, dialogBody, endAction, }: ConfirmBulkActionDialogProps) => import("react/jsx-runtime").JSX.Element;
+interface ConfirmDialogPublishAllProps extends Pick<ConfirmBulkActionDialogProps, 'isOpen' | 'onToggleDialog'> {
+    isConfirmButtonLoading?: boolean;
+    onConfirm: () => void;
+}
+declare const ConfirmDialogPublishAll: ({ isOpen, onToggleDialog, isConfirmButtonLoading, onConfirm, }: ConfirmDialogPublishAllProps) => import("react/jsx-runtime").JSX.Element | null;
+export { ConfirmDialogPublishAll, ConfirmBulkActionDialog };
+export type { ConfirmDialogPublishAllProps, ConfirmBulkActionDialogProps };

package/dist/admin/src/content-manager/pages/ListView/components/BulkActions/SelectedEntriesModal.d.ts

@@ -0,0 +1,30 @@
+import * as React from 'react';
+import { Entity } from '@strapi/types';
+import { MessageDescriptor } from 'react-intl';
+import { UseQueryResult } from 'react-query';
+import { ConfirmDialogPublishAllProps } from './ConfirmBulkActionDialog';
+interface EntryValidationTextProps {
+    validationErrors?: Record<string, MessageDescriptor>;
+    isPublished?: boolean;
+}
+interface SelectedEntriesTableContentProps {
+    isPublishing?: boolean;
+    rowsToDisplay?: TableRow[];
+    entriesToPublish?: Entity.ID[];
+    validationErrors: Record<string, EntryValidationTextProps['validationErrors']>;
+}
+interface SelectedEntriesModalContentProps extends Pick<SelectedEntriesTableContentProps, 'validationErrors'> {
+    refetchModalData: UseQueryResult['refetch'];
+    setEntriesToFetch: React.Dispatch<React.SetStateAction<Entity.ID[]>>;
+    setSelectedListViewEntries: React.Dispatch<React.SetStateAction<Entity.ID[]>>;
+    toggleModal: ConfirmDialogPublishAllProps['onToggleDialog'];
+}
+interface TableRow {
+    id: Entity.ID;
+    publishedAt: string | null;
+}
+interface SelectedEntriesModalProps {
+    onToggle: SelectedEntriesModalContentProps['toggleModal'];
+}
+declare const SelectedEntriesModal: ({ onToggle }: SelectedEntriesModalProps) => import("react/jsx-runtime").JSX.Element;
+export { SelectedEntriesModal };

package/dist/admin/src/content-manager/pages/ListView/components/DialogConfirmDelete.d.ts

@@ -0,0 +1,9 @@
+interface DialogConfirmDeleteProps {
+    isConfirmButtonLoading?: boolean;
+    isOpen?: boolean;
+    onConfirm: () => void;
+    onToggleDialog: () => void;
+}
+declare const DialogConfirmDelete: ({ isConfirmButtonLoading, isOpen, onToggleDialog, onConfirm, }: DialogConfirmDeleteProps) => import("react/jsx-runtime").JSX.Element;
+export { DialogConfirmDelete };
+export type { DialogConfirmDeleteProps };

package/dist/admin/src/content-manager/pages/ListView/components/Filter.d.ts

@@ -0,0 +1,7 @@
+import { FilterData } from '@strapi/helper-plugin';
+interface FilterProps {
+    displayedFilters: FilterData[];
+}
+declare const Filter: ({ displayedFilters }: FilterProps) => import("react/jsx-runtime").JSX.Element;
+export { Filter };
+export type { FilterProps };

package/dist/admin/src/content-manager/pages/ListView/components/InjectionZoneList.d.ts

@@ -0,0 +1,7 @@
+import { InjectionZoneArea } from '../../../../components/InjectionZone';
+interface InjectionZoneListProps {
+    area: InjectionZoneArea;
+}
+declare const InjectionZoneList: ({ area, ...props }: InjectionZoneListProps) => import("react/jsx-runtime").JSX.Element | null;
+export { InjectionZoneList };
+export type { InjectionZoneListProps };

package/dist/admin/src/content-manager/pages/ListView/components/Table.d.ts

@@ -0,0 +1,28 @@
+import * as React from 'react';
+import { Entity } from '@strapi/types';
+interface CheckboxDataCellProps {
+    rowId: Entity.ID;
+    index: number;
+}
+interface EntityActionsDataCellProps {
+    rowId: Entity.ID;
+    index: number;
+    canCreate?: boolean;
+    canDelete?: boolean;
+    setIsConfirmDeleteRowOpen: (isOpen: boolean) => void;
+    handleCloneClick: (id: Entity.ID) => () => void;
+}
+interface RootProps {
+    children: React.ReactNode;
+    onConfirmDelete: (id: Entity.ID) => Promise<void>;
+    isConfirmDeleteRowOpen: boolean;
+    setIsConfirmDeleteRowOpen: (isOpen: boolean) => void;
+}
+declare const Table: {
+    CheckboxDataCell: ({ rowId, index }: CheckboxDataCellProps) => import("react/jsx-runtime").JSX.Element;
+    EntityActionsDataCell: ({ rowId, index, canCreate, canDelete, setIsConfirmDeleteRowOpen, handleCloneClick, }: EntityActionsDataCellProps) => import("react/jsx-runtime").JSX.Element;
+    Root: ({ children, onConfirmDelete, isConfirmDeleteRowOpen, setIsConfirmDeleteRowOpen, }: RootProps) => import("react/jsx-runtime").JSX.Element;
+};
+type TableProps = RootProps;
+export { Table };
+export type { TableProps };

package/dist/admin/src/content-manager/pages/ListView/components/TableCells/CellContent.d.ts

@@ -0,0 +1,11 @@
+import type { FormattedContentTypeLayout } from '../../../../utils/layouts';
+import type { TableHeader } from '../../ListViewPage';
+import type { Attribute, Entity } from '@strapi/types';
+interface CellContentProps extends Omit<TableHeader, 'key'> {
+    content: Attribute.GetValue<Attribute.Any>;
+    rowId: Entity.ID;
+    contentType: FormattedContentTypeLayout;
+}
+declare const CellContent: ({ content, fieldSchema, metadatas, name, rowId, contentType, }: CellContentProps) => import("react/jsx-runtime").JSX.Element;
+export { CellContent };
+export type { CellContentProps };

package/dist/admin/src/content-manager/pages/ListView/components/TableCells/CellValue.d.ts

@@ -0,0 +1,8 @@
+import type { Attribute } from '@strapi/types';
+interface CellValueProps {
+    type: Attribute.Kind | 'custom';
+    value: any;
+}
+declare const CellValue: ({ type, value }: CellValueProps) => string;
+export { CellValue };
+export type { CellValueProps };

package/dist/admin/src/content-manager/pages/ListView/components/TableCells/Components.d.ts

@@ -0,0 +1,12 @@
+import { CellContentProps } from './CellContent';
+import type { Attribute } from '@strapi/types';
+interface SingleComponentProps extends Pick<CellContentProps, 'metadatas'> {
+    content: Attribute.GetValue<Attribute.Component>;
+}
+declare const SingleComponent: ({ content, metadatas }: SingleComponentProps) => import("react/jsx-runtime").JSX.Element | null;
+interface RepeatableComponentProps extends Pick<CellContentProps, 'metadatas'> {
+    content: Attribute.GetValue<Attribute.Component<`${string}.${string}`, true>>;
+}
+declare const RepeatableComponent: ({ content, metadatas }: RepeatableComponentProps) => import("react/jsx-runtime").JSX.Element | null;
+export { SingleComponent, RepeatableComponent };
+export type { SingleComponentProps, RepeatableComponentProps };

package/dist/admin/src/content-manager/pages/ListView/components/TableCells/Media.d.ts

@@ -0,0 +1,23 @@
+import type { Entity } from '@strapi/types';
+interface MediaFile {
+    id?: Entity.ID;
+    alternativeText?: string;
+    ext: string;
+    formats: {
+        thumbnail?: {
+            url?: string;
+        };
+    };
+    mime: string;
+    name: string;
+    url: string;
+}
+interface MediaSingleProps extends MediaFile {
+}
+declare const MediaSingle: ({ url, mime, alternativeText, name, ext, formats }: MediaSingleProps) => import("react/jsx-runtime").JSX.Element;
+interface MediaMultipleProps {
+    content: MediaFile[];
+}
+declare const MediaMultiple: ({ content }: MediaMultipleProps) => import("react/jsx-runtime").JSX.Element;
+export { MediaMultiple, MediaSingle };
+export type { MediaMultipleProps, MediaSingleProps };

package/dist/admin/src/content-manager/pages/ListView/components/TableCells/Relations.d.ts

@@ -0,0 +1,12 @@
+import type { CellContentProps } from './CellContent';
+import type { Entity } from '@strapi/types';
+interface RelationSingleProps extends Pick<CellContentProps, 'metadatas' | 'content'> {
+}
+declare const RelationSingle: ({ metadatas, content }: RelationSingleProps) => import("react/jsx-runtime").JSX.Element;
+interface RelationMultipleProps extends Pick<CellContentProps, 'metadatas' | 'name' | 'content'> {
+    entityId: Entity.ID;
+    uid: string;
+}
+declare const RelationMultiple: ({ metadatas, name, entityId, content, uid }: RelationMultipleProps) => import("react/jsx-runtime").JSX.Element;
+export { RelationSingle, RelationMultiple };
+export type { RelationSingleProps, RelationMultipleProps };

package/dist/admin/src/content-manager/pages/ListView/components/ViewSettingsMenu.d.ts

@@ -0,0 +1,6 @@
+interface ViewSettingsMenuProps {
+    slug: string;
+}
+declare const ViewSettingsMenu: ({ slug }: ViewSettingsMenuProps) => import("react/jsx-runtime").JSX.Element;
+export { ViewSettingsMenu };
+export type { ViewSettingsMenuProps };

package/dist/admin/src/content-manager/pages/ListView/hooks/useAllowedAttributes.d.ts

@@ -0,0 +1,3 @@
+import { FormattedContentTypeLayout } from '../../../utils/layouts';
+declare const useAllowedAttributes: (contentType: FormattedContentTypeLayout, slug: string) => string[];
+export { useAllowedAttributes };