@strapi/content-manager 0.0.0-experimental.008123965da692a55d02a1df63facc54077c6bde

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

@@ -0,0 +1,125 @@
+import { SerializedError } from '@reduxjs/toolkit';
+import { type TrackingEvent } from '@strapi/admin/strapi-admin';
+import { BaseQueryError } from '../utils/api';
+import type { Document } from './useDocument';
+import type { AutoClone, Clone, Create, Delete, BulkDelete, Discard, FindOne, Publish, BulkPublish, Update, Unpublish, BulkUnpublish } from '../../../shared/contracts/collection-types';
+type OperationResponse<TResponse extends {
+    data: any;
+    meta?: any;
+    error?: any;
+}> = Pick<TResponse, 'data'> | Pick<TResponse, 'data' | 'meta'> | {
+    error: BaseQueryError | SerializedError;
+};
+type BulkOperationResponse<TResponse extends {
+    data: any;
+    error?: any;
+}> = Pick<TResponse, 'data'> | {
+    error: BaseQueryError | SerializedError;
+};
+type UseDocumentActions = (fromPreview?: boolean, fromRelationModal?: boolean) => {
+    /**
+     * @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.
+     */
+    isLoading: boolean;
+    autoClone: (args: {
+        model: string;
+        sourceId: string;
+        locale?: string;
+    }) => Promise<OperationResponse<AutoClone.Response>>;
+    clone: (args: {
+        model: string;
+        documentId: string;
+        params?: object;
+    }, document: Omit<Document, 'id'>, trackerProperty?: Extract<TrackingEvent, {
+        name: 'willCreateEntry' | 'didCreateEntry' | 'didNotCreateEntry';
+    }>['properties']) => Promise<OperationResponse<Clone.Response>>;
+    create: (args: {
+        model: string;
+        params?: object;
+    }, document: Omit<Document, 'id'>, trackerProperty?: Extract<TrackingEvent, {
+        name: 'willCreateEntry' | 'didCreateEntry' | 'didNotCreateEntry';
+    }>['properties']) => Promise<OperationResponse<Create.Response>>;
+    delete: (args: {
+        collectionType: string;
+        model: string;
+        documentId?: string;
+        params?: object;
+    }, trackerProperty?: Extract<TrackingEvent, {
+        name: 'willDeleteEntry' | 'didDeleteEntry' | 'didNotDeleteEntry';
+    }>['properties']) => Promise<OperationResponse<Delete.Response>>;
+    deleteMany: (args: {
+        model: string;
+        documentIds: string[];
+        params?: object;
+    }) => Promise<BulkOperationResponse<BulkDelete.Response>>;
+    discard: (args: {
+        collectionType: string;
+        model: string;
+        documentId?: string;
+        params?: object;
+    }) => Promise<OperationResponse<Discard.Response>>;
+    getDocument: (args: {
+        collectionType: string;
+        model: string;
+        documentId?: string;
+        params?: object;
+    }) => Promise<FindOne.Response | undefined>;
+    publish: (args: {
+        collectionType: string;
+        model: string;
+        documentId?: string;
+        params?: object;
+    }, document: Partial<Document>) => Promise<OperationResponse<Publish.Response>>;
+    publishMany: (args: {
+        model: string;
+        documentIds: string[];
+        params?: object;
+    }) => Promise<BulkOperationResponse<BulkPublish.Response>>;
+    update: (args: {
+        collectionType: string;
+        model: string;
+        documentId?: string;
+        params?: object;
+    }, document: Partial<Document>, trackerProperty?: Extract<TrackingEvent, {
+        name: 'willEditEntry' | 'didEditEntry' | 'didNotEditEntry';
+    }>['properties']) => Promise<OperationResponse<Update.Response>>;
+    unpublish: (args: {
+        collectionType: string;
+        model: string;
+        documentId?: string;
+        params?: object;
+    }, discardDraft?: boolean) => Promise<OperationResponse<Unpublish.Response>>;
+    unpublishMany: (args: {
+        model: string;
+        documentIds: string[];
+        params?: object;
+    }) => Promise<BulkOperationResponse<BulkUnpublish.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 };

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

@@ -0,0 +1,30 @@
+import { type UseDocument } from '../hooks/useDocument';
+interface DocumentMeta {
+    /**
+     * The equivalent of the ":id" url param value
+     * i.e. gus5a67jcboa3o2zjnz39mb1
+     */
+    documentId?: string;
+    /**
+     * The equivalent of the url ":slug" param value
+     * i.e. api::articles.article
+     */
+    model: string;
+    /**
+     * The equivalent of the url ":collectionType" param value
+     * i.e. collection-types or single-types
+     */
+    collectionType: string;
+    /**
+     * Query params object
+     * i.e. { locale: 'fr' }
+     */
+    params?: Record<string, string | string[] | null>;
+}
+interface DocumentContextValue {
+    currentDocumentMeta: DocumentMeta;
+    currentDocument: ReturnType<UseDocument>;
+}
+declare function useDocumentContext(consumerName: string): DocumentContextValue;
+export { useDocumentContext };
+export type { DocumentMeta };

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

@@ -0,0 +1,137 @@
+import { SerializedError } from '@reduxjs/toolkit';
+import { BaseQueryError } from '../utils/api';
+import { type ComponentsDictionary, type Document, type Schema } from './useDocument';
+import type { ComponentConfiguration } from '../../../shared/contracts/components';
+import type { Metadatas, FindContentTypeConfiguration, Settings } from '../../../shared/contracts/content-types';
+import type { Filters, InputProps, Table } from '@strapi/admin/strapi-admin';
+import type { Schema as SchemaUtils } from '@strapi/types';
+type LayoutOptions = Schema['options'] & Schema['pluginOptions'] & object;
+interface LayoutSettings extends Settings {
+    displayName?: string;
+    icon?: never;
+}
+interface ListFieldLayout extends Table.Header<Document, ListFieldLayout>, Pick<Filters.Filter, 'mainField'> {
+    attribute: SchemaUtils.Attribute.AnyAttribute | {
+        type: 'custom';
+    };
+}
+interface ListLayout {
+    layout: ListFieldLayout[];
+    components?: never;
+    metadatas: {
+        [K in keyof Metadatas]: Metadatas[K]['list'];
+    };
+    options: LayoutOptions;
+    settings: LayoutSettings;
+}
+interface EditFieldSharedProps extends Omit<InputProps, 'hint' | 'label' | 'type'>, Pick<Filters.Filter, 'mainField'> {
+    hint?: string;
+    label: string;
+    size: number;
+    unique?: boolean;
+    visible?: boolean;
+}
+/**
+ * Map over all the types in Attribute Types and use that to create a union of new types where the attribute type
+ * is under the property attribute and the type is under the property type.
+ */
+type EditFieldLayout = {
+    [K in SchemaUtils.Attribute.Kind]: EditFieldSharedProps & {
+        attribute: Extract<SchemaUtils.Attribute.AnyAttribute, {
+            type: K;
+        }>;
+        type: K;
+    };
+}[SchemaUtils.Attribute.Kind];
+interface EditLayout {
+    layout: Array<Array<EditFieldLayout[]>>;
+    components: {
+        [uid: string]: {
+            layout: Array<EditFieldLayout[]>;
+            settings: ComponentConfiguration['settings'] & {
+                displayName?: string;
+                icon?: string;
+            };
+        };
+    };
+    metadatas: {
+        [K in keyof Metadatas]: Metadatas[K]['edit'];
+    };
+    options: LayoutOptions;
+    settings: LayoutSettings;
+}
+type UseDocumentLayout = (model: string) => {
+    error?: BaseQueryError | SerializedError;
+    isLoading: boolean;
+    /**
+     * This is the layout for the edit view,
+     */
+    edit: EditLayout;
+    list: ListLayout;
+};
+declare const DEFAULT_SETTINGS: {
+    bulkable: boolean;
+    filterable: boolean;
+    searchable: boolean;
+    pagination: boolean;
+    defaultSortBy: string;
+    defaultSortOrder: string;
+    mainField: string;
+    pageSize: number;
+};
+/**
+ * @alpha
+ * @description This hook is used to get the layouts for either the edit view or list view of a specific content-type
+ * including the layouts for the components used in the content-type. It also runs the mutation hook waterfall so the data
+ * is consistent wherever it is used. It's a light wrapper around the `useDocument` hook, but provides the `skip` option a document
+ * is not fetched, however, it does fetch the schemas & components if they do not already exist in the cache.
+ *
+ * If the fetch fails, it will display a notification to the user.
+ *
+ * @example
+ * ```tsx
+ * const { model } = useParams<{ model: string }>();
+ * const { edit: { schema: layout } } = useDocumentLayout(model);
+ *
+ * return layout.map(panel => panel.map(row => row.map(field => <Field.Root {...field} />)))
+ * ```
+ *
+ */
+declare const useDocumentLayout: UseDocumentLayout;
+/**
+ * @internal this hook uses the internal useDoc hook, as such it shouldn't be used outside of the
+ * content-manager because it won't work as intended.
+ */
+declare const useDocLayout: () => {
+    error?: SerializedError | BaseQueryError | undefined;
+    isLoading: boolean;
+    /**
+     * This is the layout for the edit view,
+     */
+    edit: EditLayout;
+    list: ListLayout;
+};
+type LayoutData = FindContentTypeConfiguration.Response['data'];
+/**
+ * @internal
+ * @description takes the edit layout from either a content-type or a component
+ * and formats it into a generic object that can be used to correctly render
+ * the form fields.
+ */
+declare const convertEditLayoutToFieldLayouts: (rows: LayoutData['contentType']['layouts']['edit'], attributes: import("@strapi/types/dist/struct").SchemaAttributes | undefined, metadatas: Metadatas, components?: {
+    configurations: Record<string, ComponentConfiguration>;
+    schemas: ComponentsDictionary;
+}, schemas?: Schema[]) => EditFieldLayout[][];
+/**
+ * @internal
+ * @description takes the columns from the list view configuration and formats them into a generic object
+ * combinining metadata and attribute data.
+ *
+ * @note We do use this to reformat the list of strings when updating the displayed headers for the list view.
+ */
+declare const convertListLayoutToFieldLayouts: (columns: LayoutData['contentType']['layouts']['list'], attributes: import("@strapi/types/dist/struct").SchemaAttributes | undefined, metadatas: ListLayout['metadatas'], components?: {
+    configurations: Record<string, ComponentConfiguration>;
+    schemas: ComponentsDictionary;
+}, schemas?: Schema[]) => ListFieldLayout[];
+export { useDocLayout, useDocumentLayout, convertListLayoutToFieldLayouts, convertEditLayoutToFieldLayouts, DEFAULT_SETTINGS, };
+export type { EditLayout, EditFieldLayout, ListLayout, ListFieldLayout, UseDocumentLayout };

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

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

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

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

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

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

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

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export declare const useOnce: (effect: React.EffectCallback) => void;

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

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

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

@@ -0,0 +1,18 @@
+import 'prismjs';
+declare const _default: {
+    register(app: any): void;
+    bootstrap(app: any): void;
+    registerTrads({ locales }: {
+        locales: string[];
+    }): Promise<({
+        data: {
+            [x: string]: string;
+        };
+        locale: string;
+    } | {
+        data: {};
+        locale: string;
+    })[]>;
+};
+export default _default;
+export * from './exports';

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

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

package/dist/admin/src/modules/app.d.ts

@@ -0,0 +1,20 @@
+import { GetInitData } from '../../../shared/contracts/init';
+import type { ContentManagerLink } from '../hooks/useContentManagerInitData';
+interface AppState {
+    collectionTypeLinks: ContentManagerLink[];
+    components: GetInitData.Response['data']['components'];
+    fieldSizes: GetInitData.Response['data']['fieldSizes'];
+    models: GetInitData.Response['data']['contentTypes'];
+    singleTypeLinks: ContentManagerLink[];
+    isLoading: boolean;
+}
+declare const reducer: import("redux").Reducer<AppState>;
+declare const setInitialData: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    authorizedCollectionTypeLinks: AppState['collectionTypeLinks'];
+    authorizedSingleTypeLinks: AppState['singleTypeLinks'];
+    components: AppState['components'];
+    contentTypeSchemas: AppState['models'];
+    fieldSizes: AppState['fieldSizes'];
+}, "app/setInitialData">;
+export { reducer, setInitialData };
+export type { AppState };

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

@@ -0,0 +1,10 @@
+import { Dispatch } from '@reduxjs/toolkit';
+import { TypedUseSelectorHook } from 'react-redux';
+import { State } from './reducers';
+import type { Store } from '@strapi/admin/strapi-admin';
+type RootState = ReturnType<Store['getState']> & {
+    ['content-manager']: State;
+};
+declare const useTypedDispatch: () => Dispatch;
+declare const useTypedSelector: TypedUseSelectorHook<RootState>;
+export { useTypedSelector, useTypedDispatch };

package/dist/admin/src/modules/reducers.d.ts

@@ -0,0 +1,6 @@
+declare const reducer: import("redux").Reducer<import("redux").CombinedState<{
+    app: import("./app").AppState;
+}>, import("redux").AnyAction>;
+type State = ReturnType<typeof reducer>;
+export { reducer };
+export type { State };

package/dist/admin/src/pages/ComponentConfigurationPage.d.ts

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

package/dist/admin/src/pages/EditConfigurationPage.d.ts

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

package/dist/admin/src/pages/EditView/EditViewPage.d.ts

@@ -0,0 +1,11 @@
+import { type UseDocument } from '../../hooks/useDocument';
+declare const EditViewPage: () => import("react/jsx-runtime").JSX.Element;
+/**
+ * @internal
+ * @description Returns the status of the document where its latest state takes priority,
+ * this typically will be "published" unless a user has edited their draft in which we should
+ * display "modified".
+ */
+declare const getDocumentStatus: (document: ReturnType<UseDocument>['document'], meta: ReturnType<UseDocument>['meta']) => 'draft' | 'published' | 'modified';
+declare const ProtectedEditViewPage: () => import("react/jsx-runtime").JSX.Element;
+export { EditViewPage, ProtectedEditViewPage, getDocumentStatus };

package/dist/admin/src/pages/EditView/components/DocumentActions.d.ts

@@ -0,0 +1,77 @@
+import * as React from 'react';
+import { NotificationConfig } from '@strapi/admin/strapi-admin';
+import { ButtonProps } from '@strapi/design-system';
+import type { DocumentActionComponent } from '../../../content-manager';
+type DocumentActionPosition = 'panel' | 'header' | 'table-row' | 'preview' | 'relation-modal';
+interface DocumentActionDescription {
+    label: string;
+    onClick?: (event: React.SyntheticEvent) => Promise<boolean | void> | boolean | void;
+    icon?: React.ReactNode;
+    /**
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * @default 'panel'
+     * @description Where the action should be rendered.
+     */
+    position?: DocumentActionPosition | DocumentActionPosition[];
+    dialog?: DialogOptions | NotificationOptions | ModalOptions;
+    /**
+     * @default 'secondary'
+     */
+    variant?: ButtonProps['variant'];
+    loading?: ButtonProps['loading'];
+}
+interface DialogOptions {
+    type: 'dialog';
+    title: string;
+    content?: React.ReactNode;
+    variant?: ButtonProps['variant'];
+    onConfirm?: () => void | Promise<void>;
+    onCancel?: () => void | Promise<void>;
+}
+interface NotificationOptions {
+    type: 'notification';
+    title: string;
+    link?: {
+        label: string;
+        url: string;
+        target?: string;
+    };
+    content?: string;
+    onClose?: () => void;
+    status?: NotificationConfig['type'];
+    timeout?: number;
+}
+interface ModalOptions {
+    type: 'modal';
+    title: string;
+    content: React.ComponentType<{
+        onClose: () => void;
+    }> | React.ReactNode;
+    footer?: React.ComponentType<{
+        onClose: () => void;
+    }> | React.ReactNode;
+    onClose?: () => void;
+}
+interface Action extends DocumentActionDescription {
+    id: string;
+}
+interface DocumentActionsProps {
+    actions: Action[];
+}
+declare const DocumentActions: ({ actions }: DocumentActionsProps) => import("react/jsx-runtime").JSX.Element | null;
+interface DocumentActionButtonProps extends Action {
+}
+declare const DocumentActionButton: (action: DocumentActionButtonProps) => import("react/jsx-runtime").JSX.Element;
+interface DocumentActionsMenuProps {
+    actions: Action[];
+    children?: React.ReactNode;
+    label?: string;
+    variant?: 'ghost' | 'tertiary';
+}
+declare const DocumentActionsMenu: ({ actions, children, label, variant, }: DocumentActionsMenuProps) => import("react/jsx-runtime").JSX.Element;
+declare const DEFAULT_ACTIONS: DocumentActionComponent[];
+export { DocumentActions, DocumentActionsMenu, DocumentActionButton, DEFAULT_ACTIONS };
+export type { DocumentActionDescription, DocumentActionPosition, DialogOptions, NotificationOptions, ModalOptions, };

package/dist/admin/src/pages/EditView/components/DocumentStatus.d.ts

@@ -0,0 +1,16 @@
+import { StatusProps } from '@strapi/design-system';
+interface DocumentStatusProps extends Omit<StatusProps, 'children' | 'variant'> {
+    /**
+     * The status of the document (draft, published, etc.)
+     * @default 'draft'
+     */
+    status?: string;
+}
+/**
+ * @public
+ * @description Displays the status of a document (draft, published, etc.)
+ * and automatically calculates the appropriate variant for the status.
+ */
+declare const DocumentStatus: ({ status, size, ...restProps }: DocumentStatusProps) => import("react/jsx-runtime").JSX.Element;
+export { DocumentStatus };
+export type { DocumentStatusProps };

package/dist/admin/src/pages/EditView/components/EditorToolbarObserver.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { Menu } from '@strapi/design-system';
+export interface ObservedComponent {
+    toolbar: React.ReactNode;
+    menu: React.ReactNode;
+    key: string;
+}
+export declare const EditorToolbarObserver: ({ observedComponents, menuTriggerVariant, }: {
+    observedComponents: ObservedComponent[];
+    menuTriggerVariant?: Menu.TriggerProps['variant'];
+}) => import("react/jsx-runtime").JSX.Element[];

package/dist/admin/src/pages/EditView/components/FormInputs/BlocksInput/Blocks/Code.d.ts

@@ -0,0 +1,58 @@
+import { BaseRange, NodeEntry } from 'slate';
+import { type BlocksStore } from '../BlocksEditor';
+import 'prismjs/themes/prism-solarizedlight.css';
+import 'prismjs/components/prism-asmatmel';
+import 'prismjs/components/prism-bash';
+import 'prismjs/components/prism-basic';
+import 'prismjs/components/prism-c';
+import 'prismjs/components/prism-clojure';
+import 'prismjs/components/prism-cobol';
+import 'prismjs/components/prism-cpp';
+import 'prismjs/components/prism-csharp';
+import 'prismjs/components/prism-dart';
+import 'prismjs/components/prism-docker';
+import 'prismjs/components/prism-elixir';
+import 'prismjs/components/prism-erlang';
+import 'prismjs/components/prism-fortran';
+import 'prismjs/components/prism-fsharp';
+import 'prismjs/components/prism-go';
+import 'prismjs/components/prism-graphql';
+import 'prismjs/components/prism-groovy';
+import 'prismjs/components/prism-haskell';
+import 'prismjs/components/prism-haxe';
+import 'prismjs/components/prism-ini';
+import 'prismjs/components/prism-java';
+import 'prismjs/components/prism-javascript';
+import 'prismjs/components/prism-jsx';
+import 'prismjs/components/prism-json';
+import 'prismjs/components/prism-julia';
+import 'prismjs/components/prism-kotlin';
+import 'prismjs/components/prism-latex';
+import 'prismjs/components/prism-lua';
+import 'prismjs/components/prism-markdown';
+import 'prismjs/components/prism-matlab';
+import 'prismjs/components/prism-makefile';
+import 'prismjs/components/prism-objectivec';
+import 'prismjs/components/prism-perl';
+import 'prismjs/components/prism-php';
+import 'prismjs/components/prism-powershell';
+import 'prismjs/components/prism-python';
+import 'prismjs/components/prism-r';
+import 'prismjs/components/prism-ruby';
+import 'prismjs/components/prism-rust';
+import 'prismjs/components/prism-sas';
+import 'prismjs/components/prism-scala';
+import 'prismjs/components/prism-scheme';
+import 'prismjs/components/prism-sql';
+import 'prismjs/components/prism-stata';
+import 'prismjs/components/prism-swift';
+import 'prismjs/components/prism-typescript';
+import 'prismjs/components/prism-tsx';
+import 'prismjs/components/prism-vbnet';
+import 'prismjs/components/prism-yaml';
+type BaseRangeCustom = BaseRange & {
+    className: string;
+};
+export declare const decorateCode: ([node, path]: NodeEntry) => BaseRangeCustom[];
+declare const codeBlocks: Pick<BlocksStore, 'code'>;
+export { codeBlocks };

package/dist/admin/src/pages/EditView/components/FormInputs/BlocksInput/Blocks/Heading.d.ts

@@ -0,0 +1,3 @@
+import { type BlocksStore } from '../BlocksEditor';
+declare const headingBlocks: Pick<BlocksStore, 'heading-one' | 'heading-two' | 'heading-three' | 'heading-four' | 'heading-five' | 'heading-six'>;
+export { headingBlocks };

package/dist/admin/src/pages/EditView/components/FormInputs/BlocksInput/Blocks/Image.d.ts

@@ -0,0 +1,3 @@
+import { type BlocksStore } from '../BlocksEditor';
+declare const imageBlocks: Pick<BlocksStore, 'image'>;
+export { imageBlocks };

package/dist/admin/src/pages/EditView/components/FormInputs/BlocksInput/Blocks/Link.d.ts

@@ -0,0 +1,3 @@
+import { type BlocksStore } from '../BlocksEditor';
+declare const linkBlocks: Pick<BlocksStore, 'link'>;
+export { linkBlocks };

package/dist/admin/src/pages/EditView/components/FormInputs/BlocksInput/Blocks/List.d.ts

@@ -0,0 +1,3 @@
+import { type BlocksStore } from '../BlocksEditor';
+declare const listBlocks: Pick<BlocksStore, 'list-ordered' | 'list-unordered' | 'list-item'>;
+export { listBlocks };

package/dist/admin/src/pages/EditView/components/FormInputs/BlocksInput/Blocks/Paragraph.d.ts

@@ -0,0 +1,3 @@
+import { type BlocksStore } from '../BlocksEditor';
+declare const paragraphBlocks: Pick<BlocksStore, 'paragraph'>;
+export { paragraphBlocks };