@strapi/upload 5.54.0 → 5.55.0

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

@@ -0,0 +1,45 @@
+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;
+}
+/**
+ * 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.
+ *
+ * Loaded pages survive navigating away and back: each list's accumulator is
+ * remembered (LRU, `MAX_REMEMBERED_LISTS`) and restored when its key returns, so
+ * stepping into a subfolder and back out keeps the rows the user scrolled for.
+ */
+declare const useInfiniteAssets: ({ folder, sort, search, filters, enabled, }?: UseInfiniteAssetsOptions) => {
+    assets: File[];
+    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;
+    fetchNextPage: () => void;
+    error: import("@strapi/admin/strapi-admin").BaseQueryError | import("@reduxjs/toolkit").SerializedError | undefined;
+};
+export { useInfiniteAssets };
+export { PAGE_SIZE };

package/dist/admin/src/pages/Assets/utils/mergeMixedList.d.ts

@@ -0,0 +1,40 @@
+import type { File } from '../../../../../shared/contracts/files';
+import type { Folder } from '../../../../../shared/contracts/folders';
+export type MixedItem = {
+    kind: 'folder';
+    folder: Folder;
+} | {
+    kind: 'asset';
+    asset: File;
+};
+type SortableRecord = {
+    name?: string | null;
+    createdAt?: string | null;
+    updatedAt?: string | null;
+    size?: number | null;
+};
+/**
+ * Builds a comparator from comma-separated sort rules (`updatedAt:DESC,name:ASC`).
+ * Rules apply in order; the first non-equal field decides. Client-side
+ * approximation of the server ordering — good enough to slot folders between
+ * files that were sorted server-side by the same rules.
+ */
+export declare const buildComparator: (sort: string) => (a: SortableRecord, b: SortableRecord) => number;
+interface MergeMixedListParams {
+    folders: Folder[];
+    assets: File[];
+    /** Combined sort rules used for the assets query. */
+    sort: string;
+    /**
+     * More asset pages exist. A folder may only be placed once we know no
+     * not-yet-loaded asset sorts before it — i.e. it compares ≤ the last loaded
+     * asset. Later pages release the remaining folders progressively.
+     */
+    hasNextPage: boolean;
+}
+/**
+ * Interleaves the complete folder list into the (possibly partially loaded)
+ * asset stream according to the active sort. Ties order folders first.
+ */
+export declare const mergeMixedList: ({ folders, assets, sort, hasNextPage, }: MergeMixedListParams) => MixedItem[];
+export {};

package/dist/admin/src/pages/Assets/utils/mergeUploadedAssets.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Merges just-uploaded assets into the loaded asset list so each one appears as
+ * soon as its own upload finishes, rather than when the whole batch settles.
+ *
+ * The upload is one mutation per batch, so its cache invalidation fires once at
+ * the end. These helpers bridge that gap purely client-side: the completed
+ * uploads already sit in the progress store as full `File` objects, so they can
+ * be placed into the list at their sort position with no extra request.
+ *
+ * The server list stays authoritative — merging never reorders it, and an id it
+ * already contains wins over the local copy, so the end-of-batch refetch
+ * silently takes over.
+ */
+import type { File } from '../../../../../shared/contracts/files';
+/**
+ * Comparator matching a `<field>:<ASC|DESC>` sort rule, as sent to the API.
+ *
+ * Ties break on id so the order is total: without it, two files sharing a
+ * timestamp could swap places between renders.
+ */
+export declare const getAssetComparator: (rule?: string) => (a: File, b: File) => number;
+/**
+ * Places `uploaded` into `assets` at their sort position.
+ *
+ * An upload that sorts past everything loaded is dropped unless the list is
+ * fully loaded: it belongs on a page the user has not reached, and appending it
+ * would show it adjacent to the last loaded item instead of at its real place.
+ */
+export declare const mergeUploadedAssets: ({ assets, uploaded, sort, hasNextPage, }: {
+    assets: File[];
+    uploaded: File[];
+    sort?: string;
+    /** Whether more pages remain, i.e. the tail of the list is not loaded. */
+    hasNextPage: boolean;
+}) => File[];

package/dist/admin/src/pages/Assets/utils/renderedKeys.d.ts

@@ -0,0 +1,19 @@
+import { type ItemKey } from './selection';
+import type { MixedItem } from './mergeMixedList';
+import type { File } from '../../../../../shared/contracts/files';
+import type { Folder } from '../../../../../shared/contracts/folders';
+/**
+ * The keys of the items actually on screen, in render order.
+ *
+ * Single source for every consumer of the rendered set — range selection,
+ * select-all and the bulk action bar. Derived once so they cannot disagree:
+ * in "Folders: Mixed with files" the rows come from `mergeMixedList`, which
+ * withholds folders sorting after the last loaded asset, so `folders` is not
+ * the rendered folder set.
+ */
+export declare const buildRenderedKeys: ({ folders, assets, mixedItems, }: {
+    folders: Folder[];
+    assets: File[];
+    /** The interleaved rows, when the table is in mixed mode. */
+    mixedItems?: MixedItem[] | null;
+}) => ItemKey[];

package/dist/admin/src/pages/SettingsPage/useAIMetadataJob.d.ts

@@ -0,0 +1,9 @@
+import type { AIMetadataJob } from '../../../../shared/contracts/ai-metadata-jobs';
+export declare const useAIMetadataJob: (options?: {
+    enabled?: boolean;
+}) => {
+    data: AIMetadataJob | null | undefined;
+    refetch: <TPageData>(options?: (import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("react-query").QueryObserverResult<AIMetadataJob | null, {
+        message: string;
+    }>>;
+};

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

@@ -0,0 +1,99 @@
+import { Dispatch } from '@reduxjs/toolkit';
+import type { CreateFilesStream, File as UploadedFile, GenerateAIMetadata, 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.
+ * Retained in {@link uploadRegistry} so cancelled files can be retried without
+ * the user re-selecting them. `File`/`AbortController` are non-serializable, so
+ * they live here rather than in Redux.
+ */
+interface UploadEntry {
+    file: File;
+    fileInfo: UploadFileInfo;
+}
+/**
+ * Aborts an upload by its uploadId.
+ * 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 to `/upload/files`, 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">;
+    /**
+     * Upload a single, already-prepared file WITHOUT opening the global
+     * upload-progress dialog. For flows that create one asset programmatically
+     * (e.g. crop → "Save as copy"), where the bulk-upload progress UI is
+     * inappropriate. Same endpoint as `uploadFiles`, minus the progress/retry
+     * machinery.
+     */
+    uploadFileSilently: 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">;
+    /**
+     * Retry uploading cancelled files.
+     * Maps cancelled rows back to their original entries and re-runs only those
+     * 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">;
+    /**
+     * Upload files from URLs.
+     * 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", GenerateAIMetadata.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">>, 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", GenerateAIMetadata.FileResult[], "adminApi">>;
+export { uploadApi };

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

@@ -0,0 +1,33 @@
+import type { File, Pagination, UploadFileInfo, AssetWithPopulatedCreatedBy } from '../../../shared/contracts/files';
+interface GetAssetsParams {
+    page?: number;
+    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[];
+    pagination: Pagination;
+}
+interface UpdateAssetArgs {
+    id: number;
+    fileInfo: Partial<UploadFileInfo>;
+}
+interface ReplaceAssetArgs {
+    id: number;
+    file: globalThis.File;
+    fileInfo?: Partial<UploadFileInfo>;
+}
+export declare const useGetAssetsQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<void | GetAssetsParams, 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", GetAssetsResponse, "adminApi">>, useGetAssetQuery: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseQuery<import("@reduxjs/toolkit/query").QueryDefinition<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", AssetWithPopulatedCreatedBy, "adminApi">>, useUpdateAssetMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<UpdateAssetArgs, 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", AssetWithPopulatedCreatedBy, "adminApi">>, useReplaceAssetMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<ReplaceAssetArgs, 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", AssetWithPopulatedCreatedBy, "adminApi">>, useDeleteAssetMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<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">>, useBulkDeleteItemsMutation: import("@reduxjs/toolkit/dist/query/react/buildHooks").UseMutation<import("@reduxjs/toolkit/query").MutationDefinition<{
+    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">>;
+/**
+ * `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/services/folders.d.ts

@@ -0,0 +1,37 @@
+import type { Folder, FolderNode } from '../../../shared/contracts/folders';
+export type FolderWithCounts = Omit<Folder, 'children' | 'files'> & {
+    children?: {
+        count: number;
+    };
+    files?: {
+        count: number;
+    };
+};
+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[];
+    folderIds?: number[];
+    /** `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">>, 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: {
+        files: [];
+        folders: Folder[];
+    };
+}, "adminApi">>;
+export {};

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

@@ -0,0 +1,2 @@
+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/services/uploadFileViaXHR.d.ts

@@ -0,0 +1,23 @@
+import type { File } from '../../../shared/contracts/files';
+/**
+ * Thrown when an upload is aborted via its `AbortSignal`.
+ * Distinct from {@link UploadFileError} so callers can tell cancellation apart
+ * from a genuine failure.
+ */
+export declare class UploadAbortedError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Thrown when an upload fails (non-2xx response, network error, or unparseable body).
+ */
+export declare class UploadFileError extends Error {
+    status?: number;
+    /**
+     * Whether `message` came from the response body. The fallbacks this module
+     * invents are hardcoded English; callers with localized text should use theirs.
+     */
+    isServerMessage: boolean;
+    constructor(message: string, status?: number, isServerMessage?: boolean);
+}
+export type UploadProgressCallback = (bytes: number, total: number) => void;
+export declare const uploadFileViaXHR: <T = File>(url: string, token: string | null | undefined, formData: FormData, signal: AbortSignal, onProgress?: UploadProgressCallback) => Promise<T>;

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

@@ -0,0 +1,201 @@
+import type { File } from '../../../shared/contracts/files';
+export interface FileUploadError {
+    name: string;
+    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;
+    status: FileProgressStatus;
+    size: number;
+    uploadedBytes: number;
+    file?: File;
+    /** When the server confirmed the upload. Set with the row's asset. */
+    completedAt?: number;
+    error?: string;
+    metadataStatus?: FileMetadataStatus;
+}
+export interface UploadProgressState {
+    isVisible: boolean;
+    isMinimized: boolean;
+    totalFiles: number;
+    files: FileProgress[];
+    errors: FileUploadError[];
+    uploadId: number;
+    /**
+     * Whether every row's size was known when the batch opened (the direct-file flow), so
+     * the byte-weighted aggregate is meaningful. The URL flow learns sizes one row at a time.
+     */
+    reportsByteProgress: boolean;
+}
+export interface RootState {
+    uploadProgress: UploadProgressState;
+}
+/** An uploaded asset, with the moment the server confirmed it. */
+export interface CompletedUpload {
+    asset: File;
+    completedAt: number;
+}
+export declare const selectCompletedUploads: ((state: Partial<RootState>) => CompletedUpload[]) & import("reselect").OutputSelectorFields<(args_0: FileProgress[]) => CompletedUpload[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Byte-weighted aggregate progress across the whole batch: `sum(uploadedBytes) / sum(size)`.
+ *
+ * Falls back to count-based progress (settled files / total files) when all sizes are
+ * zero — e.g. URL-flow rows where the file size is unknown up front.
+ */
+export declare const selectAggregateProgress: ((state: RootState) => number) & import("reselect").OutputSelectorFields<(args_0: FileProgress[]) => number, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Whether to show byte-weighted `selectAggregateProgress` rather than `selectCountBasedProgress`.
+ *
+ * Only the flag: byte-weighting needs every size up front. A URL batch learns sizes one row
+ * at a time, so weighting over the sizes known so far makes the header jump backwards at
+ * every file boundary.
+ */
+export declare const selectReportsByteProgress: ((state: RootState) => boolean) & import("reselect").OutputSelectorFields<(args_0: boolean) => boolean, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Row-weighted progress for a batch whose sizes are not known up front (the URL flow).
+ * Each row is worth `1 / total`: settled rows count fully and an in-flight row contributes
+ * `uploadedBytes / size` once it reports bytes, so a multi-URL batch climbs smoothly to
+ * 33 → 67 → 100 and never moves backwards.
+ *
+ * Returns `null` until something has moved — 0% is the frozen signal this flow exists to
+ * remove, so the header stays indeterminate until there's real progress.
+ */
+export declare const selectCountBasedProgress: ((state: RootState) => number | null) & import("reselect").OutputSelectorFields<(args_0: FileProgress[]) => number | null, {
+    clearCache: () => void;
+}> & {
+    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[];
+    fileSizes?: number[];
+}, "uploadProgress/openUploadProgress">, appendUploadFiles: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    uploadId: number;
+    fileNames: string[];
+    fileSizes?: number[];
+}, "uploadProgress/appendUploadFiles">, setFileUploading: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    name: string;
+    index: number;
+    size: number;
+    uploadId: number;
+}, "uploadProgress/setFileUploading">, setFileProgress: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    index: number;
+    bytes: number;
+    uploadId: number;
+    size?: number;
+}, "uploadProgress/setFileProgress">, setFileComplete: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    index: number;
+    file: File;
+    uploadId: number;
+    completedAt: number;
+}, "uploadProgress/setFileComplete">, setFileError: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    index: number;
+    name: string;
+    message: string;
+    uploadId: number;
+}, "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">;
+/**
+ * The merge/reset switch. Errored and cancelled rows count as settled, so a
+ * batch that finished badly is still replaced by the next drop.
+ */
+export declare const isUploadInFlight: (files: ReadonlyArray<{
+    status: FileProgressStatus;
+}>) => boolean;
+export declare const uploadProgressReducer: import("redux").Reducer<UploadProgressState>;

package/dist/admin/src/utils/canDropItemOnFolder.d.ts

@@ -0,0 +1,9 @@
+import type { FolderNode } from '../../../shared/contracts/folders';
+import type { DragItemData } from '../types/dnd';
+export interface CanDropItemOnFolderParams {
+    items: DragItemData[];
+    targetFolderId: number | null;
+    folderStructure: FolderNode[];
+}
+export declare const isFolderDescendantOf: (folderStructure: FolderNode[], ancestorId: number, candidateId: number) => boolean;
+export declare const canDropItemOnFolder: ({ items, targetFolderId, folderStructure, }: CanDropItemOnFolderParams) => boolean;

package/dist/admin/src/utils/downloadFile.d.ts

@@ -1 +1,6 @@
+/**
+ * Fetch a file at `url` and trigger a browser download with the given filename.
+ * Goes via a blob + temporary anchor so we honour the `download` attribute
+ * even when the file is served same-origin without `Content-Disposition`.
+ */
 export declare const downloadFile: (url: string, fileName: string) => Promise<void>;

package/dist/admin/src/utils/flattenFolderStructure.d.ts

@@ -0,0 +1,18 @@
+import type { FolderNode } from '../../../shared/contracts/folders';
+export interface FlatFolderOption {
+    id: number;
+    /** Full ancestry label, e.g. "About / Images". */
+    label: string;
+}
+/**
+ * Flattens the nested folder structure (`/upload/folder-structure`) into a
+ * depth-first list of `{ id, label }` options where the label carries the full
+ * ancestry path. Used by destination selects so folders sharing a name stay
+ * distinguishable ("About / Images" vs "Tech / Images"), with children listed
+ * right under their parent.
+ *
+ * `excludeSubtreeIds` prunes a folder *and everything below it* in the same
+ * single pass — used to drop the selected folders (and their descendants) from
+ * bulk-move destinations without re-walking the tree per option.
+ */
+export declare const flattenFolderStructure: (nodes: FolderNode[], excludeSubtreeIds?: ReadonlySet<number>, parentLabel?: string) => FlatFolderOption[];

package/dist/admin/src/utils/getFolderLabel.d.ts

@@ -0,0 +1,11 @@
+import type { FolderNode } from '../../../shared/contracts/folders';
+/**
+ * Leaf display name for a folder id. `null` (root) → the Media Library label.
+ * Used by both the DnD success toast and the dialog success toast so the two
+ * paths name folders identically. Ancestry paths belong only in the dialog's
+ * select options (see `flattenFolderStructure`).
+ *
+ * `id === null` returns `rootLabel`; an unknown id falls back to `rootLabel`
+ * too (defensive — mirrors the dialog's previous `?? rootLabel`).
+ */
+export declare const getFolderLabel: (folderStructure: FolderNode[], id: number | null, rootLabel: string) => string;