@strapi/admin 4.20.5 → 5.0.0-alpha.0

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

@@ -0,0 +1,135 @@
+/**
+ * TODO: honestly, half of this stuff should come straight from
+ * the design-system and then we can just wrap round the bits for
+ * the i18n & router interactions.
+ *
+ * So we'll do that in v2 of the DS.
+ */
+import * as React from 'react';
+import { RawTrProps, EmptyStateLayoutProps, TableProps, RawTdProps } from '@strapi/design-system';
+interface BaseRow {
+    id: string | number;
+    [key: string]: any;
+}
+interface TableHeader<TData = object, THeader = object> {
+    /**
+     * Typically used by plugins to render a custom cell
+     */
+    cellFormatter?: (data: TData, header: Omit<THeader, 'cellFormatter'>) => React.ReactNode;
+    label: string;
+    name: string;
+    searchable?: boolean;
+    sortable?: boolean;
+}
+interface TableContextValue<TRow extends BaseRow, THeader extends TableHeader<TRow, THeader>> extends Pick<TableProps, 'footer'> {
+    colCount: number;
+    hasHeaderCheckbox: boolean;
+    headers: THeader[];
+    isLoading: boolean;
+    rowCount: number;
+    rows: TRow[];
+    setHasHeaderCheckbox: (value: boolean) => void;
+    selectedRows: TRow[];
+    selectRow: (row: TRow | TRow[]) => void;
+}
+declare const useTable: <Selected>(consumerName: string, selector: (value: TableContextValue<any, any>) => Selected) => Selected;
+interface RootProps<TRow extends BaseRow, THeader extends TableHeader<TRow, THeader>> extends Partial<Pick<TableContextValue<TRow, THeader>, 'footer' | 'headers' | 'isLoading' | 'rows' | 'selectedRows'>> {
+    children?: React.ReactNode;
+    defaultSelectedRows?: TRow[];
+    onSelectedRowsChange?: (selectedRows: TRow[]) => void;
+}
+/**
+ * @alpha we may move this component to the design-system.
+ * @public
+ * @description A generic table component composition. Internally handles the state of the table
+ * such as selected rows, loading state, and more assuming the correct pieces are put togther.
+ * @example
+ * ```tsx
+ * interace Data {
+ *  id: string;
+ *  name: string;
+ *  email: string;
+ * }
+ *
+ * const ListView = () => {
+ *  const { data, isLoading } = useGetData<Data>();
+ *
+ *  const headers: Table.Header<Data>[] = [
+ *    {
+ *      label: 'Name',
+ *      name: 'name',
+ *      sortable: true,
+ *    },
+ *    {
+ *      label: 'Email',
+ *      name: 'email',
+ *      sortable: true,
+ *    },
+ *  ];
+ *
+ *  return (
+ *    <Table.Root rows={data} headers={headers} isLoading={isLoading}>
+ *      <Table.Content>
+ *        <Table.Head>
+ *          {headers.map((head) => (
+ *            <Table.HeaderCell key={head.name} {...head} />
+ *          ))}
+ *        </Table.Head>
+ *        <Table.Body>
+ *          <Table.Loading />
+ *          <Table.Empty />
+ *          {data.map((row) => (
+ *            <Table.Row key={row.id}>
+ *              <Table.Cell>{row.name}</Table.Cell>
+ *              <Table.Cell>{row.email}</Table.Cell>
+ *            </Table.Row>
+ *          ))}
+ *        </Table.Body>
+ *      </Table.Content>
+ *    </Table.Root>
+ *  );
+ * };
+ * ```
+ */
+declare const Table: {
+    Root: <TRow extends BaseRow, THeader extends TableHeader<TRow, THeader>>({ children, defaultSelectedRows, footer, headers, isLoading, onSelectedRowsChange, rows, selectedRows: selectedRowsProps, }: RootProps<TRow, THeader>) => import("react/jsx-runtime").JSX.Element;
+    Content: ({ children }: Table.ContentProps) => import("react/jsx-runtime").JSX.Element;
+    ActionBar: ({ children }: Table.ActionBarProps) => import("react/jsx-runtime").JSX.Element | null;
+    Head: ({ children }: Table.HeadProps) => import("react/jsx-runtime").JSX.Element;
+    HeaderCell: <TData, THead>({ name, label, sortable }: TableHeader<TData, THead>) => import("react/jsx-runtime").JSX.Element;
+    HeaderCheckboxCell: () => import("react/jsx-runtime").JSX.Element;
+    Body: ({ children }: Table.BodyProps) => import("react/jsx-runtime").JSX.Element | null;
+    CheckboxCell: ({ id, ...props }: Table.CheckboxCellProps) => import("react/jsx-runtime").JSX.Element;
+    Cell: ({ children, ...props }: RawTdProps) => import("react/jsx-runtime").JSX.Element;
+    Row: (props: Table.RowProps) => import("react/jsx-runtime").JSX.Element;
+    Loading: ({ children }: Table.LoadingProps) => import("react/jsx-runtime").JSX.Element | null;
+    Empty: (props: Table.EmptyProps) => import("react/jsx-runtime").JSX.Element | null;
+};
+declare namespace Table {
+    type Props<TData extends BaseRow, THeader extends TableHeader<TData, THeader> = TableHeader<TData, TableHeader>> = RootProps<TData, THeader>;
+    interface ActionBarProps {
+        children?: React.ReactNode;
+    }
+    interface ContentProps {
+        children: React.ReactNode;
+    }
+    type Header<TData, THeader> = TableHeader<TData, THeader>;
+    interface HeadProps {
+        children: React.ReactNode;
+    }
+    interface EmptyProps extends Partial<EmptyStateLayoutProps> {
+    }
+    interface LoadingProps {
+        children?: React.ReactNode;
+    }
+    interface BodyProps {
+        children: React.ReactNode;
+    }
+    interface RowProps extends RawTrProps {
+    }
+    interface CellProps extends RawTdProps {
+    }
+    interface CheckboxCellProps extends Pick<BaseRow, 'id'>, Omit<RawTdProps, 'id'> {
+    }
+}
+export { Table, useTable };

package/dist/admin/src/constants/filters.d.ts

@@ -0,0 +1,137 @@
+import type { EntityService } from '@strapi/types';
+import type { MessageDescriptor } from 'react-intl';
+/**
+ * @description designed to be parsed by formatMessage from react-intl
+ * then passed to a Select component.
+ */
+interface FilterOption {
+    value: EntityService.Params.Filters.Operator.Where;
+    label: MessageDescriptor;
+}
+/**
+ * @description these are shared by everyone
+ */
+declare const BASE_FILTERS: ({
+    label: {
+        id: string;
+        defaultMessage: string;
+    };
+    value: "$eq";
+} | {
+    label: {
+        id: string;
+        defaultMessage: string;
+    };
+    value: "$ne";
+} | {
+    label: {
+        id: string;
+        defaultMessage: string;
+    };
+    value: "$null";
+} | {
+    label: {
+        id: string;
+        defaultMessage: string;
+    };
+    value: "$notNull";
+})[];
+/**
+ * @description typically performed on attributes that are numerical incl. dates.
+ */
+declare const NUMERIC_FILTERS: ({
+    label: {
+        id: string;
+        defaultMessage: string;
+    };
+    value: "$gt";
+} | {
+    label: {
+        id: string;
+        defaultMessage: string;
+    };
+    value: "$gte";
+} | {
+    label: {
+        id: string;
+        defaultMessage: string;
+    };
+    value: "$lt";
+} | {
+    label: {
+        id: string;
+        defaultMessage: string;
+    };
+    value: "$lte";
+})[];
+declare const IS_SENSITIVE_FILTERS: ({
+    label: {
+        id: string;
+        defaultMessage: string;
+    };
+    value: "$eqi";
+} | {
+    label: {
+        id: string;
+        defaultMessage: string;
+    };
+    value: "$nei";
+})[];
+/**
+ * @description typically performed on attributes that are strings for partial looking.
+ */
+declare const CONTAINS_FILTERS: ({
+    label: {
+        id: string;
+        defaultMessage: string;
+    };
+    value: "$contains";
+} | {
+    label: {
+        id: string;
+        defaultMessage: string;
+    };
+    value: "$containsi";
+} | {
+    label: {
+        id: string;
+        defaultMessage: string;
+    };
+    value: "$notContains";
+} | {
+    label: {
+        id: string;
+        defaultMessage: string;
+    };
+    value: "$notContainsi";
+})[];
+/**
+ * @description only used on string attributes.
+ */
+declare const STRING_PARSE_FILTERS: ({
+    label: {
+        id: string;
+        defaultMessage: string;
+    };
+    value: "$startsWith";
+} | {
+    label: {
+        id: string;
+        defaultMessage: string;
+    };
+    value: "$startsWithi";
+} | {
+    label: {
+        id: string;
+        defaultMessage: string;
+    };
+    value: "$endsWith";
+} | {
+    label: {
+        id: string;
+        defaultMessage: string;
+    };
+    value: "$endsWithi";
+})[];
+export { BASE_FILTERS, NUMERIC_FILTERS, IS_SENSITIVE_FILTERS, CONTAINS_FILTERS, STRING_PARSE_FILTERS, };
+export type { FilterOption };

package/dist/admin/src/constants.d.ts

@@ -1,4 +1,4 @@
-import { StrapiAppSettingLink } from '@strapi/helper-plugin';
+import type { StrapiAppSettingLink } from './StrapiApp';
 export declare const ADMIN_PERMISSIONS_CE: {
     contentManager: {
         main: never[];

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

@@ -0,0 +1,9 @@
+import type { Attribute } from '@strapi/types';
+interface EditFieldFormProps {
+    attribute?: Attribute.Any;
+    name: string;
+    onClose: () => void;
+}
+declare const EditFieldForm: ({ attribute, name, onClose }: EditFieldFormProps) => import("react/jsx-runtime").JSX.Element | null;
+export { EditFieldForm };
+export type { EditFieldFormProps };

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

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import { type UseDragAndDropOptions } from '../../hooks/useDragAndDrop';
+import { EditFieldFormProps } from './EditFieldForm';
+import type { EditLayout } from '../../hooks/useDocumentLayout';
+interface FieldsProps extends Pick<EditLayout, 'metadatas'>, Pick<FieldProps, 'components'> {
+    attributes: {
+        [key: string]: FieldProps['attribute'];
+    };
+    fieldSizes: Record<string, number>;
+    components: EditLayout['components'];
+}
+declare const Fields: ({ attributes, fieldSizes, components, metadatas }: FieldsProps) => import("react/jsx-runtime").JSX.Element;
+interface FieldProps extends Pick<EditFieldFormProps, 'name' | 'attribute'> {
+    components: EditLayout['components'];
+    index: [row: number, index: number];
+    onMoveField: UseDragAndDropOptions<number[]>['onMoveItem'];
+    onRemoveField: React.MouseEventHandler<HTMLButtonElement>;
+}
+declare const TEMP_FIELD_NAME = "_TEMP_";
+export { Fields, TEMP_FIELD_NAME };
+export type { FieldsProps };

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

@@ -0,0 +1,32 @@
+import { FormProps } from '../../../components/Form';
+import { FieldsProps } from './Fields';
+import type { EditFieldLayout, EditLayout } from '../../hooks/useDocumentLayout';
+interface ConfigurationFormProps extends Pick<FieldsProps, 'attributes' | 'fieldSizes'> {
+    layout: EditLayout;
+    onSubmit: FormProps<ConfigurationFormData>['onSubmit'];
+}
+/**
+ * Every key in EditFieldLayout is turned to optional never and then we overwrite the ones we are using.
+ */
+type EditFieldSpacerLayout = {
+    [key in keyof Omit<EditFieldLayout, 'name' | 'size'>]?: never;
+} & {
+    description?: never;
+    editable?: never;
+    name: '_TEMP_';
+    size: number;
+    __temp_key__: string;
+};
+interface ConfigurationFormData extends Pick<EditLayout, 'settings'> {
+    layout: Array<{
+        __temp_key__: string;
+        children: Array<(Pick<EditFieldLayout, 'label' | 'size' | 'name' | 'placeholder' | 'mainField'> & {
+            description: EditFieldLayout['hint'];
+            editable: EditFieldLayout['disabled'];
+            __temp_key__: string;
+        }) | EditFieldSpacerLayout>;
+    }>;
+}
+declare const ConfigurationForm: ({ attributes, fieldSizes, layout: editLayout, onSubmit, }: ConfigurationFormProps) => import("react/jsx-runtime").JSX.Element;
+export { ConfigurationForm };
+export type { ConfigurationFormProps, ConfigurationFormData, EditFieldSpacerLayout };

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

@@ -1,7 +1,7 @@
 interface CardDragPreviewProps {
-    labelField: string;
+    label: string;
     isSibling?: boolean;
 }
-declare const CardDragPreview: ({ labelField, isSibling }: CardDragPreviewProps) => import("react/jsx-runtime").JSX.Element;
+declare const CardDragPreview: ({ label, isSibling }: CardDragPreviewProps) => import("react/jsx-runtime").JSX.Element;
 export { CardDragPreview };
 export type { CardDragPreviewProps };

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

@@ -1,7 +1,9 @@
-import { PUBLICATION_STATES } from '../Relations/RelationInputDataManager';
+import { Entity } from '@strapi/types';
 interface RelationDragPreviewProps {
-    status: typeof PUBLICATION_STATES.DRAFT | typeof PUBLICATION_STATES.PUBLISHED;
+    status?: string;
     displayedValue: string;
+    id: Entity.ID;
+    index: number;
     width: number;
 }
 declare const RelationDragPreview: ({ status, displayedValue, width }: RelationDragPreviewProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,32 +1,9 @@
-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;
-};
+import * as React from 'react';
+import type { Attribute } from '@strapi/types';
+declare const iconByTypes: Record<Attribute.Kind, React.ReactElement>;
 interface FieldTypeIconProps {
-    type: keyof typeof iconByTypes;
+    type?: keyof typeof iconByTypes;
     customFieldUid?: string;
 }
-declare const FieldTypeIcon: ({ type, customFieldUid }: FieldTypeIconProps) => import("react/jsx-runtime").JSX.Element | null;
+declare const FieldTypeIcon: ({ type, customFieldUid }: FieldTypeIconProps) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
 export { FieldTypeIcon };

package/dist/admin/src/content-manager/constants/attributes.d.ts

@@ -1,2 +1,14 @@
+declare const CREATED_BY_ATTRIBUTE_NAME = "createdBy";
+declare const UPDATED_BY_ATTRIBUTE_NAME = "updatedBy";
 declare const CREATOR_FIELDS: string[];
-export { CREATOR_FIELDS };
+declare const PUBLISHED_BY_ATTRIBUTE_NAME = "publishedBy";
+declare const CREATED_AT_ATTRIBUTE_NAME = "createdAt";
+declare const UPDATED_AT_ATTRIBUTE_NAME = "updatedAt";
+declare const PUBLISHED_AT_ATTRIBUTE_NAME = "publishedAt";
+declare const DOCUMENT_META_FIELDS: string[];
+/**
+ * List of attribute types that cannot be used as the main field.
+ * Not sure the name could be any clearer.
+ */
+declare const ATTRIBUTE_TYPES_THAT_CANNOT_BE_MAIN_FIELD: string[];
+export { ATTRIBUTE_TYPES_THAT_CANNOT_BE_MAIN_FIELD, CREATED_AT_ATTRIBUTE_NAME, UPDATED_AT_ATTRIBUTE_NAME, PUBLISHED_AT_ATTRIBUTE_NAME, CREATED_BY_ATTRIBUTE_NAME, UPDATED_BY_ATTRIBUTE_NAME, PUBLISHED_BY_ATTRIBUTE_NAME, CREATOR_FIELDS, DOCUMENT_META_FIELDS, };

package/dist/admin/src/content-manager/constants/collections.d.ts

@@ -0,0 +1,3 @@
+declare const SINGLE_TYPES = "single-types";
+declare const COLLECTION_TYPES = "collection-types";
+export { SINGLE_TYPES, COLLECTION_TYPES };

package/dist/admin/src/content-manager/exports.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This file keeps track of the exports from the CM plugin admin side.
+ * When we move the CM plugin back to its package, we won't need this
+ * but should still export the same things.
+ */
+export { useDocument as unstable_useDocument } from './hooks/useDocument';
+export { useDocumentActions as unstable_useDocumentActions } from './hooks/useDocumentActions';
+export { useDocumentLayout as unstable_useDocumentLayout } from './hooks/useDocumentLayout';
+export type { EditFieldLayout, EditLayout, ListFieldLayout, ListLayout, } from './hooks/useDocumentLayout';
+export * from './features/DocumentRBAC';

package/dist/admin/src/content-manager/features/DocumentRBAC.d.ts

@@ -0,0 +1,36 @@
+import * as React from 'react';
+import { type Permission } from '@strapi/helper-plugin';
+import type { Attribute } from '@strapi/types';
+/**
+ * The boolean values indicate the global actions a user can perform on the document.
+ * The `string[]` values tell us specifically which fields the actions can be performed on,
+ * for example, if the `canReadFields` array is empty, than no fields can be read by the user.
+ * This can happen even if the user can read the document.
+ */
+interface DocumentRBACContextValue {
+    canCreate?: boolean;
+    canCreateFields: string[];
+    canDelete?: boolean;
+    canPublish?: boolean;
+    canRead?: boolean;
+    canReadFields: string[];
+    canUpdate?: boolean;
+    canUpdateFields: string[];
+    canUserAction: (fieldName: string, fieldsUserCanAction: string[], fieldType: Attribute.Kind) => boolean;
+    isLoading: boolean;
+}
+declare const useDocumentRBAC: <Selected>(consumerName: string, selector: (value: DocumentRBACContextValue) => Selected) => Selected;
+interface DocumentRBACProps {
+    children: React.ReactNode;
+    permissions: Permission[] | null;
+}
+/**
+ * @internal This component is not meant to be used outside of the Content Manager plugin.
+ * It depends on knowing the slug/model of the content-type using the params of the URL.
+ * If you do use the hook outside of the context, we default to `false` for all actions.
+ *
+ * It then creates an list of `can{Action}` that are passed to the context for consumption
+ * within the app to enforce RBAC.
+ */
+declare const DocumentRBAC: ({ children, permissions }: DocumentRBACProps) => import("react/jsx-runtime").JSX.Element;
+export { DocumentRBAC, useDocumentRBAC, DocumentRBACContextValue, DocumentRBACProps };

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

@@ -0,0 +1,3 @@
+import type { DocumentActionComponent } from '../../../core/apis/content-manager';
+declare const HistoryAction: DocumentActionComponent;
+export { HistoryAction };

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

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

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

@@ -0,0 +1,5 @@
+interface VersionHeaderProps {
+    headerId: string;
+}
+export declare const VersionHeader: ({ headerId }: VersionHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

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

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

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import { Contracts } from '@strapi/plugin-content-manager/_internal/shared';
+import { type EditLayout } from '../../hooks/useDocumentLayout';
+import type { UID } from '@strapi/types';
+interface HistoryContextValue {
+    contentType: UID.ContentType;
+    id?: string;
+    layout: EditLayout['layout'];
+    selectedVersion: Contracts.HistoryVersions.HistoryVersionDataResponse;
+    versions: Extract<Contracts.HistoryVersions.GetHistoryVersions.Response, {
+        data: Array<Contracts.HistoryVersions.HistoryVersionDataResponse>;
+    }>;
+    page: number;
+    mainField: string;
+    schema: Contracts.ContentTypes.ContentType;
+}
+declare const HistoryProvider: {
+    (props: HistoryContextValue & {
+        children: React.ReactNode;
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+}, useHistoryContext: <Selected>(consumerName: string, selector: (value: HistoryContextValue) => Selected) => Selected;
+declare const ProtectedHistoryPage: () => import("react/jsx-runtime").JSX.Element;
+export { ProtectedHistoryPage, HistoryProvider, useHistoryContext };
+export type { HistoryContextValue };

package/dist/admin/src/content-manager/history/routes.d.ts

@@ -0,0 +1,11 @@
+import { type RouteObject } from 'react-router-dom';
+/**
+ * These routes will be merged with the rest of the Content Manager routes
+ */
+declare const routes: RouteObject[];
+/**
+ * Used to determine if we're on a history route from the admin and the content manager,
+ * so that we can hide the left menus on all history routes
+ */
+declare function useIsHistoryRoute(): boolean;
+export { routes, useIsHistoryRoute };

package/dist/admin/src/content-manager/history/services/historyVersion.d.ts

@@ -0,0 +1,7 @@
+import { Contracts } from '@strapi/plugin-content-manager/_internal/shared';
+declare const useGetHistoryVersionsQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<{
+    contentType: `admin::${string}` | `strapi::${string}` | `api::${string}.${string}` | `plugin::${string}.${string}`;
+    documentId?: import("@strapi/types/dist/types/core/entity").ID | undefined;
+    locale?: string | undefined;
+} & Partial<Pick<Contracts.HistoryVersions.Pagination, "page" | "pageSize">>, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("../../../utils/baseQuery").QueryArguments, unknown, import("../../../utils/baseQuery").BaseQueryError>, "ComponentConfiguration" | "ContentTypesConfiguration" | "ContentTypeSettings" | "Document" | "InitialData" | "HistoryVersion", Contracts.HistoryVersions.GetHistoryVersions.Response, "contentManagerApi">>;
+export { useGetHistoryVersionsQuery };

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

@@ -1,5 +1,5 @@
 import { Permission } from '@strapi/helper-plugin';
-import { Contracts } from '@strapi/plugin-content-manager/_internal/shared';
+import { ContentManagerAppState } from '../layout';
 interface ContentManagerLink {
     permissions: Permission[];
     search: string | null;
@@ -10,20 +10,6 @@ interface ContentManagerLink {
     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";
-};
+declare const useContentManagerInitData: () => ContentManagerAppState;
 export { useContentManagerInitData };
 export type { ContentManagerLink };

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

@@ -0,0 +1,24 @@
+import type { Contracts } from '@strapi/plugin-content-manager/_internal/shared';
+type ComponentsDictionary = Record<string, Contracts.Components.Component>;
+/**
+ * @internal
+ * @description Given a model UID, return the schema and the schemas
+ * of the associated components within said model's schema. A wrapper
+ * implementation around the `useGetInitialDataQuery` with a unique
+ * `selectFromResult` function to memoize the calculation.
+ *
+ * If no model is provided, the hook will return all the schemas.
+ */
+declare const useContentTypeSchema: (model?: string) => {
+    components: ComponentsDictionary;
+    schema: Contracts.ContentTypes.ContentType | undefined;
+    schemas: Contracts.ContentTypes.ContentType[];
+    isLoading: boolean;
+};
+/**
+ * @internal
+ * @description Extracts the components used in a content type's attributes recursively.
+ */
+declare const extractContentTypeComponents: (attributes?: Contracts.ContentTypes.ContentType['attributes'], allComponents?: ComponentsDictionary) => ComponentsDictionary;
+export { useContentTypeSchema, extractContentTypeComponents };
+export type { ComponentsDictionary };