@strapi/upload 5.58.0 → 5.60.0

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

@@ -0,0 +1,19 @@
+interface AddAssetMenuProps {
+    disabled?: boolean;
+    onBrowseLibrary: () => void;
+    onUploadFromDevice: () => void;
+    onUploadFromUrl: () => void;
+}
+/**
+ * The field's "Add asset" menu, on the label row.
+ *
+ * Browsing needs the Media Library's read permission, the two upload entries
+ * `assets.create`; each entry disappears without its permission, and the
+ * trigger itself goes when nothing is left to offer, rather than opening an
+ * empty menu.
+ *
+ * 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 {};

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

@@ -0,0 +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;
+    onDropFiles: (files: globalThis.File[]) => void;
+}
+/**
+ * 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: ({ 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

@@ -0,0 +1,25 @@
+import type { FieldUpload } from './useFieldUploads';
+import type { File } from '../../../../shared/contracts/files';
+interface AssetRowProps {
+    asset: File;
+    disabled?: boolean;
+    onCopyLink: (asset: File) => void;
+    onEdit?: (asset: File) => void;
+    onRemove: (asset: File) => void;
+}
+/**
+ * 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

@@ -0,0 +1,28 @@
+import { type ReactNode } from 'react';
+import { type AllowedMediaType } from '../../utils/allowedMediaTypes';
+export interface MediaLibraryInputProps {
+    name: string;
+    label?: string;
+    labelAction?: ReactNode;
+    hint?: string;
+    required?: boolean;
+    disabled?: boolean;
+    attribute?: {
+        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.
+ *
+ * Files dropped here (or picked from the device) upload straight through
+ * `uploadFiles`, which is what drives the global upload progress dialog — so the
+ * entry form stays usable while they go, instead of being covered by the legacy
+ * wizard.
+ *
+ * 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, 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/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
@@ -14,6 +16,7 @@
  */
 export declare const useMediaLibraryPermissions: () => {
     isLoading: boolean;
+    canRead: boolean;
     canCreate: boolean;
     canUpdate: boolean;
     canDownload: boolean;

package/dist/admin/src/legacy/components/BulkMoveDialog/BulkMoveDialog.d.ts

@@ -11,5 +11,5 @@ export interface BulkMoveDialogProps {
     selected?: Array<FolderWithType | FileWithType>;
     currentFolder?: FolderWithType;
 }
-export declare const BulkMoveDialog: ({ onClose, selected, currentFolder }: BulkMoveDialogProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const BulkMoveDialog: ({ onClose, selected, currentFolder, }: BulkMoveDialogProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/admin/src/legacy/pages/App/components/BulkActions.d.ts

@@ -11,5 +11,5 @@ export interface BulkActionsProps {
     onSuccess: () => void;
     currentFolder?: FolderWithType;
 }
-export declare const BulkActions: ({ selected, onSuccess, currentFolder }: BulkActionsProps) => import("react/jsx-runtime").JSX.Element;
+export declare const BulkActions: ({ selected, onSuccess, currentFolder, }: BulkActionsProps) => 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/useListQueryParams.d.ts

@@ -0,0 +1,27 @@
+import { type Dispatch, type ReactNode, type SetStateAction } from 'react';
+interface ListQueryState {
+    search: string;
+    setSearch: Dispatch<SetStateAction<string>>;
+}
+interface ListQueryStateProviderProps {
+    children: ReactNode;
+}
+/**
+ * Keeps the list query (folder, search, filters, sort) in memory instead of the
+ * URL, for surfaces hosted inside another page — the Content Manager asset
+ * picker would otherwise overwrite the entry's own URL. Without this provider,
+ * `useListQueryParams` falls back to the URL, which is what the Media Library
+ * page relies on.
+ */
+export declare const ListQueryStateProvider: ({ children }: ListQueryStateProviderProps) => import("react").FunctionComponentElement<import("react").ProviderProps<ListQueryState | null>>;
+/**
+ * Drop-in for `useQueryParams` used by the list hooks. The in-memory store keeps
+ * a serialized search string and goes through the same `qs` round trip as the
+ * URL, so callers that pre-encode values (`withEncodedUserParams`,
+ * `encodeSearchQuery`) read back exactly what they would from the URL.
+ */
+export declare const useListQueryParams: <TQuery extends object>() => readonly [{
+    readonly query: TQuery;
+    readonly rawQuery: string;
+}, (nextParams: TQuery, method?: "push" | "remove", replace?: boolean) => void];
+export {};

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

@@ -0,0 +1,29 @@
+import { type ReactNode } from 'react';
+interface ListSettings {
+    /**
+     * Management affordances on list items: the right-click menu and the bulk
+     * actions bar. A picker hosted elsewhere (the Content Manager asset picker)
+     * turns them off — choosing an asset is not the place to delete or move it.
+     */
+    showItemActions: boolean;
+    /**
+     * "Folders (n)" / "Assets (n)" headings above each grid section, with a
+     * divider between them. The page carries the count in its own header instead.
+     */
+    showSectionHeadings: boolean;
+    /** Narrowest a grid tile may get before the grid drops a column. */
+    gridMinTileWidth: string;
+    /**
+     * A "Select all" checkbox beside the grid's "Assets (n)" heading, the grid's
+     * counterpart of the table's header checkbox. The page reaches select-all
+     * from its bulk actions bar instead.
+     */
+    showGridSelectAll: boolean;
+}
+interface ListSettingsProviderProps extends Partial<ListSettings> {
+    children: ReactNode;
+}
+export declare const ListSettingsProvider: ({ children, showItemActions, showSectionHeadings, gridMinTileWidth, showGridSelectAll, }: ListSettingsProviderProps) => import("react").FunctionComponentElement<import("react").ProviderProps<ListSettings>>;
+/** Without a provider, returns the Media Library page's settings. */
+export declare const useListSettings: () => ListSettings;
+export {};