@strapi/content-manager 0.0.0 → 5.0.0-beta.11

package/dist/_chunks/zh-Hans-BPQcRIyH.mjs.map

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

package/dist/admin/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index = require("../_chunks/index-DVPWZkbS.js");
+require("@strapi/icons");
+exports.DocumentRBAC = index.DocumentRBAC;
+exports.buildValidParams = index.buildValidParams;
+exports.default = index.index;
+exports.unstable_useDocument = index.useDocument;
+exports.unstable_useDocumentActions = index.useDocumentActions;
+exports.unstable_useDocumentLayout = index.useDocumentLayout;
+exports.useDocumentRBAC = index.useDocumentRBAC;
+//# sourceMappingURL=index.js.map

package/dist/admin/index.js.map

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

package/dist/admin/index.mjs

@@ -0,0 +1,12 @@
+import { l, d, J, G, K, h, f } from "../_chunks/index-DJXJw9V5.mjs";
+import "@strapi/icons";
+export {
+  l as DocumentRBAC,
+  d as buildValidParams,
+  J as default,
+  G as unstable_useDocument,
+  K as unstable_useDocumentActions,
+  h as unstable_useDocumentLayout,
+  f as useDocumentRBAC
+};
+//# sourceMappingURL=index.mjs.map

package/dist/admin/index.mjs.map

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

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

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { FlexProps } from '@strapi/design-system';
+import type { Struct } from '@strapi/types';
+interface ComponentIconProps extends FlexProps {
+    showBackground?: boolean;
+    icon?: Struct.ContentTypeSchemaInfo['icon'];
+}
+declare const ComponentIcon: ({ showBackground, icon, ...props }: ComponentIconProps) => import("react/jsx-runtime").JSX.Element;
+declare const COMPONENT_ICONS: Record<string, React.ComponentType<any>>;
+export { ComponentIcon, COMPONENT_ICONS };
+export type { ComponentIconProps };

package/dist/admin/src/components/ConfigurationForm/EditFieldForm.d.ts

@@ -0,0 +1,9 @@
+import type { Schema } from '@strapi/types';
+interface EditFieldFormProps {
+    attribute?: Schema.Attribute.AnyAttribute;
+    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/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/components/ConfigurationForm/Form.d.ts

@@ -0,0 +1,32 @@
+import { FormProps } from '@strapi/admin/strapi-admin';
+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/components/DragLayer.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { DragLayerMonitor } from 'react-dnd';
+export interface DragLayerProps {
+    renderItem: (item: {
+        /**
+         * TODO: it'd be great if we could make this a union where the type infers the item.
+         */
+        item: any;
+        type: ReturnType<DragLayerMonitor['getItemType']>;
+    }) => React.ReactNode;
+}
+declare const DragLayer: ({ renderItem }: DragLayerProps) => import("react/jsx-runtime").JSX.Element | null;
+export { DragLayer };

package/dist/admin/src/components/DragPreviews/CardDragPreview.d.ts

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

package/dist/admin/src/components/DragPreviews/ComponentDragPreview.d.ts

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

package/dist/admin/src/components/DragPreviews/RelationDragPreview.d.ts

@@ -0,0 +1,11 @@
+import type { Data } from '@strapi/types';
+interface RelationDragPreviewProps {
+    status?: string;
+    displayedValue: string;
+    id: Data.ID;
+    index: number;
+    width: number;
+}
+declare const RelationDragPreview: ({ status, displayedValue, width }: RelationDragPreviewProps) => import("react/jsx-runtime").JSX.Element;
+export { RelationDragPreview };
+export type { RelationDragPreviewProps };

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

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import type { Schema } from '@strapi/types';
+declare const iconByTypes: Record<Schema.Attribute.Kind, React.ReactElement>;
+interface FieldTypeIconProps {
+    type?: keyof typeof iconByTypes;
+    customFieldUid?: string;
+}
+declare const FieldTypeIcon: ({ type, customFieldUid }: FieldTypeIconProps) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+export { FieldTypeIcon };

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

@@ -0,0 +1,45 @@
+/// <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[];
+    };
+};
+interface InjectionZones {
+    editView: {
+        informations: InjectionZoneComponent[];
+        'right-links': InjectionZoneComponent[];
+    };
+    listView: {
+        actions: InjectionZoneComponent[];
+        deleteModalAdditionalInfos: InjectionZoneComponent[];
+        publishModalAdditionalInfos: InjectionZoneComponent[];
+        unpublishModalAdditionalInfos: InjectionZoneComponent[];
+    };
+}
+type InjectionZoneArea = 'editView.informations' | 'editView.right-links' | 'listView.actions' | 'listView.unpublishModalAdditionalInfos' | 'listView.deleteModalAdditionalInfos' | 'listView.publishModalAdditionalInfos' | 'listView.deleteModalAdditionalInfos';
+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,2 @@
+declare const LeftMenu: () => 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/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,133 @@
+import { 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';
+}
+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[];
+            };
+        };
+        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: () => 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,12 @@
+/**
+ * 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 { 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';
+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,36 @@
+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>(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/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/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>(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/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 { Data } from '@strapi/types';
+import { GetHistoryVersions, RestoreHistoryVersion } from '../../../../shared/contracts/history-versions';
+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, {}, {}>, "ComponentConfiguration" | "ContentTypesConfiguration" | "ContentTypeSettings" | "Document" | "InitialData" | "HistoryVersion" | "Relations", 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, {}, {}>, "ComponentConfiguration" | "ContentTypesConfiguration" | "ContentTypeSettings" | "Document" | "InitialData" | "HistoryVersion" | "Relations", 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 };