@strapi/upload 5.51.1 → 5.52.0

package/dist/admin/src/future/pages/Assets/hooks/useInfiniteAssets.d.ts

@@ -1,12 +1,36 @@
-import type { File } from '../../../../../../shared/contracts/files';
+import type { File, Pagination } from '../../../../../../shared/contracts/files';
 declare const PAGE_SIZE = 20;
 interface UseInfiniteAssetsOptions {
     folder?: number | null;
     sort?: string;
+    search?: string;
+    /** Extra `filters[$and]` entries for the files query. */
+    filters?: Record<string, unknown>[];
+    /** Structural switch: an `is [folder]`-only type badge means no file can match. */
+    enabled?: boolean;
 }
-declare const useInfiniteAssets: ({ folder, sort }?: UseInfiniteAssetsOptions) => {
+/**
+ * Infinite scroll over `/upload/files`, keeping one accumulated slot per page.
+ *
+ * The caller MUST render the returned `subscribers` node — that is what keeps
+ * every loaded page subscribed, so `{Asset, LIST}` invalidations keep the whole
+ * list consistent rather than only the current page.
+ */
+declare const useInfiniteAssets: ({ folder, sort, search, filters, enabled, }?: UseInfiniteAssetsOptions) => {
     assets: File[];
-    pagination: import("../../../../../../shared/contracts/files").Pagination | undefined;
+    subscribers: null;
+    pagination: undefined;
+    isLoading: boolean;
+    isFetchingMore: boolean;
+    hasNextPage: boolean;
+    fetchNextPage: () => void;
+    error: undefined;
+} | {
+    assets: File[];
+    subscribers: import("react").FunctionComponentElement<{
+        children?: import("react").ReactNode | undefined;
+    }>;
+    pagination: Pagination | undefined;
     isLoading: boolean;
     isFetchingMore: boolean;
     hasNextPage: boolean;

package/dist/admin/src/future/pages/Assets/hooks/useInfiniteScrollSentinel.d.ts

@@ -0,0 +1,41 @@
+interface UseInfiniteScrollSentinelArgs {
+    /** Whether there is a further page to request. */
+    hasNextPage: boolean;
+    /** Whether a subsequent page is already in flight. */
+    isFetchingMore: boolean;
+    /** Called to request the next page. Held in a ref, so it need not be stable. */
+    onLoadMore: () => void;
+    /**
+     * Passed to the `IntersectionObserver`. Read once, when the sentinel node
+     * attaches — changing it afterwards does NOT rebuild the observer, so a
+     * later `threshold`/`rootMargin` is silently ignored. Pass a stable, ideally
+     * module-level, object.
+     */
+    options?: IntersectionObserverInit;
+}
+/**
+ * Infinite-scroll trigger for the media library list.
+ *
+ * Returns a callback ref to place on a sentinel element rendered after the last
+ * row. Three deliberate choices:
+ *
+ * 1. **Loading is driven only by fresh observer readings.** A fetch fires from
+ *    the `IntersectionObserver` callback — never from a state/prop change — so
+ *    it can't react to a stale `isIntersecting` from before newly loaded rows
+ *    rendered (which fetched an extra page on every trigger).
+ *
+ * 2. **Each settled page re-observes the sentinel.** An `IntersectionObserver`
+ *    only fires on a *transition*. When the sentinel stays on screen (a page
+ *    that doesn't fill the viewport — tall viewport, short page, grid fitting
+ *    the whole page) it would never fire again and loading would stall. So when
+ *    `isFetchingMore` settles back to false we re-observe, forcing a fresh
+ *    reading against the new layout: still on screen → load the next page;
+ *    viewport now filled → stop.
+ *
+ * 3. **A callback ref, not a stable object ref.** The sentinel only mounts once
+ *    the first page has rendered (the list shows a loader before that). A
+ *    callback ref (re)binds the observer exactly when the node mounts/unmounts,
+ *    so the observer can't miss a sentinel that appears after the hook first ran.
+ */
+export declare const useInfiniteScrollSentinel: ({ hasNextPage, isFetchingMore, onLoadMore, options, }: UseInfiniteScrollSentinelArgs) => (node: HTMLElement | null) => void;
+export {};

package/dist/admin/src/future/pages/Assets/hooks/useListFilters.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Filter state for the assets list, backed by a single `?filters=` query param
+ * so the applied filters are shareable and survive Back/refresh.
+ *
+ * Serialized grammar — badges separated by `;`, one badge is
+ * `<field>:<condition>:<value>`:
+ *
+ * - `type:is:picture,audio` / `type:not:folder`
+ * - `created:within:1week` / `updated:notwithin:3months` / `created:exact:1day`
+ * - `created:rangeis:2024-01-01..2024-04-07` / `created:rangenot:...`
+ *
+ * Relative presets stay relative in the URL on purpose: the badge label
+ * ("1 week ago") remains truthful forever and a shared link means "within the
+ * last week from whenever it is opened". Resolution to absolute timestamps
+ * happens at query-build time (see utils/buildAssetFilters.ts).
+ *
+ * Several badges for the same field are allowed, even contradictory ones —
+ * everything is combined with AND; contradictions simply produce the filtered
+ * empty state.
+ */
+export declare const TYPE_VALUES: readonly ["folder", "picture", "audio", "video", "document"];
+export type TypeValue = (typeof TYPE_VALUES)[number];
+export declare const DATE_PRESETS: readonly ["1day", "3days", "1week", "1month", "3months", "6months", "1year"];
+export type DatePreset = (typeof DATE_PRESETS)[number];
+export type TypeCondition = 'is' | 'isNot';
+export type PresetCondition = 'isExactly' | 'withinLast' | 'notWithinLast';
+export type RangeCondition = 'is' | 'isNot';
+export type DateField = 'createdAt' | 'updatedAt';
+export interface TypeFilter {
+    kind: 'type';
+    condition: TypeCondition;
+    values: TypeValue[];
+}
+export interface DatePresetFilter {
+    kind: 'date';
+    field: DateField;
+    mode: 'preset';
+    condition: PresetCondition;
+    preset: DatePreset;
+}
+export interface DateRangeFilter {
+    kind: 'date';
+    field: DateField;
+    mode: 'range';
+    condition: RangeCondition;
+    /** Calendar dates, `YYYY-MM-DD`, inclusive on both ends. */
+    from: string;
+    to: string;
+}
+export type DateFilter = DatePresetFilter | DateRangeFilter;
+export type ListFilter = TypeFilter | DateFilter;
+/**
+ * `unknown` on purpose: the query string is user-editable, and qs parses
+ * shapes like `?filters[]=a&filters[]=b` into arrays — the guard is what
+ * makes the caller's `?filters=` type an assertion rather than a crash.
+ */
+export declare const parseFiltersParam: (raw: unknown) => ListFilter[];
+export declare const serializeFilters: (filters: ListFilter[]) => string;
+export interface ListFilters {
+    filters: ListFilter[];
+    /** Serialized form — stable fingerprint for list-identity (selection reset). */
+    serialized: string;
+    addFilter: (filter: ListFilter) => void;
+    /** Replaces the badge at `index` (condition or value edited in place). */
+    updateFilter: (index: number, filter: ListFilter) => void;
+    removeFilter: (index: number) => void;
+    clearFilters: () => void;
+}
+export declare const useListFilters: () => ListFilters;

package/dist/admin/src/future/pages/Assets/utils/buildAssetFilters.d.ts

@@ -0,0 +1,46 @@
+import { type ListFilter } from '../hooks/useListFilters';
+/**
+ * Translates the URL filter model into Strapi `filters[$and]` entries for the
+ * files and folders queries, and decides the structural visibility of both
+ * sections.
+ *
+ * Relative presets resolve against `now` at build time — the URL stays
+ * relative ("within the last week"), only the outgoing query is absolute.
+ *
+ * Semantics:
+ * - Every badge is one `$and` entry (badges combine with AND, per ticket).
+ * - Type: `folder` is not a mime — it acts structurally on the folders
+ *   section. The remaining values map to mime clauses; `document` is the
+ *   legacy catch-all (mime contains none of image/audio/video — audio
+ *   included in the exclusion, fixing the legacy quirk).
+ * - Dates apply to files and folders alike (folders have both timestamps).
+ * - "is exactly <preset>" means the calendar day of `now - delta`.
+ * - Ranges are inclusive on both ends (start-of-day .. end-of-day).
+ */
+type QueryClause = Record<string, unknown>;
+/**
+ * Parses `YYYY-MM-DD` as a local calendar date — NOT `new Date(value)`, which
+ * treats date-only strings as UTC midnight and shifts the day in every
+ * timezone west of UTC. Shared by the query builder, the badge labels and the
+ * range calendar so all three agree on which day a range endpoint means.
+ */
+export declare const parseCalendarDate: (value: string) => Date;
+export interface BuiltFilters {
+    /** Extra `$and` entries for the files query. */
+    fileClauses: QueryClause[];
+    /** Extra `$and` entries for the folders query (dates only). */
+    folderClauses: QueryClause[];
+    /**
+     * Whether the folders section can show at all. A type badge decides it by
+     * evaluating "folder" like any other value: `is` shows folders only when
+     * folder is selected; `is not` hides them only when folder is selected.
+     */
+    showFolders: boolean;
+    /**
+     * Whether the files list can show at all — false when an `is` type badge
+     * selects only "folder" (no file can match).
+     */
+    showFiles: boolean;
+}
+export declare const buildAssetFilters: (filters: ListFilter[], now: Date) => BuiltFilters;
+export {};

package/dist/admin/src/future/pages/Assets/utils/listQueryKey.d.ts

@@ -9,14 +9,13 @@
  *   same list, so the selection survives the toggle.
  * - Infinite scroll (load more) does NOT change any segment → selection persists.
  *
- * Search/filter use stable defaults until their header controls are wired;
- * follow-up PRs only pass real values — no selection logic changes needed.
+ * Filter uses a stable default until its header control is wired; that follow-up
+ * only passes a real value — no selection logic changes needed.
  */
 export interface ListQueryKeyInput {
     folderId: number | null;
-    /** Empty string until search UI ships. */
     search: string;
-    /** Null until sort UI ships. */
+    /** Composite of asset sort and folder position — both change the render order. */
     sort: string | null;
     /** Null until filter UI ships. */
     filter: string | null;

package/dist/admin/src/future/services/api.d.ts

@@ -1,11 +1,20 @@
-import type { CreateFilesStream, File as UploadedFile, UploadFileInfo } from '../../../../shared/contracts/files';
+import { Dispatch } from '@reduxjs/toolkit';
+import type { CreateFilesStream, File as UploadedFile, UnstableGenerateAIMetadata, UploadFileInfo } from '../../../../shared/contracts/files';
 interface UploadFilesArgs {
     formData: FormData;
     totalFiles: number;
+    /**
+     * How many files to upload in parallel — the `concurrentUploadRequests`
+     * settings value. Defaults to 1 (sequential).
+     */
+    concurrency?: number;
+    /** Whether AI metadata generation is enabled (EE AI available + `settings.aiMetadata`). */
+    generateAiMetadata: boolean;
 }
 interface UploadFromUrlsArgs {
     urls: string[];
     folderId: number | null;
+    generateAiMetadata: boolean;
 }
 /**
  * A single file plus the `fileInfo` it was queued with.
@@ -22,10 +31,33 @@ interface UploadEntry {
  * Called from the UploadProgressDialog when the user clicks cancel or close.
  */
 export declare const abortUpload: (uploadId: number) => void;
+/**
+ * Kicks off AI metadata generation for a freshly uploaded file.
+ *
+ * Deliberately fire-and-forget — the caller must NOT await it:
+ *  - generation for file N overlaps the upload of file N+1;
+ *  - a generation failure can never affect the upload result (the upload already
+ *    succeeded), which is why the promise is fully swallowed here.
+ *
+ * Every uploaded file is sent, including non-images: the server already classifies
+ * them (`ai-metadata.generateForFiles` returns `skipped` for anything whose mime
+ * isn't `image/*`) and duplicating that rule here would let the two drift apart.
+ * The upshot is that a non-image now reports "Metadata generation skipped" rather
+ * than silently showing no metadata state at all.
+ */
+export declare const maybeGenerateMetadata: ({ file, index, uploadId, enabled, dispatch, }: {
+    file: UploadedFile;
+    index: number;
+    uploadId: number;
+    enabled: boolean;
+    dispatch: Dispatch;
+}) => void;
 declare const uploadApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, import("@reduxjs/toolkit/dist/query/endpointDefinitions").UpdateDefinitions<{}, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", never> & {
     /**
-     * Upload files sequentially, one request per file, to `/upload/unstable/upload-file`.
-     * Real per-file byte progress comes from `XHR.upload.onprogress`.
+     * Upload files to `/upload/unstable/upload-file`, one request per file,
+     * through a worker pool of `concurrency` parallel requests (default 1 =
+     * sequential). Real per-file byte progress comes from
+     * `XHR.upload.onprogress`.
      */
     uploadFiles: import("@reduxjs/toolkit/query").MutationDefinition<UploadFilesArgs, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", UploadedFile[], "adminApi">;
     /**
@@ -39,7 +71,7 @@ declare const uploadApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/t
     /**
      * Retry uploading cancelled files.
      * Maps cancelled rows back to their original entries and re-runs only those
-     * through the same sequential loop with a fresh AbortController.
+     * through the same upload pool with a fresh AbortController.
      */
     retryCancelledFiles: import("@reduxjs/toolkit/query").MutationDefinition<void, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", UploadedFile[], "adminApi">;
     /**
@@ -47,6 +79,22 @@ declare const uploadApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/t
      * Sends URLs to the server which fetches and uploads them (SSE flow, unchanged).
      */
     uploadFromUrls: import("@reduxjs/toolkit/query").MutationDefinition<UploadFromUrlsArgs, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", CreateFilesStream.Response, "adminApi">;
+    /**
+     * Generate AI metadata (alt text + caption) for the given assets.
+     * Synchronous: resolves once every file has been processed and reports the
+     * outcome per file, so non-images and individual failures don't fail the
+     * whole batch. Existing alt text and captions are never overwritten.
+     *
+     * Lives here rather than in `assets.ts` because the upload flows dispatch it
+     * directly via `initiate()` after each file completes, and `assets.ts` already
+     * imports from this module — defining it there would be a circular import.
+     * Re-exported from `assets.ts` for the components that consume the hook.
+     */
+    generateAiMetadata: import("@reduxjs/toolkit/query").MutationDefinition<{
+        fileIds: number[];
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", UnstableGenerateAIMetadata.FileResult[], "adminApi">;
 }, "adminApi", "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/dist/query/react").reactHooksModuleName>;
-export declare const useUploadFilesMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<UploadFilesArgs, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", UploadedFile[], "adminApi">>, useUploadFileSilentlyMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<UploadEntry, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", UploadedFile, "adminApi">>, useRetryCancelledFilesMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<void, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", UploadedFile[], "adminApi">>, useUploadFromUrlsMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<UploadFromUrlsArgs, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", CreateFilesStream.Response, "adminApi">>;
+export declare const useUploadFilesMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<UploadFilesArgs, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", UploadedFile[], "adminApi">>, useUploadFileSilentlyMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<UploadEntry, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", UploadedFile, "adminApi">>, useRetryCancelledFilesMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<void, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", UploadedFile[], "adminApi">>, useUploadFromUrlsMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<UploadFromUrlsArgs, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", CreateFilesStream.Response, "adminApi">>, useGenerateAiMetadataMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<{
+    fileIds: number[];
+}, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", UnstableGenerateAIMetadata.FileResult[], "adminApi">>;
 export { uploadApi };

package/dist/admin/src/future/services/assets.d.ts

@@ -4,6 +4,9 @@ interface GetAssetsParams {
     pageSize?: number;
     folder?: number | null;
     sort?: string;
+    search?: string;
+    /** Extra `filters[$and]` entries (list filters), AND-ed with the folder/search scope. */
+    filters?: Record<string, unknown>[];
 }
 interface GetAssetsResponse {
     results: File[];
@@ -22,4 +25,9 @@ export declare const useGetAssetsQuery: import("@reduxjs/toolkit/dist/query/reac
     fileIds: number[];
     folderIds: number[];
 }, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", unknown, "adminApi">>;
-export {};
+/**
+ * `generateAiMetadata` is defined in `./api` (the upload flows dispatch it directly
+ * after each file completes, and this module imports from there) — re-exported here
+ * so asset components keep a single import site for asset-related hooks.
+ */
+export { useGenerateAiMetadataMutation } from './api';

package/dist/admin/src/future/services/folders.d.ts

@@ -11,6 +11,9 @@ interface GetFoldersParams {
     parentId?: number | null;
     /** Comma-separated rules, e.g. `updatedAt:DESC,name:ASC`. Defaults to alphabetical. */
     sort?: string;
+    search?: string;
+    /** Extra `filters[$and]` entries (list filters), AND-ed with the parent/search scope. */
+    filters?: Record<string, unknown>[];
 }
 interface BulkMoveParams {
     fileIds?: number[];
@@ -18,7 +21,12 @@ interface BulkMoveParams {
     /** `null` moves the items to the root of the Media Library. */
     destinationFolderId: number | null;
 }
-export declare const useCreateFolderMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<Pick<Folder, "name" | "parent">, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", Folder, "adminApi">>, useGetFoldersQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<void | GetFoldersParams, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", Folder[], "adminApi">>, useGetFolderQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<{
+export declare const useCreateFolderMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<Pick<Folder, "name" | "parent">, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", Folder, "adminApi">>, useUpdateFolderMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<{
+    id: number;
+} & {
+    name: string;
+    parent: number | null;
+}, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", Folder, "adminApi">>, useGetFoldersQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<void | GetFoldersParams, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", Folder[], "adminApi">>, useGetFolderQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<{
     id: number;
 }, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", FolderWithCounts, "adminApi">>, useGetAllFoldersQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<void, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", Folder[], "adminApi">>, useGetFolderStructureQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<void, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", FolderNode[], "adminApi">>, useBulkMoveMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<BulkMoveParams, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", {
     data: {

package/dist/admin/src/future/services/settings.d.ts

@@ -1,2 +1,2 @@
-declare const useGetSettingsQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<void, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", import("../../../../shared/contracts/settings").Settings, "adminApi">>;
-export { useGetSettingsQuery };
+declare const useGetUploadSettingsQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<void, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("@strapi/admin/strapi-admin").QueryArguments, unknown, import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError, {}, {}>, "GuidedTourMeta" | "HomepageKeyStatistics" | "AiUsage" | "AiFeatureConfig" | "Asset" | "Folder", import("../../../../shared/contracts/settings").Settings, "adminApi">>;
+export { useGetUploadSettingsQuery };

package/dist/admin/src/future/store/uploadProgress.d.ts

@@ -4,6 +4,14 @@ export interface FileUploadError {
     message: string;
 }
 export type FileProgressStatus = 'pending' | 'uploading' | 'complete' | 'error' | 'cancelled';
+/**
+ * AI metadata generation phase for a single row, tracked independently from the
+ * upload status: a metadata failure never turns a successful upload into an error.
+ * `undefined` means the row has no metadata phase at all, i.e. AI metadata is
+ * disabled — non-images do get a phase and come back `skipped` from the server.
+ */
+export type FileMetadataStatus = 'generating' | 'generated' | 'skipped' | 'failed';
+export type FileMetadataResultStatus = Exclude<FileMetadataStatus, 'generating'>;
 export interface FileProgress {
     name: string;
     index: number;
@@ -12,6 +20,7 @@ export interface FileProgress {
     uploadedBytes: number;
     file?: File;
     error?: string;
+    metadataStatus?: FileMetadataStatus;
 }
 export interface UploadProgressState {
     isVisible: boolean;
@@ -35,6 +44,72 @@ export declare const selectAggregateProgress: ((state: RootState) => number) & i
 }> & {
     clearCache: () => void;
 };
+/**
+ * Count-based metadata progress across the whole batch: `settled / expected`.
+ *
+ * Count-based rather than byte-weighted because the generation endpoint answers in one
+ * go — there is no intermediate progress to weight.
+ *
+ * The denominator is every row *expected* to enter the phase, not just those that
+ * already have. Generation is fired per file as each upload finishes, so counting only
+ * started rows made the denominator grow mid-batch and the percentage jump backwards
+ * (1/1 = 100%, then a second row starts and it drops to 1/2 = 50%), which flickered the
+ * header subtitle on and off once per file.
+ *
+ * "Expected" is derived from upload outcome rather than from the AI-metadata flag:
+ *  - a row still uploading may yet enter the phase, so it counts toward the total;
+ *  - an errored or cancelled row never will, so it must not — otherwise a batch with
+ *    one failure could never reach 100%.
+ *
+ * Returns `null` when nothing has entered the phase and nothing is pending — i.e. AI
+ * metadata is off, or the batch is done — so the header can hide the subtitle.
+ */
+export declare const selectMetadataProgress: ((state: RootState) => number | null) & import("reselect").OutputSelectorFields<(args_0: FileProgress[]) => number | null, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Whether the metadata phase is still ongoing for the batch as a whole.
+ *
+ * The header uses this — not `selectMetadataProgress === 100` — to decide when to drop
+ * the subtitle. Two distinct reasons the phase can be unfinished:
+ *  - a row is generating right now;
+ *  - no row is generating this instant, but rows are still uploading and will enter the
+ *    phase when they finish.
+ *
+ * The second clause is what keeps the subtitle stable. Generation for file N typically
+ * finishes before file N+1 finishes uploading, so a naive "is anything generating?"
+ * check goes false between every pair of files and blinks the subtitle out and back in.
+ */
+export declare const selectIsGeneratingMetadata: ((state: RootState) => boolean) & import("reselect").OutputSelectorFields<(args_0: FileProgress[]) => boolean, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * How many rows reached each terminal metadata outcome, for the header's completion
+ * message. `null` while the phase is unfinished — or was never entered at all — so the
+ * caller has a single check for "there is no settled outcome to report yet".
+ *
+ * Counts are reported separately rather than collapsed into one total because they are
+ * not interchangeable: only `generated` rows actually had metadata written, so only that
+ * count can be claimed as a success. A batch of non-images settles entirely on `skipped`,
+ * where "generated on 0 files" would be worse than saying nothing.
+ */
+export declare const selectMetadataOutcome: ((state: RootState) => {
+    generated: number;
+    skipped: number;
+    failed: number;
+} | null) & import("reselect").OutputSelectorFields<(args_0: FileProgress[]) => {
+    generated: number;
+    skipped: number;
+    failed: number;
+} | null, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
 export declare const openUploadProgress: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     totalFiles: number;
     fileNames: string[];
@@ -53,7 +128,14 @@ export declare const openUploadProgress: import("@reduxjs/toolkit").ActionCreato
     index: number;
     name: string;
     message: string;
-}, "uploadProgress/setFileError">, addUploadErrors: import("@reduxjs/toolkit").ActionCreatorWithPayload<FileUploadError[], "uploadProgress/addUploadErrors">, closeUploadProgress: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"uploadProgress/closeUploadProgress">, toggleMinimize: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"uploadProgress/toggleMinimize">, cancelUpload: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"uploadProgress/cancelUpload">, setUploadFailed: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+}, "uploadProgress/setFileError">, setFileMetadataGenerating: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    index: number;
+    uploadId: number;
+}, "uploadProgress/setFileMetadataGenerating">, setFileMetadataResult: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    index: number;
+    uploadId: number;
+    status: FileMetadataResultStatus;
+}, "uploadProgress/setFileMetadataResult">, addUploadErrors: import("@reduxjs/toolkit").ActionCreatorWithPayload<FileUploadError[], "uploadProgress/addUploadErrors">, closeUploadProgress: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"uploadProgress/closeUploadProgress">, toggleMinimize: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"uploadProgress/toggleMinimize">, cancelUpload: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"uploadProgress/cancelUpload">, setUploadFailed: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     message: string;
 }, "uploadProgress/setUploadFailed">, retryCancelledFiles: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"uploadProgress/retryCancelledFiles">;
 export declare const uploadProgressReducer: import("redux").Reducer<UploadProgressState>;

package/dist/admin/src/future/utils/buildDragSetFromSelection.d.ts

@@ -1,11 +1,12 @@
+import { type ItemLocations } from './itemLocations';
 import type { DragItemData } from '../types/dnd';
 /**
  * Reconstruct the drag set from a bulk-actions selection so the dialog can feed
  * the exact same `DragItemData[]` into `computeValidDropTargets` / the canonical
  * `canDropItemOnFolder` predicate that pointer drag uses.
  *
- * Selection is page-scoped to the current folder, so every selected item shares
- * `currentFolderId` as its location (files → `folderId`, folders → `parentId`).
+ * Each item's location comes from the loaded row, not from the folder currently
+ * open: search results are global, so a selected item can live anywhere.
  * Names are irrelevant to drop validation, so they are left empty.
  */
-export declare const buildDragSetFromSelection: (selectedIds: ReadonlySet<number>, selectedFolderIds: ReadonlySet<number>, currentFolderId: number | null) => DragItemData[];
+export declare const buildDragSetFromSelection: (selectedIds: ReadonlySet<number>, selectedFolderIds: ReadonlySet<number>, locations: ItemLocations, fallbackFolderId: number | null) => DragItemData[];

package/dist/admin/src/future/utils/formatMoveSuccessMessage.d.ts

@@ -2,7 +2,13 @@ import type { IntlShape } from 'react-intl';
 interface FormatMoveSuccessArgs {
     formatMessage: IntlShape['formatMessage'];
     count: number;
-    source: string;
+    /**
+     * Leaf name of the folder the items came from, or `null` when the move spans
+     * several source folders and no single one can be named — a global-search
+     * selection can hold items from anywhere. The wording then omits the source
+     * rather than naming one folder and implying the rest came from it too.
+     */
+    source: string | null;
     destination: string;
 }
 /**

package/dist/admin/src/future/utils/getRelationId.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Normalise a to-one relation down to its id.
+ *
+ * The contracts type `File['folder']` and `Folder['parent']` as ids, but the
+ * admin populates both (`populate: { folder: true }` on `/upload/files`,
+ * `populate: { parent: true }` on `/upload/folders`), so the wire value is an
+ * object. Only the id is ever read — move validation compares locations by id.
+ */
+export declare const getRelationId: (relation: number | string | {
+    id?: number;
+} | null | undefined) => number | null;

package/dist/admin/src/future/utils/isEventFromWithin.d.ts

@@ -0,0 +1,11 @@
+import type { SyntheticEvent } from 'react';
+/**
+ * True when the event really originated inside `currentTarget`'s DOM subtree.
+ *
+ * Portaled content (Radix menus, modals, select popovers) bubbles through the
+ * React tree, so a row's handlers see events coming from dialogs rendered by
+ * its own children. Guarding on DOM containment keeps those out — without
+ * calling `stopPropagation`, which would also kill the native event before it
+ * reaches `document`, where Radix listens in order to dismiss its layers.
+ */
+export declare const isEventFromWithin: (event: SyntheticEvent) => boolean;

package/dist/admin/src/future/utils/itemLocations.d.ts

@@ -0,0 +1,31 @@
+import type { File } from '../../../../shared/contracts/files';
+import type { Folder } from '../../../../shared/contracts/folders';
+/**
+ * Where each loaded item actually lives, keyed by id.
+ *
+ * Search results are global, so the folder currently open (`?folder=`) says
+ * nothing about a selected item's location. The loaded lists do: the server
+ * populates `folder` on `/upload/files` and `parent` on `/upload/folders`.
+ *
+ * `undefined` means "not in the loaded list" and is distinct from `null`
+ * ("lives at the root") — the two lead to different move validation.
+ */
+export interface ItemLocations {
+    fileFolderId: (id: number) => number | null | undefined;
+    folderParentId: (id: number) => number | null | undefined;
+}
+/** Every id misses — used where no list is loaded (e.g. an isolated provider). */
+export declare const emptyItemLocations: ItemLocations;
+/**
+ * Build the lookup once per list. Callers memoize on the rows so the identity
+ * stays stable: `BulkMoveDialog` memoizes its destination walk on the items
+ * derived from it.
+ */
+export declare const buildItemLocations: (assets: File[], folders: Folder[]) => ItemLocations;
+/**
+ * Resolve an item's location, falling back to the folder currently open when it
+ * is not in the loaded list. The fallback is unreachable in practice — selection
+ * clears whenever the list identity changes and infinite scroll only appends —
+ * but a stale parent beats silently dropping the item from the move.
+ */
+export declare const locateItem: (locations: ItemLocations, kind: "file" | "folder", id: number, fallbackFolderId: number | null) => number | null;

package/dist/admin/src/future/utils/itemSource.d.ts

@@ -0,0 +1,22 @@
+import type { DragItemData } from '../types/dnd';
+/**
+ * Where an item currently lives, regardless of its kind — folders carry their
+ * location on `parentId`, files on `folderId`.
+ */
+export declare const sourceFolderIdOf: (item: DragItemData) => number | null;
+/**
+ * The one folder every item in a move came from, or `null` when there isn't one.
+ *
+ * A selection made under a global search can hold items from anywhere, so a move
+ * has a nameable source only when the whole set agrees on it. `null` also covers
+ * the empty set. Callers pass the result straight to `formatMoveSuccessMessage`,
+ * which drops the source from the wording rather than crediting one item's
+ * folder to all of them.
+ *
+ * Note `null` is overloaded on purpose at the *label* level: an item at the
+ * Media Library root also has a `null` location, and both cases end up reading
+ * as "no folder to name". Use `hasUniformSource` when the difference matters.
+ */
+export declare const uniformSourceFolderId: (items: DragItemData[]) => number | null;
+/** Whether every item in the set came from the same folder. False for an empty set. */
+export declare const hasUniformSource: (items: DragItemData[]) => boolean;

package/dist/admin/src/future/utils/searchQueryParam.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `_q` must be encoded on both hops: `useQueryParams.setQuery` and the fetch
+ * client both stringify with `{ encode: false }`, so an unencoded `&` would
+ * truncate the query. `qs.parse` decodes `+` as a space, so `+` needs escaping
+ * beyond what `encodeURIComponent` does.
+ */
+export declare const encodeSearchQuery: (value: string) => string;

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

@@ -1,4 +1,4 @@
 export declare const useAIAvailability: () => {
-    status: "loading" | "success" | "error" | "idle";
+    status: "success" | "error" | "loading" | "idle";
     isEnabled: boolean | undefined;
 };