@strapi/upload 5.51.1 → 5.51.2

package/dist/admin/shared/constants.mjs

@@ -0,0 +1,38 @@
+/**
+ * Constants shared by the upload server and the admin panel.
+ *
+ * The server stays authoritative — it validates and rejects — but the admin
+ * needs the same values to disable actions up front rather than letting the
+ * user discover a limit through a failed request.
+ */ /**
+ * Image formats the AI metadata provider can read.
+ *
+ * Anything outside this list (non-images, but also exotic image formats like
+ * SVG or TIFF) is reported as `skipped` instead of being sent.
+ *
+ * @see https://ai.google.dev/gemini-api/docs/image-understanding
+ */ const AI_METADATA_SUPPORTED_IMAGE_TYPES = [
+    'image/png',
+    'image/jpeg',
+    'image/webp',
+    'image/heic',
+    'image/heif'
+];
+/**
+ * Whether the AI metadata provider can generate metadata for this mime type.
+ */ const isAIMetadataSupportedMime = (mime)=>AI_METADATA_SUPPORTED_IMAGE_TYPES.includes(mime);
+/**
+ * Number of images sent to the AI server per request when generating metadata
+ * for an explicit selection. Matches the URL cap of the bulk URL upload flow.
+ */ const AI_METADATA_CHUNK_SIZE = 20;
+/**
+ * Upper bound on a single synchronous AI metadata request.
+ *
+ * The selection is processed in sequential chunks inside one HTTP request, so
+ * an unbounded selection means an unbounded request — long past most proxy and
+ * load balancer timeouts, with no way for the client to learn what was written.
+ * Rejecting with a 400 lets the UI ask for a smaller selection instead.
+ */ const AI_METADATA_MAX_FILES = AI_METADATA_CHUNK_SIZE * 2;
+
+export { AI_METADATA_CHUNK_SIZE, AI_METADATA_MAX_FILES, AI_METADATA_SUPPORTED_IMAGE_TYPES, isAIMetadataSupportedMime };
+//# sourceMappingURL=constants.mjs.map

package/dist/admin/shared/constants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mjs","sources":["../../../shared/constants.ts"],"sourcesContent":["/**\n * Constants shared by the upload server and the admin panel.\n *\n * The server stays authoritative — it validates and rejects — but the admin\n * needs the same values to disable actions up front rather than letting the\n * user discover a limit through a failed request.\n */\n\n/**\n * Image formats the AI metadata provider can read.\n *\n * Anything outside this list (non-images, but also exotic image formats like\n * SVG or TIFF) is reported as `skipped` instead of being sent.\n *\n * @see https://ai.google.dev/gemini-api/docs/image-understanding\n */\nexport const AI_METADATA_SUPPORTED_IMAGE_TYPES = [\n  'image/png',\n  'image/jpeg',\n  'image/webp',\n  'image/heic',\n  'image/heif',\n] as const;\n\nexport type AIMetadataSupportedImageType = (typeof AI_METADATA_SUPPORTED_IMAGE_TYPES)[number];\n\n/**\n * Whether the AI metadata provider can generate metadata for this mime type.\n */\nexport const isAIMetadataSupportedMime = (mime?: string | null): boolean =>\n  AI_METADATA_SUPPORTED_IMAGE_TYPES.includes(mime as AIMetadataSupportedImageType);\n\n/**\n * Number of images sent to the AI server per request when generating metadata\n * for an explicit selection. Matches the URL cap of the bulk URL upload flow.\n */\nexport const AI_METADATA_CHUNK_SIZE = 20;\n\n/**\n * Upper bound on a single synchronous AI metadata request.\n *\n * The selection is processed in sequential chunks inside one HTTP request, so\n * an unbounded selection means an unbounded request — long past most proxy and\n * load balancer timeouts, with no way for the client to learn what was written.\n * Rejecting with a 400 lets the UI ask for a smaller selection instead.\n */\nexport const AI_METADATA_MAX_FILES = AI_METADATA_CHUNK_SIZE * 2;\n"],"names":["AI_METADATA_SUPPORTED_IMAGE_TYPES","isAIMetadataSupportedMime","mime","includes","AI_METADATA_CHUNK_SIZE","AI_METADATA_MAX_FILES"],"mappings":"AAAA;;;;;;;;;;;;;UAgBaA,iCAAAA,GAAoC;AAC/C,IAAA,WAAA;AACA,IAAA,YAAA;AACA,IAAA,YAAA;AACA,IAAA,YAAA;AACA,IAAA;;AAKF;;UAGaC,yBAAAA,GAA4B,CAACC,OACxCF,iCAAAA,CAAkCG,QAAQ,CAACD,IAAAA;AAE7C;;;IAIO,MAAME,sBAAAA,GAAyB;AAEtC;;;;;;;AAOC,IACM,MAAMC,qBAAAA,GAAwBD,sBAAAA,GAAyB;;;;"}

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

@@ -0,0 +1,21 @@
+/**
+ * RBAC gate for the future Media Library UI. Mirrors the legacy hook of the
+ * same name: the server already enforces every action route-side (assets and
+ * folder operations share the asset permissions — folder create requires
+ * `assets.create`, folder rename/move/delete require `assets.update`); this
+ * hook is what keeps the UI honest so users don't discover a missing
+ * permission through a 403.
+ *
+ * - `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
+ *   "Update (crop, details, replace) + delete" by definition
+ * - `canDownload` / `canCopyLink` — the matching drawer actions
+ */
+export declare const useMediaLibraryPermissions: () => {
+    isLoading: boolean;
+    canCreate: boolean;
+    canUpdate: boolean;
+    canDownload: boolean;
+    canCopyLink: boolean;
+};

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

@@ -5,6 +5,12 @@ interface AssetCropEditorProps {
     onClose: () => void;
     onApply: (file: globalThis.File, focalPoint: FocalPoint) => void;
     onSaveAsCopy: (file: globalThis.File, focalPoint: FocalPoint) => void;
+    /**
+     * "Save as copy" creates a new asset (`assets.create`), a different permission
+     * from cropping in place (`assets.update`). Hidden when the user lacks it, so
+     * an update-only role can't trigger a 403.
+     */
+    canSaveAsCopy: boolean;
 }
-export declare const AssetCropEditor: ({ asset, isBusy, onClose, onApply, onSaveAsCopy, }: AssetCropEditorProps) => import("react/jsx-runtime").JSX.Element;
+export declare const AssetCropEditor: ({ asset, isBusy, onClose, onApply, onSaveAsCopy, canSaveAsCopy, }: AssetCropEditorProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,5 @@
+/**
+ * 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;

package/dist/admin/src/future/pages/Assets/components/BulkActionsBar.d.ts

@@ -1 +1,14 @@
-export declare const BulkActionsBar: () => import("react/jsx-runtime").JSX.Element | null;
+import type { File } from '../../../../../../shared/contracts/files';
+interface BulkActionsBarProps {
+    /**
+     * The assets currently rendered in the list, used to resolve the mime types
+     * of the selection — the bar needs them to know which selected assets the AI
+     * provider can actually read.
+     *
+     * Selection is page-scoped and cleared whenever the list identity changes, so
+     * every selected asset id is guaranteed to appear here.
+     */
+    assets?: File[];
+}
+export declare const BulkActionsBar: ({ assets }: BulkActionsBarProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/admin/src/future/pages/Assets/components/DateRangeCalendar.d.ts

@@ -0,0 +1,8 @@
+interface DateRangeCalendarProps {
+    /** `YYYY-MM-DD`, both set when editing an existing range badge. */
+    from?: string;
+    to?: string;
+    onSelect: (from: string, to: string) => void;
+}
+export declare const DateRangeCalendar: ({ from, to, onSelect }: DateRangeCalendarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/future/pages/Assets/components/DropZone/UploadDropZoneContext.d.ts

@@ -3,8 +3,15 @@ type DropHandler = (files: File[]) => void | Promise<void>;
 interface UploadDropZoneProps {
     children: ReactNode;
     onDrop?: DropHandler;
+    /**
+     * When true, the zone never enters the dragging state and never fires
+     * `onDrop` — no overlay, no "drop here" invitation. Used to hide the whole
+     * upload affordance from users without `assets.create`, so they don't drag a
+     * file onto an inviting target that then silently discards it.
+     */
+    disabled?: boolean;
 }
-export declare const UploadDropZoneProvider: ({ children, onDrop }: UploadDropZoneProps) => import("react/jsx-runtime").JSX.Element;
+export declare const UploadDropZoneProvider: ({ children, onDrop, disabled, }: UploadDropZoneProps) => import("react/jsx-runtime").JSX.Element;
 export declare const useUploadDropZone: () => {
     isDragging: boolean;
 };

package/dist/admin/src/future/pages/Assets/components/EmptyState.d.ts

@@ -1,5 +1,13 @@
 interface EmptyStateProps {
     onAddAssets: () => void;
+    /**
+     * RBAC gate — without `assets.create` the "Add assets" CTA is hidden.
+     * Required (not defaulted) so a permission gate can't silently regress to
+     * permissive when a future call site forgets to pass it.
+     */
+    canAddAssets: boolean;
+    searchQuery?: string;
+    onClearSearch?: () => void;
 }
 /**
  * Empty state for the assets list (both views) when the current folder holds
@@ -7,5 +15,14 @@ interface EmptyStateProps {
  * as New > File upload; drag-and-drop upload keeps working since the page-wide
  * drop zone wraps this component.
  */
-export declare const EmptyState: ({ onAddAssets }: EmptyStateProps) => import("react/jsx-runtime").JSX.Element;
+export declare const EmptyState: ({ onAddAssets, canAddAssets, searchQuery, onClearSearch, }: EmptyStateProps) => import("react/jsx-runtime").JSX.Element;
+interface FilteredEmptyStateProps {
+    onClearFilters: () => void;
+}
+/**
+ * Empty state when active filters match nothing (including contradictory
+ * badges — allowed by design). Distinct from the no-content state: the library
+ * has items, the filters exclude them all.
+ */
+export declare const FilteredEmptyState: ({ onClearFilters }: FilteredEmptyStateProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/admin/src/future/pages/Assets/components/FilterBadges.d.ts

@@ -0,0 +1,6 @@
+import { type ListFilters } from '../hooks/useListFilters';
+interface FilterBadgesProps {
+    listFilters: ListFilters;
+}
+export declare const FilterBadges: ({ listFilters }: FilterBadgesProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/admin/src/future/pages/Assets/components/FilterMenu.d.ts

@@ -0,0 +1,22 @@
+import { type DateField, type DatePreset, type ListFilters, type TypeValue } from '../hooks/useListFilters';
+import type { MessageDescriptor } from 'react-intl';
+export declare const TYPE_LABELS: Record<TypeValue, MessageDescriptor>;
+export declare const PRESET_LABELS: Record<DatePreset, MessageDescriptor>;
+export declare const DATE_FIELD_LABELS: Record<DateField, MessageDescriptor>;
+/** Every panel of the filter tree shares this fixed width (design). */
+export declare const FILTER_PANEL_WIDTH = "24.2rem";
+interface FilterMenuProps {
+    listFilters: ListFilters;
+}
+/**
+ * Toolbar "Filter" dropdown. Picking anything ADDS a badge (editing happens on
+ * the badge itself, see FilterBadges):
+ *
+ * - Type → keep-open checkbox list; the badge is created/updated live with the
+ *   checked set (`is` by default, condition editable on the badge).
+ * - Creation date / Last modified → preset list (single pick, `within the
+ *   last` by default) + "Select date range" (creation date only) opening the
+ *   range calendar; a completed range adds an `is` range badge.
+ */
+export declare const FilterMenu: ({ listFilters }: FilterMenuProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -1,5 +1,10 @@
 interface FolderTreeProps {
     currentFolderId: number | null;
+    /**
+     * Set to `false` while a global asset search is active: the results span the
+     * whole library, so highlighting one folder would misrepresent them.
+     * */
+    showActiveFolder?: boolean;
     onSelectFolder: (folderId: number | null) => void;
 }
 /**
@@ -7,13 +12,17 @@ interface FolderTreeProps {
  * and renders:
  *
  * 1. A "Media library" title
- * 2. A "Home" entry that clears the folder query param
- * 3. A "FOLDERS" section header
- * 4. The folder tree itself
+ * 2. A filter input that prunes the tree to matching destinations
+ * 3. A "Home" entry that clears the folder query param
+ * 4. A "FOLDERS" section header
+ * 5. The folder tree itself
+ *
+ * The filter is purely local: it never touches the URL and never affects the
+ * asset list, which has its own independent search in the content toolbar.
  *
  * Presentational with respect to routing — navigation is delegated to the parent
  * via `onSelectFolder` so the URL stays the single source of truth (see
  * `useFolderNavigation`).
  */
-export declare const FolderTree: ({ currentFolderId, onSelectFolder }: FolderTreeProps) => import("react/jsx-runtime").JSX.Element;
+export declare const FolderTree: ({ currentFolderId, showActiveFolder, onSelectFolder, }: FolderTreeProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,16 @@
+import type { FolderNode } from '../../../../../../../shared/contracts/folders';
+interface FilterFolderTreeResult {
+    nodes: FolderNode[];
+    /**
+     * Ancestors of a match, which have to be expanded for the match to be
+     * reachable.
+     */
+    expandedIds: number[];
+}
+/**
+ * Prunes the folder tree to nodes that match, or that have a matching
+ * descendant, so a match deep in the hierarchy stays reachable with its ancestor
+ * chain intact.
+ */
+export declare const filterFolderTree: (nodes: FolderNode[], matches: (name: string) => boolean) => FilterFolderTreeResult;
+export {};

package/dist/admin/src/future/pages/Assets/components/SortMenu.d.ts

@@ -12,6 +12,12 @@ interface SortMenuProps {
  * option keeps the menu open (`onSelect` preventDefault) so several facets can
  * be tuned in one visit; clicking a checked facet clears it (the hook
  * guarantees at least one sort rule stays active).
+ *
+ * Each section is single-select, so its items are radios: the checkmark icon is
+ * decorative, and `aria-checked` is what assistive tech reads. The DS `Menu`
+ * exposes no `RadioItem`, but `Menu.Item` forwards extra props onto the element
+ * it renders through Radix's `asChild`, where they take precedence over Radix's
+ * own `role="menuitem"`.
  */
 export declare const SortMenu: ({ sort, showFoldersGroup }: SortMenuProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,12 @@
+/**
+ * Reads and writes the global asset search term held in `?_q=`.
+ *
+ * Debouncing is the input component's job (see `AssetsSearchInput`) — this hook
+ * is a thin URL accessor so every consumer reads the same source of truth.
+ */
+export declare const useAssetSearch: () => {
+    searchQuery: string;
+    isSearching: boolean;
+    setSearchQuery: (value: string) => void;
+    clearSearch: () => void;
+};

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

@@ -32,8 +32,15 @@ export interface AssetSelection {
 }
 interface AssetSelectionProviderProps {
     children: ReactNode;
+    /**
+     * When true, selection is inert: every mutator is a no-op and nothing ever
+     * reads as selected. Every bulk action is gated on `assets.update`, so a user
+     * without it has nothing to select for — the views also hide the checkboxes,
+     * and this makes the remaining paths (click-to-select, Space key) do nothing.
+     */
+    disabled?: boolean;
 }
-export declare const AssetSelectionProvider: ({ children }: AssetSelectionProviderProps) => import("react").FunctionComponentElement<import("react").ProviderProps<AssetSelection | null>>;
+export declare const AssetSelectionProvider: ({ children, disabled, }: AssetSelectionProviderProps) => import("react").FunctionComponentElement<import("react").ProviderProps<AssetSelection | null>>;
 export declare const useAssetSelection: () => AssetSelection;
 export declare const useAssetSelectionOptional: () => AssetSelection | null;
 export {};

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

@@ -1,12 +1,22 @@
-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>[];
+    /**
+     * Stable fingerprint of `filters` — a change resets the accumulated pages
+     * (the array identity itself changes every render).
+     */
+    filtersKey?: string;
+    /** Structural switch: an `is [folder]`-only type badge means no file can match. */
+    enabled?: boolean;
 }
-declare const useInfiniteAssets: ({ folder, sort }?: UseInfiniteAssetsOptions) => {
+declare const useInfiniteAssets: ({ folder, sort, search, filters, filtersKey, enabled, }?: UseInfiniteAssetsOptions) => {
     assets: File[];
-    pagination: import("../../../../../../shared/contracts/files").Pagination | undefined;
+    pagination: Pagination | undefined;
     isLoading: boolean;
     isFetchingMore: boolean;
     hasNextPage: boolean;

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[];

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 };