@strapi/admin 5.0.0-beta.1 → 5.0.0-beta.3

package/dist/admin/sk-5bIrjuCN.mjs.map

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

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

@@ -1,59 +0,0 @@
-import * as React from 'react';
-declare const INJECTION_ZONES: {
-    admin: {
-        tutorials: {
-            links: never[];
-        };
-    };
-    contentManager: {
-        editView: {
-            informations: never[];
-            'right-links': never[];
-        };
-        listView: {
-            actions: never[];
-            deleteModalAdditionalInfos: never[];
-            publishModalAdditionalInfos: never[];
-            unpublishModalAdditionalInfos: never[];
-        };
-    };
-};
-interface InjectionZoneComponent {
-    Component: React.ComponentType;
-    name: string;
-    slug: string;
-}
-interface InjectionZones {
-    admin: {
-        tutorials: {
-            links: InjectionZoneComponent[];
-        };
-    };
-    contentManager: {
-        editView: {
-            informations: InjectionZoneComponent[];
-            'right-links': InjectionZoneComponent[];
-        };
-        listView: {
-            actions: InjectionZoneComponent[];
-            deleteModalAdditionalInfos: InjectionZoneComponent[];
-            publishModalAdditionalInfos: InjectionZoneComponent[];
-            unpublishModalAdditionalInfos: InjectionZoneComponent[];
-        };
-    };
-}
-type InjectionZoneArea = 'admin.tutorials.links' | 'contentManager.editView.informations' | 'contentManager.editView.right-links' | 'contentManager.listView.actions' | 'contentManager.listView.unpublishModalAdditionalInfos' | 'contentManager.listView.deleteModalAdditionalInfos' | 'contentManager.listView.publishModalAdditionalInfos' | 'contentManager.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 }: {
-    [key: string]: unknown;
-    area: InjectionZoneArea;
-}) => import("react/jsx-runtime").JSX.Element;
-export { InjectionZone, INJECTION_ZONES };
-export type { InjectionZoneArea, InjectionZoneComponent, InjectionZones, InjectionZoneModule, InjectionZoneContainer, InjectionZoneBlock, };

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

@@ -1,8 +0,0 @@
-import type { Struct } from '@strapi/types';
-interface ComponentIconProps {
-    showBackground?: boolean;
-    icon?: Struct.ContentTypeSchemaInfo['icon'];
-}
-declare const ComponentIcon: ({ showBackground, icon }: ComponentIconProps) => import("react/jsx-runtime").JSX.Element;
-export { ComponentIcon };
-export type { ComponentIconProps };

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

@@ -1,9 +0,0 @@
-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/content-manager/components/ConfigurationForm/Fields.d.ts

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

@@ -1,32 +0,0 @@
-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 +0,0 @@
-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/content-manager/components/DragPreviews/ComponentDragPreview.d.ts

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

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

@@ -1,11 +0,0 @@
-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/content-manager/components/FieldTypeIcon.d.ts

@@ -1,9 +0,0 @@
-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/content-manager/components/LeftMenu.d.ts

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

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

@@ -1,14 +0,0 @@
-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/content-manager/constants/collections.d.ts

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

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

@@ -1,8 +0,0 @@
-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/content-manager/exports.d.ts

@@ -1,10 +0,0 @@
-/**
- * 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

@@ -1,36 +0,0 @@
-import * as React from 'react';
-import { type Permission } from '../../features/Auth';
-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/content-manager/history/components/HistoryAction.d.ts

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

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

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

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

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

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

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

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

@@ -1,7 +0,0 @@
-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: import("@strapi/types/dist/uid").ContentType;
-    documentId?: import("@strapi/types/dist/data").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" | "Relations", Contracts.HistoryVersions.GetHistoryVersions.Response, "contentManagerApi">>;
-export { useGetHistoryVersionsQuery };

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

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

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

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

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

@@ -1,89 +0,0 @@
-/**
- * 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 { useGetDocumentQuery } from '../services/documents';
-import { ComponentsDictionary } from './useContentTypeSchema';
-import type { Contracts } from '@strapi/plugin-content-manager/_internal/shared';
-import type { MessageDescriptor, PrimitiveType } from 'react-intl';
-interface UseDocumentArgs {
-    collectionType: string;
-    model: string;
-    documentId?: string;
-    params?: object;
-}
-type UseDocumentOpts = Parameters<typeof useGetDocumentQuery>[1];
-type Document = Contracts.CollectionTypes.FindOne.Response['data'];
-type Schema = Contracts.ContentTypes.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?: Contracts.CollectionTypes.FindOne.Response['meta'];
-    isLoading: boolean;
-    /**
-     * This is the schema of the content type, it is not the same as the layout.
-     */
-    schema?: Schema;
-    validate: (document: Document) => null | Record<string, MessageDescriptor & {
-        values?: Record<string, PrimitiveType>;
-    }>;
-};
-/**
- * @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?: import("@strapi/types/dist/modules/documents").AnyDocument | undefined;
-    meta?: Contracts.CollectionTypes.DocumentMetadata | undefined;
-    isLoading: boolean;
-    /**
-     * This is the schema of the content type, it is not the same as the layout.
-     */
-    schema?: Contracts.ContentTypes.ContentType | undefined;
-    validate: (document: Document) => null | Record<string, MessageDescriptor & {
-        values?: Record<string, PrimitiveType>;
-    }>;
-    collectionType: string;
-    model: string;
-    id: string | undefined;
-};
-export { useDocument, useDoc };
-export type { UseDocument, UseDocumentArgs, Document, Schema, ComponentsDictionary };

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

@@ -1,102 +0,0 @@
-import { SerializedError } from '@reduxjs/toolkit';
-import { TrackingEvent } from '../../features/Tracking';
-import { BaseQueryError } from '../../utils/baseQuery';
-import type { Document } from './useDocument';
-import type { Contracts } from '@strapi/plugin-content-manager/_internal/shared';
-type OperationResponse<TResponse extends {
-    data: any;
-    meta: any;
-    error?: any;
-}> = Pick<TResponse, 'data' | 'meta'> | {
-    error: BaseQueryError | SerializedError;
-};
-type UseDocumentActions = () => {
-    /**
-     * @description Attempts to clone a document based on the provided sourceId.
-     * This will return a list of the fields as an error if it's unable to clone.
-     * You most likely want to use the `clone` action instead.
-     */
-    autoClone: (args: {
-        model: string;
-        sourceId: string;
-    }) => Promise<OperationResponse<Contracts.CollectionTypes.AutoClone.Response>>;
-    clone: (args: {
-        model: string;
-        documentId: string;
-        params?: object;
-    }, document: Omit<Document, 'id'>, trackerProperty?: Extract<TrackingEvent, {
-        name: 'willCreateEntry' | 'didCreateEntry' | 'didNotCreateEntry';
-    }>['properties']) => Promise<OperationResponse<Contracts.CollectionTypes.Clone.Response>>;
-    create: (args: {
-        model: string;
-        params?: object;
-    }, document: Omit<Document, 'id'>, trackerProperty?: Extract<TrackingEvent, {
-        name: 'willCreateEntry' | 'didCreateEntry' | 'didNotCreateEntry';
-    }>['properties']) => Promise<OperationResponse<Contracts.CollectionTypes.Create.Response>>;
-    delete: (args: {
-        collectionType: string;
-        model: string;
-        documentId?: string;
-        params?: object;
-    }, trackerProperty?: Extract<TrackingEvent, {
-        name: 'willDeleteEntry' | 'didDeleteEntry' | 'didNotDeleteEntry';
-    }>['properties']) => Promise<OperationResponse<Contracts.CollectionTypes.Delete.Response>>;
-    discard: (args: {
-        collectionType: string;
-        model: string;
-        documentId?: string;
-        params?: object;
-    }) => Promise<OperationResponse<Contracts.CollectionTypes.Discard.Response>>;
-    getDocument: (args: {
-        collectionType: string;
-        model: string;
-        documentId?: string;
-        params?: object;
-    }) => Promise<Contracts.CollectionTypes.FindOne.Response | undefined>;
-    publish: (args: {
-        collectionType: string;
-        model: string;
-        documentId?: string;
-        params?: object;
-    }, document: Partial<Document>) => Promise<OperationResponse<Contracts.CollectionTypes.Publish.Response>>;
-    update: (args: {
-        collectionType: string;
-        model: string;
-        documentId?: string;
-        params?: object;
-    }, document: Partial<Document>, trackerProperty?: Extract<TrackingEvent, {
-        name: 'willEditEntry' | 'didEditEntry' | 'didNotEditEntry';
-    }>['properties']) => Promise<OperationResponse<Contracts.CollectionTypes.Update.Response>>;
-    unpublish: (args: {
-        collectionType: string;
-        model: string;
-        documentId?: string;
-        params?: object;
-    }, discardDraft?: boolean) => Promise<OperationResponse<Contracts.CollectionTypes.Unpublish.Response>>;
-};
-/**
- * @alpha
- * @public
- * @description Contains all the operations that can be performed on a single document.
- * Designed to be able to be used anywhere within a Strapi app. The hooks will handle
- * notifications should the operation fail, however the response is always returned incase
- * the user needs to handle side-effects.
- * @example
- * ```tsx
- * import { Form } from '@strapi/admin/admin';
- *
- * const { id, model, collectionType } = useParams<{ id: string; model: string; collectionType: string }>();
- * const { update } = useDocumentActions();
- *
- * const handleSubmit = async (data) => {
- *  await update({ collectionType, model, documentId: id }, data);
- * }
- *
- * return <Form method="PUT" onSubmit={handleSubmit} />
- * ```
- *
- * @see {@link https://contributor.strapi.io/docs/core/content-manager/hooks/use-document-operations} for more information
- */
-declare const useDocumentActions: UseDocumentActions;
-export { useDocumentActions };
-export type { UseDocumentActions, OperationResponse };