@strapi/upload 5.59.0 → 5.61.0

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

@@ -0,0 +1,21 @@
+import { type DragEvent, type ReactNode } from 'react';
+import { type AllowedMediaType } from '../../utils/allowedMediaTypes';
+import type { File } from '../../../../shared/contracts/files';
+export interface EditorFileDropZoneProps {
+    children: ReactNode;
+    disabled?: boolean;
+    allowedTypes?: AllowedMediaType[];
+    /**
+     * Called once per accepted drop, while the drop event is still current. It
+     * returns what receives each of that drop's files once uploaded, including
+     * files a Retry in the progress dialog uploads later.
+     */
+    onDropFiles: (event: DragEvent<HTMLElement>) => (file: File) => void;
+}
+/**
+ * Lets an editor take files dropped onto it: they upload to the root of the
+ * Media Library, through the global upload progress dialog, and are handed
+ * back to the editor one by one. Drags that carry no file, such as an editor
+ * reordering its own blocks, pass through untouched.
+ */
+export declare const EditorFileDropZone: ({ children, disabled, allowedTypes, onDropFiles, }: EditorFileDropZoneProps) => import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/MediaLibraryInput/AddAssetMenu.d.ts

@@ -1,5 +1,11 @@
 interface AddAssetMenuProps {
     disabled?: boolean;
+    /**
+     * Ignore requests to open, without looking disabled. The press still reaches
+     * whatever listens for presses outside it, so an open drawer closes — or asks
+     * about unsaved edits — instead of having the menu stacked over it.
+     */
+    preventOpen?: boolean;
     onBrowseLibrary: () => void;
     onUploadFromDevice: () => void;
     onUploadFromUrl: () => void;
@@ -15,5 +21,5 @@ interface AddAssetMenuProps {
  * The drop zone below keeps working whatever this shows — it is a second way
  * in, not the only one.
  */
-export declare const AddAssetMenu: ({ disabled, onBrowseLibrary, onUploadFromDevice, onUploadFromUrl, }: AddAssetMenuProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const AddAssetMenu: ({ disabled, preventOpen, onBrowseLibrary, onUploadFromDevice, onUploadFromUrl, }: AddAssetMenuProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/admin/src/components/MediaLibraryInput/AssetCard.d.ts

@@ -0,0 +1,25 @@
+import type { FieldUpload } from './useFieldUploads';
+import type { File } from '../../../../shared/contracts/files';
+interface AssetCardProps {
+    asset: File;
+    disabled?: boolean;
+    onCopyLink: (asset: File) => void;
+    onEdit?: (asset: File) => void;
+    onRemove: (asset: File) => void;
+}
+/**
+ * An asset a multiple-value field holds.
+ */
+export declare const AssetCard: ({ asset, disabled, onCopyLink, onEdit, onRemove, }: AssetCardProps) => import("react/jsx-runtime").JSX.Element;
+interface UploadCardProps {
+    upload: FieldUpload;
+    disabled?: boolean;
+    onCancel: (upload: FieldUpload) => void;
+    onRetry: (upload: FieldUpload) => void;
+    onRemove: (upload: FieldUpload) => void;
+}
+/**
+ * A file a multiple-value field is uploading, or failed to upload.
+ */
+export declare const UploadCard: ({ upload, disabled, onCancel, onRetry, onRemove, }: UploadCardProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/components/MediaLibraryInput/AssetCarousel.d.ts

@@ -0,0 +1,16 @@
+import { type ReactNode } from 'react';
+import type { ZoneVariant } from './AssetDropZone';
+interface AssetCarouselProps {
+    /** One card per asset or upload, in field order. */
+    children: ReactNode;
+    /** Always shown: after the cards, or below them on a narrow field. */
+    renderDropZone: (variant: Exclude<ZoneVariant, 'bar'>) => ReactNode;
+    /** The field's width in the edit layout, out of 12, when the host knows it. */
+    layoutSize?: number;
+}
+/**
+ * A single row of cards followed by the drop tile. When the field holds more
+ * than fit, arrows page through the cards and the tile stays put.
+ */
+export declare const AssetCarousel: ({ children, renderDropZone, layoutSize }: AssetCarouselProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/components/MediaLibraryInput/AssetDropZone.d.ts

@@ -1,13 +1,21 @@
+/**
+ * `bar` on an empty field, `tile` after a multiple field's cards, `stacked`
+ * below them when the field is too narrow for both on one row.
+ */
+export type ZoneVariant = 'bar' | 'tile' | 'stacked';
 interface AssetDropZoneProps {
+    variant?: ZoneVariant;
     disabled?: boolean;
-    onClick: () => void;
     onDropFiles: (files: globalThis.File[]) => void;
 }
 /**
- * The field's own drop target. Deliberately not the Media Library page's
+ * The field's own drop target. It only takes drops: browsing and picking files
+ * go through the "Add asset" menu, so the field has one way in, not two.
+ *
+ * Deliberately not the Media Library page's
  * `UploadDropZoneProvider`: that one covers a whole route and paints a
  * full-surface overlay, where this has to stay inside one field on a form that
  * may hold several of them.
  */
-export declare const AssetDropZone: ({ disabled, onClick, onDropFiles }: AssetDropZoneProps) => import("react/jsx-runtime").JSX.Element;
+export declare const AssetDropZone: ({ variant, disabled, onDropFiles, }: AssetDropZoneProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/admin/src/components/MediaLibraryInput/AssetPreview.d.ts

@@ -0,0 +1,17 @@
+import type { File } from '../../../../shared/contracts/files';
+type PreviewSize = 'S' | 'L';
+interface AssetPreviewProps {
+    asset: File;
+    size: PreviewSize;
+}
+export declare const AssetPreview: ({ asset, size }: AssetPreviewProps) => import("react/jsx-runtime").JSX.Element;
+interface UploadPreviewProps {
+    file?: globalThis.File;
+    size: PreviewSize;
+}
+/**
+ * Previews a file that has not reached the server yet, straight from the
+ * user's disk.
+ */
+export declare const UploadPreview: ({ file, size }: UploadPreviewProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/components/MediaLibraryInput/AssetRow.d.ts

@@ -1,3 +1,4 @@
+import type { FieldUpload } from './useFieldUploads';
 import type { File } from '../../../../shared/contracts/files';
 interface AssetRowProps {
     asset: File;
@@ -7,9 +8,18 @@ interface AssetRowProps {
     onRemove: (asset: File) => void;
 }
 /**
- * One asset already held by the field. The uploading and failed variants the
- * design also specifies are not here yet — while an upload runs, the global
- * progress dialog is what reports it.
+ * The asset a single-value field holds.
  */
 export declare const AssetRow: ({ asset, disabled, onCopyLink, onEdit, onRemove, }: AssetRowProps) => import("react/jsx-runtime").JSX.Element;
+interface UploadRowProps {
+    upload: FieldUpload;
+    disabled?: boolean;
+    onCancel: (upload: FieldUpload) => void;
+    onRetry: (upload: FieldUpload) => void;
+    onRemove: (upload: FieldUpload) => void;
+}
+/**
+ * A file a single-value field is uploading, or failed to upload.
+ */
+export declare const UploadRow: ({ upload, disabled, onCancel, onRetry, onRemove, }: UploadRowProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/admin/src/components/MediaLibraryInput/FieldControls.d.ts

@@ -0,0 +1,19 @@
+import { Menu } from '@strapi/design-system';
+/**
+ * A ghost `IconButton` that stays a bare icon when disabled. The design system
+ * paints every disabled button, ghost included, as a bordered grey plate.
+ */
+export declare const GhostIconButton: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<Omit<Omit<import("@strapi/design-system").IconButtonProps<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>>, "ref"> & import("react").RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<unknown> | null | undefined;
+}, string | number | symbol> & Omit<Omit<import("@strapi/design-system").IconButtonProps<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>>, "ref"> & import("react").RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<unknown> | null | undefined;
+}, "variant"> & Partial<Pick<import("styled-components").FastOmit<Omit<Omit<import("@strapi/design-system").IconButtonProps<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>>, "ref"> & import("react").RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<unknown> | null | undefined;
+}, string | number | symbol> & Omit<Omit<import("@strapi/design-system").IconButtonProps<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>>, "ref"> & import("react").RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<unknown> | null | undefined;
+}, "variant">>> & string & Omit<(<C extends React.ElementType<any, keyof React.JSX.IntrinsicElements> = "button">(props: React.PropsWithoutRef<import("@strapi/design-system").IconButtonProps<C>> & React.RefAttributes<unknown>) => React.ReactNode), keyof import("react").Component<any, {}, any>>;
+/**
+ * A `Menu.Item` whose label greys out with its icon when disabled. The design
+ * system computes a disabled text colour, then its own stylesheet overrides it.
+ */
+export declare const FieldMenuItem: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<Menu.ItemProps<(props: Omit<import("@strapi/design-system").BaseLinkProps<"a">, "ref"> & React.RefAttributes<HTMLAnchorElement>) => React.ReactNode> & import("styled-components/dist/types").BaseObject, never> & Partial<Pick<Menu.ItemProps<(props: Omit<import("@strapi/design-system").BaseLinkProps<"a">, "ref"> & React.RefAttributes<HTMLAnchorElement>) => React.ReactNode> & import("styled-components/dist/types").BaseObject, never>>> & string & Omit<({ onSelect, disabled, isLink, startIcon, endIcon, isExternal, variant, ...props }: Menu.ItemProps) => import("react/jsx-runtime").JSX.Element, keyof import("react").Component<any, {}, any>>;

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

@@ -11,6 +11,8 @@ export interface MediaLibraryInputProps {
         allowedTypes?: AllowedMediaType[] | null;
         multiple?: boolean;
     };
+    /** The field's width in the edit layout, out of 12. Set by the Content Manager. */
+    layoutSize?: number;
 }
 /**
  * The Content Manager's `media` field, on the current Media Library stack.
@@ -23,4 +25,4 @@ export interface MediaLibraryInputProps {
  * The legacy input is still registered when `useLegacyMediaLibrary` is on, and
  * is untouched by this.
  */
-export declare const MediaLibraryInput: ({ name, label, labelAction, hint, required, disabled, attribute, }: MediaLibraryInputProps) => import("react/jsx-runtime").JSX.Element;
+export declare const MediaLibraryInput: ({ name, label, labelAction, hint, required, disabled, attribute, layoutSize, }: MediaLibraryInputProps) => import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/MediaLibraryInput/UploadProgressBar.d.ts

@@ -0,0 +1,7 @@
+interface UploadProgressBarProps {
+    /** 0–100, or `null` for an upload whose size is not known. */
+    progress: number | null;
+    label: string;
+}
+export declare const UploadProgressBar: ({ progress, label }: UploadProgressBarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/components/MediaLibraryInput/openAssetDetails.d.ts

@@ -0,0 +1,10 @@
+/** Read at event time, so a handler never acts on a stale render. */
+export declare const isAnyAssetDetailsOpen: () => boolean;
+/**
+ * Registers this field's drawer while `isOpen`, and returns whether any field —
+ * this one included — has one open.
+ *
+ * A layout effect, not a plain one: the drawer that a press closes must be gone
+ * from the set before that press's click reaches the next field.
+ */
+export declare const useOpenAssetDetails: (isOpen: boolean) => boolean;

package/dist/admin/src/components/MediaLibraryInput/useFieldUploads.d.ts

@@ -0,0 +1,31 @@
+export interface FieldUpload {
+    key: string;
+    uploadId: number;
+    index: number;
+    name: string;
+    status: 'uploading' | 'failed';
+    /** 0–100, or `null` while the size is unknown. */
+    progress: number | null;
+    /** The file the user picked, for the preview. Gone once the page reloads. */
+    sourceFile?: globalThis.File;
+    /** Whether the progress store still holds the row, i.e. it can be retried in place. */
+    isInStore: boolean;
+}
+/**
+ * The uploads a field started, read from the shared progress store so the field
+ * and the progress dialog always agree.
+ *
+ * The store only holds the latest batch, and closing the dialog empties it. Rows
+ * are therefore remembered here once seen: a failed upload stays on the field
+ * until the user retries or removes it, whatever happened to the dialog. A row
+ * that vanished while still in flight was cancelled along with its batch.
+ *
+ * Completed rows leave the list. Attaching them to the field is the upload's
+ * `onFileUploaded`, which outlives the input.
+ */
+export declare const useFieldUploads: (owner: string) => {
+    uploads: FieldUpload[];
+    cancel: ({ uploadId, index }: FieldUpload) => void;
+    retry: (upload: FieldUpload, reupload: (file: globalThis.File) => void) => Promise<void>;
+    dismiss: (key: string) => void;
+};

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

@@ -6,6 +6,8 @@
  * hook is what keeps the UI honest so users don't discover a missing
  * permission through a 403.
  *
+ * - `canRead` — browse the library (the Content Manager asset picker needs
+ *   nothing more)
  * - `canCreate` — upload (files, from URL) and New folder
  * - `canUpdate` — edit details, replace, crop, move (dnd + bulk), delete
  *   (single + bulk), AI metadata — the `assets.update` action covers

package/dist/admin/src/pages/Assets/components/AssetDetails/AssetDetailsDrawer.d.ts

@@ -15,9 +15,6 @@ interface AssetOperations {
 export declare const AssetOperationsContext: React.Context<AssetOperations | null>;
 export declare const useAssetDetailsParam: () => {
     assetId: number | null;
-    isVisible: boolean;
-    shouldRenderDrawer: boolean;
-    onCloseAnimationEnd: (event: React.AnimationEvent) => void;
     openDetails: (id: number) => void;
     closeDetails: () => void;
 };
@@ -40,7 +37,46 @@ export declare const getBusyMessage: (state: {
 interface AssetDetailsProps {
     asset: AssetWithPopulatedCreatedBy;
     closeDetails: () => void;
+    /** Receives whether the form has unsaved edits. */
+    hasUnsavedEditsRef?: React.MutableRefObject<boolean>;
+    /** Guard unsaved edits with <Blocker>, for a drawer whose closing is a navigation. */
+    guardNavigation?: boolean;
+    /** After the asset was updated, replaced or cropped in place, with the server's copy. */
+    onAssetChange?: (asset: AssetWithPopulatedCreatedBy) => void;
+    /** After the asset was deleted from the library. */
+    onAssetDelete?: (id: number) => void;
+    /** `location` stamped on the tracking events, for analytics to tell hosts apart. */
+    trackedLocation?: string;
 }
-export declare const AssetDetails: ({ asset, closeDetails }: AssetDetailsProps) => import("react/jsx-runtime").JSX.Element;
-export declare const AssetDetailsDrawer: () => import("react/jsx-runtime").JSX.Element | null;
+export declare const AssetDetails: ({ asset, closeDetails, hasUnsavedEditsRef, guardNavigation, onAssetChange, onAssetDelete, trackedLocation, }: AssetDetailsProps) => import("react/jsx-runtime").JSX.Element;
+interface AssetDetailsDrawerProps {
+    /** The asset to show, or `null` to close the drawer. */
+    assetId: number | null;
+    onClose: () => void;
+    /**
+     * Guard unsaved edits with <Blocker> instead of the drawer's own confirmation.
+     * Only for a drawer whose closing is itself a navigation, which <Blocker> then
+     * covers along with route changes and browser history. Not for a host that
+     * has its own <Blocker>: react-router allows one per page.
+     */
+    guardNavigation?: boolean;
+    /**
+     * After the asset was updated, replaced or cropped in place, with the server's
+     * copy, so a host holding the asset (e.g. a form field) can stay in sync.
+     */
+    onAssetChange?: (asset: AssetWithPopulatedCreatedBy) => void;
+    /** After the asset was deleted from the library, just before the drawer closes. */
+    onAssetDelete?: (id: number) => void;
+    /**
+     * `location` stamped on the tracking events, for analytics to tell hosts
+     * apart. Defaults to the Media Library page's.
+     */
+    trackedLocation?: string;
+}
+export declare const AssetDetailsDrawer: ({ assetId, onClose, guardNavigation, onAssetChange, onAssetDelete, trackedLocation, }: AssetDetailsDrawerProps) => import("react/jsx-runtime").JSX.Element | null;
+/**
+ * The drawer bound to the URL's `?assetId=`, as the Media Library page uses it:
+ * linkable, survives a refresh, and closing is a navigation.
+ */
+export declare const AssetDetailsDrawerFromUrl: () => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/admin/src/pages/Assets/components/AssetsGrid.d.ts

@@ -3,10 +3,12 @@ import type { File } from '../../../../../shared/contracts/files';
 import type { Folder } from '../../../../../shared/contracts/folders';
 interface AssetsGridProps {
     assets: File[];
+    /** Shown in the "Assets (n)" heading; falls back to the loaded count. */
+    assetsTotal?: number;
     folders?: Folder[];
     /** Keys of the rendered items, in render order. Owned by the view. */
     renderedKeys?: ItemKey[];
     onAssetItemClick: (assetId: number) => void;
 }
-export declare const AssetsGrid: ({ assets, folders, renderedKeys, onAssetItemClick, }: AssetsGridProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const AssetsGrid: ({ assets, assetsTotal, folders, renderedKeys, onAssetItemClick, }: AssetsGridProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/admin/src/pages/Assets/components/AssetsSearchInput.d.ts

@@ -1,5 +1,15 @@
+interface AssetsSearchInputProps {
+    /**
+     * Starts as an icon button that opens the field, which folds back once it
+     * loses focus empty, like the admin's own `SearchInput` in list views. Used
+     * where the toolbar is narrow (the Content Manager asset picker). Mobile
+     * always shows the field.
+     */
+    collapsible?: boolean;
+}
 /**
  * Keyword search over the whole Media Library. Owns the typing state and the
  * debounce; `useAssetSearch` owns the `?_q=` URL param.
  */
-export declare const AssetsSearchInput: () => import("react/jsx-runtime").JSX.Element;
+export declare const AssetsSearchInput: ({ collapsible }: AssetsSearchInputProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/pages/Assets/components/AssetsView.d.ts

@@ -0,0 +1,29 @@
+import { type ItemLocations } from '../../../utils/itemLocations';
+import { type FoldersPosition } from '../hooks/useListSort';
+import type { File } from '../../../../../shared/contracts/files';
+import type { Folder } from '../../../../../shared/contracts/folders';
+interface AssetsViewProps {
+    view: number;
+    folders: Folder[];
+    isLoadingFolders: boolean;
+    assets: File[];
+    /** Total matching assets on the server, beyond the pages loaded so far. */
+    assetsTotal?: number;
+    isLoadingAssets: boolean;
+    isFetchingMore: boolean;
+    hasNextPage: boolean;
+    fetchNextPage: () => void;
+    error: unknown;
+    locations: ItemLocations;
+    searchQuery: string;
+    assetsSort: string;
+    foldersPosition: FoldersPosition;
+    hasActiveFilters: boolean;
+    onClearFilters: () => void;
+    onAssetItemClick: (assetId: number) => void;
+    onAddAssets: () => void;
+    canAddAssets: boolean;
+    onClearSearch: () => void;
+}
+export declare const AssetsView: ({ view, folders, isLoadingFolders, assets, assetsTotal, isLoadingAssets, isFetchingMore, hasNextPage, fetchNextPage, error, locations, searchQuery, assetsSort, foldersPosition, hasActiveFilters, onClearFilters, onAssetItemClick, onAddAssets, canAddAssets, onClearSearch, }: AssetsViewProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/pages/Assets/components/Dnd/ReorderHandle.d.ts

@@ -0,0 +1,12 @@
+import { type AssetSortable } from './assetSortable';
+interface ReorderHandleProps {
+    name: string;
+    handle: AssetSortable['handle'];
+}
+/**
+ * The keyboard path into reordering (Space picks the item up, arrows move it,
+ * Space drops it). Pointer drags start from anywhere on the item, this grip
+ * included.
+ */
+export declare const ReorderHandle: ({ name, handle }: ReorderHandleProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/pages/Assets/components/Dnd/assetSortable.d.ts

@@ -0,0 +1,37 @@
+import { type CSSProperties, type KeyboardEvent, type SyntheticEvent } from 'react';
+import type { DraggableAttributes, DraggableSyntheticListeners } from '@dnd-kit/core';
+/**
+ * What a list item needs to take part in reordering: the whole item drags with
+ * the pointer, and a grip button carries the keyboard path (Space to pick up,
+ * arrows to move) so it doesn't collide with the item's own Space/click.
+ */
+export interface AssetSortable {
+    setNodeRef: (node: HTMLElement | null) => void;
+    isDragging: boolean;
+    style: CSSProperties;
+    /** Pointer activation, for the item itself. */
+    listeners: DraggableSyntheticListeners;
+    handle: Partial<DraggableAttributes> & {
+        ref: (node: HTMLElement | null) => void;
+        onKeyDown?: (event: KeyboardEvent) => void;
+    };
+}
+type UseAssetSortable = (assetId: number) => AssetSortable | null;
+/**
+ * Holds the hook that makes an asset sortable, rather than a value: the hook
+ * needs each item's id. A given subtree always gets the same hook, so calling
+ * it from `useAssetSortable` keeps the rules of hooks.
+ */
+export declare const AssetSortableContext: import("react").Context<UseAssetSortable>;
+export declare const useAssetSortable: (assetId: number) => AssetSortable | null;
+/** Marks the reorder grip, so the item can tell its keys apart. */
+export declare const REORDER_HANDLE_PROPS: {
+    "data-reorder-handle": string;
+};
+/**
+ * Keys pressed on the grip, including the arrows and the drop key mid-drag,
+ * belong to reordering. The item must not also read them as its own
+ * Enter/Space.
+ */
+export declare const isFromReorderHandle: (event: SyntheticEvent) => boolean;
+export {};

package/dist/admin/src/pages/Assets/components/Dnd/dndIds.d.ts

@@ -3,5 +3,10 @@ export declare const toFolderDraggableId: (id: number) => `folder:${number}`;
 export declare const toFolderTargetId: (id: number) => `folder-target:${number}`;
 export declare const parseFolderTargetId: (dndId: string | number) => number | null;
 export declare const toFolderTreeTargetId: (id: number) => `folder-tree-target:${number}`;
+/**
+ * The "N parent folders" row in the sidebar. Only there so hovering it during a
+ * drag opens it; no parser recognises it, so a drop on it moves nothing.
+ */
+export declare const toFolderTreeSummaryId: (rootId: number) => `folder-tree-summary:${number}`;
 export declare const HOME_TREE_TARGET_ID: "folder-tree-target:home";
 export declare const parseFolderTreeTargetId: (dndId: string | number) => number | "root" | null;

package/dist/admin/src/pages/Assets/components/Dnd/useAssetDnd.d.ts

@@ -1,3 +1,4 @@
+import { type DraggableAttributes } from '@dnd-kit/core';
 import type { DragFileData, DragFolderData } from '../../../../types/dnd';
 export declare const useFileDraggable: (asset: {
     id: number;
@@ -6,11 +7,31 @@ export declare const useFileDraggable: (asset: {
         id?: number;
     } | null;
 }) => {
+    setNodeRef: (node: HTMLElement | null) => void;
+    isDragging: boolean;
+    listeners: import("@dnd-kit/core").DraggableSyntheticListeners;
+    dragStyle: import("react").CSSProperties;
+    dragHandle: Partial<DraggableAttributes> & {
+        ref: (node: HTMLElement | null) => void;
+        onKeyDown?: (event: import("react").KeyboardEvent) => void;
+    };
+    dragData: DragFileData;
+    active: import("@dnd-kit/core").Active | null;
+    activatorEvent: Event | null;
+    activeNodeRect: import("@dnd-kit/core").ClientRect | null;
+    attributes: DraggableAttributes;
+    node: import("react").MutableRefObject<HTMLElement | null>;
+    over: import("@dnd-kit/core").Over | null;
+    setActivatorNodeRef: (element: HTMLElement | null) => void;
+    transform: import("@dnd-kit/utilities").Transform | null;
+} | {
+    dragStyle: undefined;
+    dragHandle: undefined;
     dragData: DragFileData;
     active: import("@dnd-kit/core").Active | null;
     activatorEvent: Event | null;
     activeNodeRect: import("@dnd-kit/core").ClientRect | null;
-    attributes: import("@dnd-kit/core").DraggableAttributes;
+    attributes: DraggableAttributes;
     isDragging: boolean;
     listeners: import("@dnd-kit/core/dist/hooks/utilities").SyntheticListenerMap | undefined;
     node: import("react").MutableRefObject<HTMLElement | null>;
@@ -31,7 +52,7 @@ export declare const useFolderDraggableDroppable: (folder: {
         active: import("@dnd-kit/core").Active | null;
         activatorEvent: Event | null;
         activeNodeRect: import("@dnd-kit/core").ClientRect | null;
-        attributes: import("@dnd-kit/core").DraggableAttributes;
+        attributes: DraggableAttributes;
         isDragging: boolean;
         listeners: import("@dnd-kit/core/dist/hooks/utilities").SyntheticListenerMap | undefined;
         node: import("react").MutableRefObject<HTMLElement | null>;

package/dist/admin/src/pages/Assets/components/FolderTree/FolderTree.d.ts

@@ -1,4 +1,5 @@
 import { type ReactNode } from 'react';
+export declare const getIndentRem: (level: number) => number;
 interface FolderTreeProps {
     currentFolderId: number | null;
     /**

package/dist/admin/src/pages/Assets/components/FolderTree/collapsedBranch.d.ts

@@ -0,0 +1,21 @@
+import type { FolderNode } from '../../../../../../shared/contracts/folders';
+/**
+ * Depth (0 = a root folder) from which the selected folder's ancestors fold into
+ * a single "N parent folders" row in the sidebar. Picked so the deepest visible
+ * row still has room for a readable name in the 23.2rem rail.
+ */
+export declare const COLLAPSE_FROM_DEPTH = 4;
+export interface CollapsedBranch {
+    root: FolderNode;
+    /** Between `root` and `parent`, shallowest first. */
+    hidden: FolderNode[];
+    /** The selected folder's parent. */
+    parent: FolderNode;
+}
+/**
+ * How the selected folder's branch folds once it is deep enough: the root stays,
+ * everything between the root and the parent is hidden, and the parent stays so
+ * the selected folder is shown alongside its siblings. `null` means the branch
+ * renders in full.
+ */
+export declare const getCollapsedBranch: (nodes: FolderNode[], selectedId: number | null) => CollapsedBranch | null;

package/dist/admin/src/pages/Assets/components/ViewToggle.d.ts

@@ -0,0 +1,8 @@
+interface ViewToggleProps {
+    view: number;
+    onChange: (view: number) => void;
+    /** Drops the visible labels at every width, for narrow hosts like a modal. */
+    iconsOnly?: boolean;
+}
+export declare const ViewToggle: ({ view, onChange, iconsOnly }: ViewToggleProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/pages/Assets/hooks/useAssetSelection.d.ts

@@ -12,7 +12,21 @@ import { type ItemKey } from '../utils/selection';
  * ordered key array from the caller (the view owns the rendered order), keeping
  * the context data-source-agnostic.
  */
+/**
+ * How an item takes part in selection: `enabled` shows a working checkbox,
+ * `disabled` shows it greyed out (the item cannot be chosen here), `hidden`
+ * shows none (the item is not something this selection is about).
+ */
+export type Selectability = 'enabled' | 'disabled' | 'hidden';
 export interface AssetSelection {
+    /**
+     * Whether selection is on at all. Views show the checkbox column and
+     * select-all only when it is.
+     */
+    isEnabled: boolean;
+    /** Whether the table offers a select-all header (not on a single-value picker). */
+    canSelectAll: boolean;
+    getSelectability: (key: ItemKey) => Selectability;
     /** Every selected item key (assets and folders), render-order agnostic. */
     selectedKeys: Set<ItemKey>;
     /** Selected asset ids, derived from {@link selectedKeys}. */
@@ -34,9 +48,21 @@ export interface AssetSelection {
     selectOnly: (key: ItemKey) => void;
     /** Row-level "..." menu — drops one key when its item leaves the list (move, delete). */
     deselect: (key: ItemKey) => void;
+    /**
+     * Header checkbox, when everything it covers is selected. The host decides how
+     * far that reaches: the Media Library page clears the whole selection, because
+     * it can still hold keys that left the list without being deselected (moved or
+     * deleted from the details drawer). The picker drops only these keys.
+     */
+    deselectAll: (orderedKeys: ItemKey[]) => void;
     /** Close button / folder navigation / list-identity changes. */
     clear: () => void;
 }
+/**
+ * Exported so a host with its own selection rules (the Content Manager asset
+ * picker) can feed the same views a different implementation.
+ */
+export declare const AssetSelectionContext: import("react").Context<AssetSelection | null>;
 interface AssetSelectionProviderProps {
     children: ReactNode;
     /**

package/dist/admin/src/pages/Assets/hooks/useAssetsList.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The list behind the Media Library page and the Content Manager asset picker:
+ * the current folder, search, sort and filters, and the folders and assets they
+ * select. Where that query state lives (URL or memory) is decided by
+ * `ListQueryStateProvider`, not here.
+ */
+export declare const useAssetsList: () => {
+    listSort: import("./useListSort").ListSort;
+    listFilters: import("./useListFilters").ListFilters;
+    assets: import("../../../../../shared/contracts/files").File[];
+    subscribers: import("react").FunctionComponentElement<{
+        children?: import("react").ReactNode | undefined;
+    }> | null;
+    pagination: import("../../../../../shared/contracts/files").Pagination | undefined;
+    isLoadingAssets: boolean;
+    isFetchingMore: boolean;
+    hasNextPage: boolean;
+    fetchNextPage: () => void;
+    assetsError: import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+    folders: import("../../../../../shared/contracts/folders").Folder[];
+    isLoadingFolders: boolean;
+    searchQuery: string;
+    isSearching: boolean;
+    setSearchQuery: (value: string) => void;
+    clearSearch: () => void;
+    currentFolderId: number | null;
+    navigateToFolder: (folder: import("../../../../../shared/contracts/folders").Folder) => void;
+    navigateToRoot: () => void;
+    navigateToFolderId: (folderId: number | null) => void;
+};

package/dist/admin/src/pages/Assets/hooks/useIsAssetDetailsOpen.d.ts

@@ -8,11 +8,7 @@ export declare const ASSET_DETAILS_URL_PARAM = "assetId";
  */
 export declare const parseAssetDetailsId: (raw: string | undefined) => number | null;
 /**
- * Whether the asset details drawer is open, derived purely from the URL.
- *
- * Deliberately separate from `useAssetDetailsParam`, which additionally owns the
- * drawer's mount lifecycle: its `shouldRenderDrawer` only stays correct in the
- * component wired to the close animation, so a second caller would strand it at
- * `true`. Anything that just needs the answer reads this instead.
+ * Whether the asset details drawer is open, derived purely from the URL — so it
+ * turns false as soon as closing starts, while the drawer is still sliding out.
  */
 export declare const useIsAssetDetailsOpen: () => boolean;