@strapi/content-manager 0.0.0-experimental.00380841fe1b29f71fe755bb387fa1f75073621b

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

@@ -0,0 +1,51 @@
+/// <reference types="react" />
+import { InjectionZoneComponent } from '@strapi/admin/strapi-admin';
+declare const INJECTION_ZONES: {
+    editView: {
+        informations: never[];
+        'right-links': never[];
+    };
+    listView: {
+        actions: never[];
+        deleteModalAdditionalInfos: never[];
+        publishModalAdditionalInfos: never[];
+        unpublishModalAdditionalInfos: never[];
+    };
+    preview: {
+        actions: never[];
+    };
+};
+interface InjectionZones {
+    editView: {
+        informations: InjectionZoneComponent[];
+        'right-links': InjectionZoneComponent[];
+    };
+    listView: {
+        actions: InjectionZoneComponent[];
+        deleteModalAdditionalInfos: InjectionZoneComponent[];
+        publishModalAdditionalInfos: InjectionZoneComponent[];
+        unpublishModalAdditionalInfos: InjectionZoneComponent[];
+    };
+    preview: {
+        actions: InjectionZoneComponent[];
+    };
+}
+type InjectionZoneArea = 'editView.informations' | 'editView.right-links' | 'listView.actions' | 'listView.unpublishModalAdditionalInfos' | 'listView.deleteModalAdditionalInfos' | 'listView.publishModalAdditionalInfos' | 'listView.deleteModalAdditionalInfos' | 'preview.actions';
+type InjectionZoneModule = InjectionZoneArea extends `${infer Word}.${string}` ? Word : never;
+type InjectionZoneContainer = InjectionZoneArea extends `${string}.${infer Word}.${string}` ? Word : never;
+type InjectionZoneBlock = InjectionZoneArea extends `${string}.${string}.${infer Word}` ? Word : never;
+/**
+ * You can't know what this component props will be because it's generic and used everywhere
+ * e.g. content-manager edit view, we just send the slug but we might not in the listView,
+ * therefore, people should type it themselves on the components they render.
+ */
+declare const InjectionZone: ({ area, ...props }: {
+    area: InjectionZoneArea;
+    [key: string]: unknown;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useInjectionZone: (area: InjectionZoneArea) => {
+    name: string;
+    Component: import("react").ComponentType<{}>;
+}[];
+export { InjectionZone, INJECTION_ZONES };
+export type { InjectionZoneArea, InjectionZoneComponent, InjectionZones, InjectionZoneModule, InjectionZoneContainer, InjectionZoneBlock, };

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

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

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

@@ -0,0 +1,28 @@
+import * as React from 'react';
+import { Duration } from 'date-fns';
+interface CustomInterval {
+    unit: keyof Duration;
+    text: string;
+    threshold: number;
+}
+interface RelativeTimeProps extends React.ComponentPropsWithoutRef<'time'> {
+    timestamp: Date;
+    customIntervals?: CustomInterval[];
+}
+/**
+ * Displays the relative time between a given timestamp and the current time.
+ * You can display a custom message for given time intervals by passing an array of custom intervals.
+ *
+ * @example
+ * ```jsx
+ * <caption>Display "last hour" if the timestamp is less than an hour ago</caption>
+ * <RelativeTime
+ *  timestamp={new Date('2021-01-01')}
+ *  customIntervals={[
+ *   { unit: 'hours', threshold: 1, text: 'last hour' },
+ *  ]}
+ * ```
+ */
+declare const RelativeTime: React.ForwardRefExoticComponent<RelativeTimeProps & React.RefAttributes<HTMLTimeElement>>;
+export { RelativeTime };
+export type { CustomInterval, RelativeTimeProps };

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

@@ -0,0 +1,8 @@
+declare const LastEditedWidget: ({ columnWidth }: {
+    columnWidth?: number;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const LastPublishedWidget: ({ columnWidth }: {
+    columnWidth?: number;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const ChartEntriesWidget: () => import("react/jsx-runtime").JSX.Element;
+export { ChartEntriesWidget, LastEditedWidget, LastPublishedWidget };

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

@@ -0,0 +1,14 @@
+declare const CREATED_BY_ATTRIBUTE_NAME = "createdBy";
+declare const UPDATED_BY_ATTRIBUTE_NAME = "updatedBy";
+declare const CREATOR_FIELDS: string[];
+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/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/constants/dragAndDrop.d.ts

@@ -0,0 +1,8 @@
+export declare const ItemTypes: {
+    readonly COMPONENT: "component";
+    readonly EDIT_FIELD: "editField";
+    readonly FIELD: "field";
+    readonly DYNAMIC_ZONE: "dynamicZone";
+    readonly RELATION: "relation";
+    readonly BLOCKS: "blocks";
+};

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

@@ -0,0 +1,26 @@
+export declare const HOOKS: {
+    /**
+     * Hook that allows to mutate the displayed headers of the list view table
+     * @constant
+     * @type {string}
+     */
+    INJECT_COLUMN_IN_TABLE: string;
+    /**
+     * Hook that allows to mutate the CM's collection types links pre-set filters
+     * @constant
+     * @type {string}
+     */
+    MUTATE_COLLECTION_TYPES_LINKS: string;
+    /**
+     * Hook that allows to mutate the CM's edit view layout
+     * @constant
+     * @type {string}
+     */
+    MUTATE_EDIT_VIEW_LAYOUT: string;
+    /**
+     * Hook that allows to mutate the CM's single types links pre-set filters
+     * @constant
+     * @type {string}
+     */
+    MUTATE_SINGLE_TYPES_LINKS: string;
+};

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

@@ -0,0 +1,3 @@
+declare const PLUGIN_ID = "content-manager";
+declare const PERMISSIONS: string[];
+export { PLUGIN_ID, PERMISSIONS };

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

@@ -0,0 +1,137 @@
+import { type DocumentActionPosition, type DocumentActionDescription } from './pages/EditView/components/DocumentActions';
+import { type HeaderActionDescription } from './pages/EditView/components/Header';
+import { type PanelDescription } from './pages/EditView/components/Panels';
+import { type BulkActionDescription } from './pages/ListView/components/BulkActions/Actions';
+import type { Document } from './hooks/useDocument';
+import type { DocumentMetadata } from '../../shared/contracts/collection-types';
+import type { DescriptionComponent } from '@strapi/admin/strapi-admin';
+type DescriptionReducer<Config extends object> = (prev: Config[]) => Config[];
+interface EditViewContext {
+    /**
+     * This will ONLY be null, if the content-type
+     * does not have draft & published enabled.
+     */
+    activeTab: 'draft' | 'published' | null;
+    /**
+     * Will be either 'single-types' | 'collection-types'
+     */
+    collectionType: string;
+    /**
+     * this will be undefined if someone is creating an entry.
+     */
+    document?: Document;
+    /**
+     * this will be undefined if someone is creating an entry.
+     */
+    documentId?: string;
+    /**
+     * this will be undefined if someone is creating an entry.
+     */
+    meta?: DocumentMetadata;
+    /**
+     * The current content-type's model.
+     */
+    model: string;
+}
+interface ListViewContext {
+    /**
+     * Will be either 'single-types' | 'collection-types'
+     */
+    collectionType: string;
+    /**
+     * The current selected documents in the table
+     */
+    documents: Document[];
+    /**
+     * The current content-type's model.
+     */
+    model: string;
+}
+interface PanelComponentProps extends EditViewContext {
+}
+interface PanelComponent extends DescriptionComponent<PanelComponentProps, PanelDescription> {
+    /**
+     * The defaults are added by Strapi only, if you're providing your own component,
+     * you do not need to provide this.
+     */
+    type?: 'actions' | 'releases';
+}
+interface DocumentActionProps extends EditViewContext {
+}
+interface DocumentActionComponent extends DescriptionComponent<DocumentActionProps, DocumentActionDescription> {
+    type?: 'clone' | 'configure-the-view' | 'delete' | 'discard' | 'edit' | 'edit-the-model' | 'history' | 'publish' | 'unpublish' | 'update';
+    position?: DocumentActionDescription['position'];
+}
+interface HeaderActionProps extends EditViewContext {
+}
+interface HeaderActionComponent extends DescriptionComponent<HeaderActionProps, HeaderActionDescription> {
+}
+interface BulkActionComponentProps extends ListViewContext {
+}
+interface BulkActionComponent extends DescriptionComponent<BulkActionComponentProps, BulkActionDescription> {
+    type?: 'delete' | 'publish' | 'unpublish';
+}
+declare class ContentManagerPlugin {
+    /**
+     * The following properties are the stored ones provided by any plugins registering with
+     * the content-manager. The function calls however, need to be called at runtime in the
+     * application, so instead we collate them and run them later with the complete list incl.
+     * ones already registered & the context of the view.
+     */
+    bulkActions: BulkActionComponent[];
+    documentActions: DocumentActionComponent[];
+    editViewSidePanels: PanelComponent[];
+    headerActions: HeaderActionComponent[];
+    constructor();
+    addEditViewSidePanel(panels: DescriptionReducer<PanelComponent>): void;
+    addEditViewSidePanel(panels: PanelComponent[]): void;
+    addDocumentAction(actions: DescriptionReducer<DocumentActionComponent>): void;
+    addDocumentAction(actions: DocumentActionComponent[]): void;
+    addDocumentHeaderAction(actions: DescriptionReducer<HeaderActionComponent>): void;
+    addDocumentHeaderAction(actions: HeaderActionComponent[]): void;
+    addBulkAction(actions: DescriptionReducer<BulkActionComponent>): void;
+    addBulkAction(actions: BulkActionComponent[]): void;
+    get config(): {
+        id: string;
+        name: string;
+        injectionZones: {
+            editView: {
+                informations: never[];
+                'right-links': never[];
+            };
+            listView: {
+                actions: never[];
+                deleteModalAdditionalInfos: never[];
+                publishModalAdditionalInfos: never[];
+                unpublishModalAdditionalInfos: never[];
+            };
+            preview: {
+                actions: never[];
+            };
+        };
+        apis: {
+            addBulkAction: {
+                (actions: DescriptionReducer<BulkActionComponent>): void;
+                (actions: BulkActionComponent[]): void;
+            };
+            addDocumentAction: {
+                (actions: DescriptionReducer<DocumentActionComponent>): void;
+                (actions: DocumentActionComponent[]): void;
+            };
+            addDocumentHeaderAction: {
+                (actions: DescriptionReducer<HeaderActionComponent>): void;
+                (actions: HeaderActionComponent[]): void;
+            };
+            addEditViewSidePanel: {
+                (panels: DescriptionReducer<PanelComponent>): void;
+                (panels: PanelComponent[]): void;
+            };
+            getBulkActions: () => BulkActionComponent[];
+            getDocumentActions: (position?: DocumentActionPosition) => DocumentActionComponent[];
+            getEditViewSidePanels: () => PanelComponent[];
+            getHeaderActions: () => HeaderActionComponent[];
+        };
+    };
+}
+export { ContentManagerPlugin };
+export type { EditViewContext, ListViewContext, BulkActionComponent, BulkActionComponentProps, BulkActionDescription, DescriptionComponent, DescriptionReducer, PanelComponentProps, PanelComponent, PanelDescription, DocumentActionComponent, DocumentActionDescription, DocumentActionProps, HeaderActionComponent, HeaderActionDescription, HeaderActionProps, };

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

@@ -0,0 +1,14 @@
+/**
+ * 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 { buildValidParams } from './utils/api';
+export { RelativeTime } from './components/RelativeTime';
+export { DocumentStatus } from './pages/EditView/components/DocumentStatus';
+export { useDocument as unstable_useDocument, useContentManagerContext as unstable_useContentManagerContext, } 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';
+export type { EditViewContext, ListViewContext, BulkActionComponent, BulkActionComponentProps, BulkActionDescription, DescriptionComponent, DescriptionReducer, PanelComponentProps, PanelComponent, PanelDescription, DocumentActionComponent, DocumentActionDescription, DocumentActionProps, HeaderActionComponent, HeaderActionDescription, HeaderActionProps, } from './content-manager';

package/dist/admin/src/features/DocumentRBAC.d.ts

@@ -0,0 +1,37 @@
+import * as React from 'react';
+import { type Permission } from '@strapi/admin/strapi-admin';
+import type { Schema } 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: Schema.Attribute.Kind) => boolean;
+    isLoading: boolean;
+}
+declare const useDocumentRBAC: <Selected, ShouldThrow extends boolean = true>(consumerName: string, selector: (value: DocumentRBACContextValue) => Selected, shouldThrowOnMissingContext?: ShouldThrow | undefined) => ShouldThrow extends true ? Selected : Selected | undefined;
+interface DocumentRBACProps {
+    children: React.ReactNode;
+    permissions: Permission[] | null;
+    model?: string;
+}
+/**
+ * @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 or the model if it is passed as arg.
+ * 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, model }: DocumentRBACProps) => import("react/jsx-runtime").JSX.Element;
+export { DocumentRBAC, useDocumentRBAC, DocumentRBACContextValue, DocumentRBACProps };

package/dist/admin/src/history/components/HistoryAction.d.ts

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

package/dist/admin/src/history/components/VersionContent.d.ts

@@ -0,0 +1,17 @@
+import { HistoryContextValue } from '../pages/History';
+import type { Metadatas } from '../../../../shared/contracts/content-types';
+import type { GetInitData } from '../../../../shared/contracts/init';
+import type { EditFieldLayout } from '../../hooks/useDocumentLayout';
+interface GetRemainingFieldsLayoutOptions extends Pick<HistoryContextValue, 'layout'>, Pick<GetInitData.Response['data'], 'fieldSizes'> {
+    schemaAttributes: HistoryContextValue['schema']['attributes'];
+    metadatas: Metadatas;
+}
+/**
+ * Build a layout for the fields that are were deleted from the edit view layout
+ * via the configure the view page. This layout will be merged with the main one.
+ * Those fields would be restored if the user restores the history version, which is why it's
+ * important to show them, even if they're not in the normal layout.
+ */
+declare function getRemaingFieldsLayout({ layout, metadatas, schemaAttributes, fieldSizes, }: GetRemainingFieldsLayoutOptions): EditFieldLayout[][][];
+declare const VersionContent: () => import("react/jsx-runtime").JSX.Element;
+export { VersionContent, getRemaingFieldsLayout };

package/dist/admin/src/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/history/components/VersionInputRenderer.d.ts

@@ -0,0 +1,19 @@
+import type { EditFieldLayout } from '../../hooks/useDocumentLayout';
+import type { DistributiveOmit } from 'react-redux';
+type VersionInputRendererProps = DistributiveOmit<EditFieldLayout, 'size'> & {
+    /**
+     * In the context of content history, deleted fields need to ignore RBAC
+     * @default false
+     */
+    shouldIgnoreRBAC?: boolean;
+};
+/**
+ * @internal
+ *
+ * @description An abstraction around the regular form input renderer designed specifically
+ * to be used on the History page in the content-manager. It understands how to render specific
+ * inputs within the context of a history version (i.e. relations, media, ignored RBAC, etc...)
+ */
+declare const VersionInputRenderer: ({ visible, hint: providedHint, shouldIgnoreRBAC, labelAction, ...props }: VersionInputRendererProps) => import("react/jsx-runtime").JSX.Element | null;
+export type { VersionInputRendererProps };
+export { VersionInputRenderer };

package/dist/admin/src/history/components/VersionsList.d.ts

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

package/dist/admin/src/history/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '@strapi/types';
+declare const historyAdmin: Partial<Plugin.Config.AdminInput>;
+export { historyAdmin };

package/dist/admin/src/history/pages/History.d.ts

@@ -0,0 +1,27 @@
+import * as React from 'react';
+import { type EditLayout } from '../../hooks/useDocumentLayout';
+import type { ContentType, FindContentTypeConfiguration } from '../../../../shared/contracts/content-types';
+import type { HistoryVersionDataResponse, GetHistoryVersions } from '../../../../shared/contracts/history-versions';
+import type { UID } from '@strapi/types';
+interface HistoryContextValue {
+    contentType: UID.ContentType;
+    id?: string;
+    layout: EditLayout['layout'];
+    configuration: FindContentTypeConfiguration.Response['data'];
+    selectedVersion: HistoryVersionDataResponse;
+    versions: Extract<GetHistoryVersions.Response, {
+        data: Array<HistoryVersionDataResponse>;
+    }>;
+    page: number;
+    mainField: string;
+    schema: ContentType;
+}
+declare const HistoryProvider: {
+    (props: HistoryContextValue & {
+        children: React.ReactNode;
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+}, useHistoryContext: <Selected, ShouldThrow extends boolean = true>(consumerName: string, selector: (value: HistoryContextValue) => Selected, shouldThrowOnMissingContext?: ShouldThrow | undefined) => ShouldThrow extends true ? Selected : Selected | undefined;
+declare const ProtectedHistoryPage: () => import("react/jsx-runtime").JSX.Element;
+export { ProtectedHistoryPage, HistoryProvider, useHistoryContext };
+export type { HistoryContextValue };

package/dist/admin/src/history/routes.d.ts

@@ -0,0 +1,6 @@
+import { type PathRouteProps } from 'react-router-dom';
+/**
+ * These routes will be merged with the rest of the Content Manager routes
+ */
+declare const routes: PathRouteProps[];
+export { routes };

package/dist/admin/src/history/services/historyVersion.d.ts

@@ -0,0 +1,12 @@
+import { GetHistoryVersions, RestoreHistoryVersion } from '../../../../shared/contracts/history-versions';
+import type { Data } from '@strapi/types';
+interface RestoreVersion extends RestoreHistoryVersion.Request {
+    documentId: Data.ID;
+    collectionType?: string;
+}
+declare const useGetHistoryVersionsQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<{
+    contentType: import("@strapi/types/dist/uid").ContentType;
+    documentId?: Data.ID | undefined;
+    locale?: string | undefined;
+} & Partial<Pick<import("../../../../shared/contracts/history-versions").Pagination, "page" | "pageSize">>, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AIUsage" | "ComponentConfiguration" | "ContentTypesConfiguration" | "ContentTypeSettings" | "Document" | "InitialData" | "HistoryVersion" | "Relations" | "UidAvailability" | "RecentDocumentList" | "CountDocuments" | "UpcomingReleasesList" | "AILocalizationJobs", GetHistoryVersions.Response, "adminApi">>, useRestoreVersionMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<RestoreVersion, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AIUsage" | "ComponentConfiguration" | "ContentTypesConfiguration" | "ContentTypeSettings" | "Document" | "InitialData" | "HistoryVersion" | "Relations" | "UidAvailability" | "RecentDocumentList" | "CountDocuments" | "UpcomingReleasesList" | "AILocalizationJobs", RestoreHistoryVersion.Response, "adminApi">>;
+export { useGetHistoryVersionsQuery, useRestoreVersionMutation };

package/dist/admin/src/hooks/useContentManagerInitData.d.ts

@@ -0,0 +1,15 @@
+import { type Permission } from '@strapi/admin/strapi-admin';
+import { AppState } from '../modules/app';
+interface ContentManagerLink {
+    permissions: Permission[];
+    search: string | null;
+    kind: string;
+    title: string;
+    to: string;
+    uid: string;
+    name: string;
+    isDisplayed: boolean;
+}
+declare const useContentManagerInitData: () => AppState;
+export { useContentManagerInitData };
+export type { ContentManagerLink };

package/dist/admin/src/hooks/useContentTypeSchema.d.ts

@@ -0,0 +1,25 @@
+import type { Component } from '../../../shared/contracts/components';
+import type { ContentType } from '../../../shared/contracts/content-types';
+type ComponentsDictionary = Record<string, 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: ContentType | undefined;
+    schemas: ContentType[];
+    isLoading: boolean;
+};
+/**
+ * @internal
+ * @description Extracts the components used in a content type's attributes recursively.
+ */
+declare const extractContentTypeComponents: (attributes?: ContentType['attributes'], allComponents?: ComponentsDictionary) => ComponentsDictionary;
+export { useContentTypeSchema, extractContentTypeComponents };
+export type { ComponentsDictionary };

package/dist/admin/src/hooks/useDebounce.d.ts

@@ -0,0 +1 @@
+export declare function useDebounce<TValue>(value: TValue, delay: number): TValue;

package/dist/admin/src/hooks/useDocument.d.ts

@@ -0,0 +1,137 @@
+/**
+ * This hook doesn't use a context provider because we fetch directly from the server,
+ * this sounds expensive but actually, it's really not. Because we have redux-toolkit-query
+ * being a cache layer so if nothing invalidates the cache, we don't fetch again.
+ */
+import { FormErrors } from '@strapi/admin/strapi-admin';
+import { type AnyData } from '../pages/EditView/utils/data';
+import { useGetDocumentQuery } from '../services/documents';
+import { ComponentsDictionary } from './useContentTypeSchema';
+import type { FindOne } from '../../../shared/contracts/collection-types';
+import type { ContentType } from '../../../shared/contracts/content-types';
+import type { Modules } from '@strapi/types';
+interface UseDocumentArgs {
+    collectionType: string;
+    model: string;
+    documentId?: string;
+    params?: object;
+}
+type UseDocumentOpts = Parameters<typeof useGetDocumentQuery>[1];
+type Document = FindOne.Response['data'];
+type Schema = ContentType;
+type UseDocument = (args: UseDocumentArgs, opts?: UseDocumentOpts) => {
+    /**
+     * These are the schemas of the components used in the content type, organised
+     * by their uid.
+     */
+    components: ComponentsDictionary;
+    document?: Document;
+    meta?: FindOne.Response['meta'];
+    isLoading: boolean;
+    /**
+     * This is the schema of the content type, it is not the same as the layout.
+     */
+    schema?: Schema;
+    schemas?: Schema[];
+    hasError?: boolean;
+    refetch: () => void;
+    validate: (document: Document) => null | FormErrors;
+    /**
+     * Get the document's title
+     */
+    getTitle: (mainField: string) => string;
+    /**
+     * Get the initial form values for the document
+     */
+    getInitialFormValues: (isCreatingDocument?: boolean) => AnyData | undefined;
+};
+/**
+ * @alpha
+ * @public
+ * @description Returns a document based on the model, collection type & id passed as arguments.
+ * Also extracts its schema from the redux cache to be used for creating a validation schema.
+ * @example
+ * ```tsx
+ * const { id, model, collectionType } = useParams<{ id: string; model: string; collectionType: string }>();
+ *
+ * if(!model || !collectionType) return null;
+ *
+ * const { document, isLoading, validate } = useDocument({ documentId: id, model, collectionType, params: { locale: 'en-GB' } })
+ * const { update } = useDocumentActions()
+ *
+ * const onSubmit = async (document: Document) => {
+ *  const errors = validate(document);
+ *
+ *  if(errors) {
+ *      // handle errors
+ *  }
+ *
+ *  await update({ collectionType, model, id }, document)
+ * }
+ * ```
+ *
+ * @see {@link https://contributor.strapi.io/docs/core/content-manager/hooks/use-document} for more information
+ */
+declare const useDocument: UseDocument;
+/**
+ * @internal this hook uses the router to extract the model, collection type & id from the url.
+ * therefore, it shouldn't be used outside of the content-manager because it won't work as intended.
+ */
+declare const useDoc: () => {
+    /**
+     * These are the schemas of the components used in the content type, organised
+     * by their uid.
+     */
+    components: ComponentsDictionary;
+    document?: Modules.Documents.AnyDocument | undefined;
+    meta?: import("../../../shared/contracts/collection-types").DocumentMetadata | undefined;
+    isLoading: boolean;
+    /**
+     * This is the schema of the content type, it is not the same as the layout.
+     */
+    schema?: ContentType | undefined;
+    schemas?: ContentType[] | undefined;
+    hasError?: boolean | undefined;
+    refetch: () => void;
+    validate: (document: Document) => null | FormErrors;
+    /**
+     * Get the document's title
+     */
+    getTitle: (mainField: string) => string;
+    /**
+     * Get the initial form values for the document
+     */
+    getInitialFormValues: (isCreatingDocument?: boolean) => AnyData | undefined;
+    collectionType: string;
+    model: string;
+    id: string | undefined;
+};
+/**
+ * @public
+ * @experimental
+ * Content manager context hooks for plugin development.
+ * Make sure to use this hook inside the content manager.
+ */
+declare const useContentManagerContext: () => {
+    error: import("@reduxjs/toolkit").SerializedError | import("../utils/api").BaseQueryError | undefined;
+    isLoading: boolean;
+    model: string;
+    collectionType: string;
+    id: string | undefined;
+    slug: string;
+    isCreatingEntry: boolean;
+    isSingleType: boolean;
+    hasDraftAndPublish: boolean;
+    components: ComponentsDictionary;
+    contentType: ContentType | undefined;
+    contentTypes: ContentType[] | undefined;
+    form: unknown;
+    layout: {
+        error?: import("@reduxjs/toolkit").SerializedError | import("../utils/api").BaseQueryError | undefined;
+        isLoading: boolean;
+        edit: import("./useDocumentLayout").EditLayout;
+        list: import("./useDocumentLayout").ListLayout;
+    };
+};
+export { useDocument, useDoc, useContentManagerContext };
+export type { UseDocument, UseDocumentArgs, Document, Schema, ComponentsDictionary };