node_modules ignore

server/node_modules/@strapi/upload/dist/admin/src/components/AssetCard/AssetCard.d.ts

@@ -0,0 +1,18 @@
+import type { File } from '../../../../shared/contracts/files';
+type FileSelectable = File & {
+    isSelectable?: boolean;
+};
+export type AllowedTypes = 'files' | 'images' | 'videos' | 'audios';
+interface AssetCardProps {
+    asset: FileSelectable;
+    local?: boolean;
+    onSelect?: (asset: FileSelectable) => void;
+    onEdit?: (asset: FileSelectable) => void;
+    onRemove?: (asset: FileSelectable) => void;
+    isSelected?: boolean;
+    size?: 'S' | 'M';
+    allowedTypes?: AllowedTypes[];
+    alt?: string;
+}
+export declare const AssetCard: ({ asset, isSelected, onSelect, onEdit, onRemove, size, local, }: AssetCardProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/AssetCard/AssetCardBase.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+export interface AssetCardBaseProps {
+    children?: React.ReactNode;
+    extension: string;
+    isSelectable?: boolean;
+    name: string;
+    onSelect?: () => void;
+    onRemove?: () => void;
+    onEdit?: (event: React.MouseEvent<HTMLButtonElement, MouseEvent> | React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+    selected?: boolean;
+    subtitle?: string;
+    variant: 'Image' | 'Video' | 'Audio' | 'Doc';
+}
+export declare const AssetCardBase: ({ children, extension, isSelectable, name, onSelect, onRemove, onEdit, selected, subtitle, variant, }: AssetCardBaseProps) => import("react/jsx-runtime").JSX.Element;

server/node_modules/@strapi/upload/dist/admin/src/components/AssetCard/AudioAssetCard.d.ts

@@ -0,0 +1,7 @@
+import { AssetCardBaseProps } from './AssetCardBase';
+interface AudioAssetCardProps extends Omit<AssetCardBaseProps, 'variant' | 'children'> {
+    size?: 'S' | 'M';
+    url: string;
+}
+export declare const AudioAssetCard: ({ name, url, size, selected, ...restProps }: AudioAssetCardProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/AssetCard/AudioPreview.d.ts

@@ -0,0 +1,6 @@
+interface AudioPreviewProps {
+    alt: string;
+    url: string;
+}
+export declare const AudioPreview: ({ url, alt }: AudioPreviewProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/AssetCard/DocAssetCard.d.ts

@@ -0,0 +1,7 @@
+import { AssetCardBaseProps } from './AssetCardBase';
+interface DocAssetCardProps extends Omit<AssetCardBaseProps, 'variant' | 'children'> {
+    size?: 'S' | 'M';
+    extension: string;
+}
+export declare const DocAssetCard: ({ name, extension, size, selected, ...restProps }: DocAssetCardProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/AssetCard/ImageAssetCard.d.ts

@@ -0,0 +1,12 @@
+import { AssetCardBaseProps } from './AssetCardBase';
+interface ImageAssetCardProps extends Omit<AssetCardBaseProps, 'variant' | 'children'> {
+    height?: number;
+    width?: number;
+    size?: 'S' | 'M';
+    thumbnail: string;
+    alt: string;
+    updatedAt?: string;
+    isUrlSigned: boolean;
+}
+export declare const ImageAssetCard: ({ height, width, thumbnail, size, alt, isUrlSigned, selected, ...props }: ImageAssetCardProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/AssetCard/UploadingAssetCard.d.ts

@@ -0,0 +1,17 @@
+import { AssetType } from '../../constants';
+import type { RawFile, File } from '../../../../shared/contracts/files';
+interface UploadingAssetCardProps {
+    onCancel: (rawFile: RawFile) => void;
+    onStatusChange: (status: string) => void;
+    addUploadedFiles: (files: File[]) => void;
+    folderId?: string | number | null;
+    asset: Asset;
+    id?: string;
+    size?: 'S' | 'M';
+}
+interface Asset extends File {
+    rawFile?: RawFile;
+    type?: AssetType;
+}
+export declare const UploadingAssetCard: ({ asset, onCancel, onStatusChange, addUploadedFiles, folderId, }: UploadingAssetCardProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/AssetCard/VideoAssetCard.d.ts

@@ -0,0 +1,8 @@
+import { AssetCardBaseProps } from './AssetCardBase';
+interface VideoAssetCardProps extends Omit<AssetCardBaseProps, 'variant' | 'children'> {
+    mime: string;
+    url: string;
+    size?: 'S' | 'M';
+}
+export declare const VideoAssetCard: ({ name, url, mime, size, selected, ...props }: VideoAssetCardProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/AssetCard/VideoPreview.d.ts

@@ -0,0 +1,9 @@
+interface VideoPreviewProps {
+    alt: string;
+    url: string;
+    mime: string;
+    onLoadDuration?: (duration?: number) => void;
+    size?: 'S' | 'M';
+}
+export declare const VideoPreview: ({ url, mime, onLoadDuration, alt, ...props }: VideoPreviewProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/AssetDialog/AssetDialog.d.ts

@@ -0,0 +1,39 @@
+import type { File as Asset } from '../../../../shared/contracts/files';
+import type { Folder } from '../../../../shared/contracts/folders';
+import type { AllowedTypes } from '../AssetCard/AssetCard';
+export interface FileRow extends Asset {
+    folderURL?: string;
+    isSelectable?: boolean;
+    type?: string;
+}
+export interface FolderRow extends Folder {
+    folderURL?: string;
+    isSelectable?: boolean;
+    type?: string;
+}
+interface AssetContentProps {
+    allowedTypes?: AllowedTypes[];
+    folderId?: number | null;
+    onClose: () => void;
+    onAddAsset: (arg?: {
+        folderId: number | {
+            id: number;
+        } | null | undefined;
+    }) => void;
+    onAddFolder: ({ folderId }: {
+        folderId: number | {
+            id: number;
+        } | null | undefined;
+    }) => void;
+    onChangeFolder: (folderId: number | null) => void;
+    onValidate: (selectedAssets: Asset[]) => void;
+    multiple?: boolean;
+    trackedLocation?: string;
+    initiallySelectedAssets?: Asset[];
+}
+export declare const AssetContent: ({ allowedTypes, folderId, onClose, onAddAsset, onAddFolder, onChangeFolder, onValidate, multiple, initiallySelectedAssets, trackedLocation, }: AssetContentProps) => import("react/jsx-runtime").JSX.Element;
+interface AssetDialogProps extends AssetContentProps {
+    open?: boolean;
+}
+export declare const AssetDialog: ({ open, onClose, ...restProps }: AssetDialogProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/AssetDialog/BrowseStep/BrowseStep.d.ts

@@ -0,0 +1,63 @@
+import { FolderRow, FileRow } from '../../TableList/TableList';
+import type { File, Query, FilterCondition } from '../../../../../shared/contracts/files';
+import type { Folder } from '../../../../../shared/contracts/folders';
+import type { AllowedTypes } from '../../AssetCard/AssetCard';
+type NumberKeyedObject = Record<number, string>;
+type StringFilter = {
+    [key: string]: string;
+};
+type MimeFilter = {
+    [key: string]: string | NumberKeyedObject | Record<string, string | NumberKeyedObject> | undefined;
+};
+export type FilterStructure = {
+    [key: string]: MimeFilter | StringFilter | undefined;
+};
+export type Filter = {
+    [key in 'mime' | 'createdAt' | 'updatedAt']?: {
+        [key in '$contains' | '$notContains' | '$eq' | '$not']?: string[] | string | {
+            $contains: string[];
+        };
+    } | undefined;
+};
+export interface FolderWithType extends Omit<Folder, 'children' | 'files'> {
+    folderURL?: string;
+    isSelectable?: boolean;
+    type?: string;
+    children?: Folder['children'] & {
+        count: number;
+    };
+    files?: Folder['files'] & {
+        count: number;
+    };
+}
+export interface FileWithType extends File {
+    folderURL?: string;
+    isSelectable?: boolean;
+    type?: string;
+}
+export interface BrowseStepProps {
+    allowedTypes?: AllowedTypes[];
+    assets: File[];
+    canCreate: boolean;
+    canRead: boolean;
+    folders?: FolderWithType[];
+    multiple?: boolean;
+    onAddAsset: () => void;
+    onChangeFilters: (filters: FilterCondition<string>[] | Filter[]) => void;
+    onChangeFolder: (id: number, path?: string) => void;
+    onChangePage: (page: number) => void;
+    onChangePageSize: (value: number) => void;
+    onChangeSort: (value: Query['sort'] | string) => void;
+    onChangeSearch: (_q?: Query['_q'] | null) => void;
+    onEditAsset: ((asset: FileWithType) => void) | null;
+    onEditFolder: ((folder: FolderRow) => void) | null;
+    onSelectAsset: (element: FileRow | FolderRow) => void;
+    onSelectAllAsset?: (checked: boolean | string, rows?: FolderRow[] | FileRow[]) => void;
+    queryObject: Query;
+    pagination: {
+        pageCount: number;
+    };
+    selectedAssets: FileWithType[] | FolderWithType[];
+}
+export declare const BrowseStep: ({ allowedTypes, assets: rawAssets, canCreate, canRead, folders, multiple, onAddAsset, onChangeFilters, onChangePage, onChangePageSize, onChangeSearch, onChangeSort, onChangeFolder, onEditAsset, onEditFolder, onSelectAllAsset, onSelectAsset, pagination, queryObject, selectedAssets, }: BrowseStepProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/AssetDialog/BrowseStep/Filters.d.ts

@@ -0,0 +1,23 @@
+type NumberKeyedObject = Record<number, string>;
+type StringFilter = {
+    [key: string]: string;
+};
+type MimeFilter = {
+    [key: string]: string | NumberKeyedObject | Record<string, string | NumberKeyedObject> | undefined;
+};
+export type FilterStructure = {
+    [key: string]: MimeFilter | StringFilter | undefined;
+};
+export type Filter = {
+    [key in 'mime' | 'createdAt' | 'updatedAt']?: {
+        [key in '$contains' | '$notContains' | '$eq' | '$not']?: string[] | string | {
+            $contains: string[];
+        };
+    } | undefined;
+};
+interface FiltersProps {
+    appliedFilters: FilterStructure[];
+    onChangeFilters: (filters: Filter[]) => void;
+}
+export declare const Filters: ({ appliedFilters, onChangeFilters }: FiltersProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/AssetDialog/BrowseStep/PageSize.d.ts

@@ -0,0 +1,6 @@
+interface PageSizeProps {
+    onChangePageSize: (value: number) => void;
+    pageSize: number;
+}
+export declare const PageSize: ({ onChangePageSize, pageSize }: PageSizeProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/AssetDialog/BrowseStep/PaginationFooter/Pagination.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+export declare const usePagination: () => {
+    activePage: number;
+    pageCount: number;
+};
+interface PaginationProps {
+    activePage: number;
+    children: React.ReactNode;
+    label?: string;
+    pageCount: number;
+}
+export declare const Pagination: ({ children, activePage, pageCount, label, }: PaginationProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/AssetDialog/BrowseStep/PaginationFooter/PaginationFooter.d.ts

@@ -0,0 +1,9 @@
+interface PaginationFooterProps {
+    activePage: number;
+    onChangePage: (page: number) => void;
+    pagination: {
+        pageCount: number;
+    };
+}
+export declare const PaginationFooter: ({ activePage, onChangePage, pagination: { pageCount }, }: PaginationFooterProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/AssetDialog/BrowseStep/SearchAsset/SearchAsset.d.ts

@@ -0,0 +1,7 @@
+import type { Query } from '../../../../../../shared/contracts/files';
+interface SearchAssetProps {
+    onChangeSearch: (_q: Query['_q'] | null) => void;
+    queryValue?: Query['_q'] | null;
+}
+export declare const SearchAsset: ({ onChangeSearch, queryValue }: SearchAssetProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/AssetDialog/BrowseStep/utils/isSelectable.d.ts

@@ -0,0 +1 @@
+export declare const isSelectable: (allowedTypes: string[], mime?: string) => boolean;

server/node_modules/@strapi/upload/dist/admin/src/components/AssetDialog/DialogFooter.d.ts

@@ -0,0 +1,6 @@
+interface DialogFooterProps {
+    onClose: () => void;
+    onValidate?: () => void;
+}
+export declare const DialogFooter: ({ onClose, onValidate }: DialogFooterProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/AssetDialog/SelectedStep/SelectedStep.d.ts

@@ -0,0 +1,8 @@
+import type { File } from '../../../../../shared/contracts/files';
+interface SelectedStepProps {
+    onSelectAsset: (asset: File) => void;
+    selectedAssets: File[];
+    onReorderAsset?: (fromIndex: number, toIndex: number) => void;
+}
+export declare const SelectedStep: ({ selectedAssets, onSelectAsset, onReorderAsset, }: SelectedStepProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/AssetGridList/AssetGridList.d.ts

@@ -0,0 +1,13 @@
+import type { File } from '../../../../shared/contracts/files';
+import type { AllowedTypes } from '../AssetCard/AssetCard';
+export interface AssetGridListProps {
+    allowedTypes?: AllowedTypes[];
+    assets: File[];
+    onEditAsset?: (asset: File) => void;
+    onSelectAsset: (asset: File) => void;
+    selectedAssets: File[];
+    size?: 'S' | 'M';
+    onReorderAsset?: (fromIndex: number, toIndex: number) => void;
+    title?: string | null;
+}
+export declare const AssetGridList: ({ allowedTypes, assets, onEditAsset, onSelectAsset, selectedAssets, size, onReorderAsset, title, }: AssetGridListProps) => import("react/jsx-runtime").JSX.Element;

server/node_modules/@strapi/upload/dist/admin/src/components/AssetGridList/Draggable.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+interface DraggableProps {
+    id: string | number;
+    index: number;
+    children: React.ReactNode;
+    moveItem: (fromIndex: number, toIndex: number) => void;
+}
+export declare const Draggable: ({ children, id, index, moveItem }: DraggableProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/Breadcrumbs/Breadcrumbs.d.ts

@@ -0,0 +1,14 @@
+import { BreadcrumbsProps as BaseBreadcrumbsProps } from '@strapi/design-system';
+import { MessageDescriptor } from 'react-intl';
+export type CrumbDefinition = {
+    id?: number | null;
+    label?: MessageDescriptor | string;
+    href?: string;
+    path?: string;
+};
+export interface BreadcrumbsProps extends BaseBreadcrumbsProps {
+    breadcrumbs: Array<CrumbDefinition>;
+    currentFolderId?: number;
+    onChangeFolder?: (id: number, path?: string) => void;
+}
+export declare const Breadcrumbs: ({ breadcrumbs, onChangeFolder, currentFolderId, ...props }: BreadcrumbsProps) => import("react/jsx-runtime").JSX.Element;

server/node_modules/@strapi/upload/dist/admin/src/components/Breadcrumbs/CrumbSimpleMenuAsync.d.ts

@@ -0,0 +1,7 @@
+interface CrumbSimpleMenuAsyncProps {
+    parentsToOmit?: number[];
+    currentFolderId?: number;
+    onChangeFolder?: (id: number, path?: string) => void;
+}
+export declare const CrumbSimpleMenuAsync: ({ parentsToOmit, currentFolderId, onChangeFolder, }: CrumbSimpleMenuAsyncProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/BulkMoveDialog/BulkMoveDialog.d.ts

@@ -0,0 +1,15 @@
+import { File } from '../../../../shared/contracts/files';
+import type { Folder } from '../../../../shared/contracts/folders';
+interface FolderWithType extends Folder {
+    type: string;
+}
+interface FileWithType extends File {
+    type: string;
+}
+export interface BulkMoveDialogProps {
+    onClose: () => void;
+    selected?: Array<FolderWithType | FileWithType>;
+    currentFolder?: FolderWithType;
+}
+export declare const BulkMoveDialog: ({ onClose, selected, currentFolder }: BulkMoveDialogProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/ContextInfo/ContextInfo.d.ts

@@ -0,0 +1,8 @@
+interface ContextInfoProps {
+    blocks: {
+        label: string;
+        value: string | number | null;
+    }[];
+}
+export declare const ContextInfo: ({ blocks }: ContextInfoProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/CopyLinkButton/CopyLinkButton.d.ts

@@ -0,0 +1,3 @@
+export declare const CopyLinkButton: ({ url }: {
+    url: string;
+}) => import("react/jsx-runtime").JSX.Element;

server/node_modules/@strapi/upload/dist/admin/src/components/EditAssetDialog/DialogHeader.d.ts

@@ -0,0 +1 @@
+export declare const DialogHeader: () => import("react/jsx-runtime").JSX.Element;

server/node_modules/@strapi/upload/dist/admin/src/components/EditAssetDialog/EditAssetContent.d.ts

@@ -0,0 +1,28 @@
+import type { File as FileDefinition, RawFile } from '../../../../shared/contracts/files';
+export interface Asset extends Omit<FileDefinition, 'folder'> {
+    isLocal?: boolean;
+    rawFile?: RawFile;
+    folder?: FileDefinition['folder'] & {
+        id: number;
+    };
+}
+interface EditAssetContentProps {
+    asset?: Asset;
+    canUpdate?: boolean;
+    canCopyLink?: boolean;
+    canDownload?: boolean;
+    trackedLocation?: string;
+    onClose: (arg?: Asset | null | boolean) => void;
+}
+export declare const EditAssetContent: ({ onClose, asset, canUpdate, canCopyLink, canDownload, trackedLocation, }: EditAssetContentProps) => import("react/jsx-runtime").JSX.Element;
+interface EditAssetDialogProps {
+    asset: Asset;
+    canUpdate?: boolean;
+    canCopyLink?: boolean;
+    canDownload?: boolean;
+    trackedLocation?: string;
+    open: boolean;
+    onClose: (arg?: Asset | null | boolean) => void;
+}
+export declare const EditAssetDialog: ({ open, onClose, canUpdate, canCopyLink, canDownload, ...restProps }: EditAssetDialogProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/EditAssetDialog/PreviewBox/AssetPreview.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+interface AssetPreviewProps {
+    mime: string;
+    name: string;
+    url: string;
+    onLoad?: () => void;
+}
+export declare const AssetPreview: React.ForwardRefExoticComponent<AssetPreviewProps & React.RefAttributes<HTMLAudioElement | HTMLVideoElement | HTMLImageElement>>;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/EditAssetDialog/PreviewBox/CroppingActions.d.ts

@@ -0,0 +1,7 @@
+interface CroppingActionsProps {
+    onCancel: () => void;
+    onValidate: () => void;
+    onDuplicate?: () => void;
+}
+export declare const CroppingActions: ({ onCancel, onValidate, onDuplicate }: CroppingActionsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/EditAssetDialog/PreviewBox/PreviewBox.d.ts

@@ -0,0 +1,23 @@
+import type { File as FileDefinition, RawFile } from '../../../../../shared/contracts/files';
+import 'cropperjs/dist/cropper.css';
+interface Asset extends Omit<FileDefinition, 'folder'> {
+    isLocal?: boolean;
+    rawFile?: RawFile;
+    folder?: FileDefinition['folder'] & {
+        id: number;
+    };
+}
+interface PreviewBoxProps {
+    asset: Asset;
+    canUpdate: boolean;
+    canCopyLink: boolean;
+    canDownload: boolean;
+    replacementFile?: File;
+    onDelete: (asset?: Asset | null) => void;
+    onCropFinish: () => void;
+    onCropStart: () => void;
+    onCropCancel: () => void;
+    trackedLocation?: string;
+}
+export declare const PreviewBox: ({ asset, canUpdate, canCopyLink, canDownload, onDelete, onCropFinish, onCropStart, onCropCancel, replacementFile, trackedLocation, }: PreviewBoxProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/EditAssetDialog/PreviewBox/PreviewComponents.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+export declare const RelativeBox: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").FastOmit<Omit<import("@strapi/design-system").TransientBoxProps & {
+    children?: import("react").ReactNode;
+} & import("@strapi/design-system/dist/types").AsProp<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
+    ref?: any;
+}, "ref"> & {
+    ref?: any;
+}, never>> & Omit<import("@strapi/design-system").BoxComponent<"div">, keyof import("react").Component<any, {}, any>>;
+export declare const Wrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>;
+export declare const ActionRow: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").FastOmit<Omit<Omit<import("@strapi/design-system").FlexProps<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>>, "ref"> & import("react").RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void) | import("react").RefObject<unknown> | null | undefined;
+}, never>> & Omit<(<C extends import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements> = "div">(props: import("react").PropsWithoutRef<import("@strapi/design-system").FlexProps<C>> & import("react").RefAttributes<unknown>) => import("react").ReactNode), keyof import("react").Component<any, {}, any>>;
+export declare const CroppingActionRow: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").FastOmit<Omit<Omit<import("@strapi/design-system").FlexProps<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>>, "ref"> & import("react").RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void) | import("react").RefObject<unknown> | null | undefined;
+}, never>> & Omit<(<C extends import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements> = "div">(props: import("react").PropsWithoutRef<import("@strapi/design-system").FlexProps<C>> & import("react").RefAttributes<unknown>) => import("react").ReactNode), keyof import("react").Component<any, {}, any>>;
+export declare const BadgeOverride: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").FastOmit<import("@strapi/design-system").BadgeProps, never>> & Omit<({ active, size, textColor, backgroundColor, children, minWidth, ...props }: import("@strapi/design-system").BadgeProps) => import("react/jsx-runtime").JSX.Element, keyof import("react").Component<any, {}, any>>;
+export declare const UploadProgressWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>;

server/node_modules/@strapi/upload/dist/admin/src/components/EditAssetDialog/RemoveAssetDialog.d.ts

@@ -0,0 +1,8 @@
+import type { File } from '../../../../shared/contracts/files';
+interface RemoveAssetDialogProps {
+    open: boolean;
+    onClose: (open: boolean | null) => void;
+    asset: File;
+}
+export declare const RemoveAssetDialog: ({ open, onClose, asset }: RemoveAssetDialogProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/EditAssetDialog/ReplaceMediaButton.d.ts

@@ -0,0 +1,8 @@
+import { ButtonProps } from '@strapi/design-system';
+interface ReplaceMediaButtonProps extends ButtonProps {
+    acceptedMime: string;
+    onSelectMedia: (file?: File) => void;
+    trackedLocation?: string;
+}
+export declare const ReplaceMediaButton: ({ onSelectMedia, acceptedMime, trackedLocation, ...props }: ReplaceMediaButtonProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/EditFolderDialog/EditFolderDialog.d.ts

@@ -0,0 +1,12 @@
+import type { FolderDefinition } from '../../../../shared/contracts/folders';
+export interface EditFolderDialogProps {
+    parentFolderId?: string | number | null;
+    location?: string;
+    folder?: FolderDefinition;
+    open?: boolean;
+    onClose: (payload?: {
+        created?: boolean | undefined;
+    } | boolean) => void;
+}
+export declare const EditFolderContent: ({ onClose, folder, location, parentFolderId, }: EditFolderDialogProps) => import("react/jsx-runtime").JSX.Element;
+export declare const EditFolderDialog: ({ open, onClose, ...restProps }: EditFolderDialogProps) => import("react/jsx-runtime").JSX.Element;

server/node_modules/@strapi/upload/dist/admin/src/components/EditFolderDialog/ModalHeader/ModalHeader.d.ts

@@ -0,0 +1,5 @@
+interface EditFolderModalHeaderProps {
+    isEditing?: boolean;
+}
+export declare const EditFolderModalHeader: ({ isEditing }: EditFolderModalHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/EditFolderDialog/RemoveFolderDialog.d.ts

@@ -0,0 +1,7 @@
+interface RemoveFolderDialogProps {
+    onClose: () => void;
+    onConfirm: () => void;
+    open: boolean;
+}
+export declare const RemoveFolderDialog: ({ onClose, onConfirm, open }: RemoveFolderDialogProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/EmptyAssets/EmptyAssetGrid.d.ts

@@ -0,0 +1,6 @@
+interface EmptyAssetGridProps {
+    count: number;
+    size: 'S' | 'M';
+}
+export declare const EmptyAssetGrid: ({ count, size }: EmptyAssetGridProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/EmptyAssets/EmptyAssets.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+interface EmptyAssetsProps {
+    action?: React.ReactNode;
+    icon?: React.ElementType;
+    content: string;
+    size?: 'S' | 'M';
+    count?: number;
+}
+export declare const EmptyAssets: ({ icon: Icon, content, action, size, count, }: EmptyAssetsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/FilterList/FilterList.d.ts

@@ -0,0 +1,33 @@
+type NumberKeyedObject = Record<number, string>;
+type StringFilter = {
+    [key: string]: string;
+};
+type MimeFilter = {
+    [key: string]: string | NumberKeyedObject | Record<string, string | NumberKeyedObject> | undefined;
+};
+export type FilterStructure = {
+    [key: string]: MimeFilter | StringFilter | undefined;
+};
+export interface FilterListProps {
+    appliedFilters: FilterStructure[];
+    filtersSchema: {
+        name: string;
+        metadatas?: {
+            label?: string;
+        };
+        fieldSchema?: {
+            type?: string;
+            mainField?: {
+                name: string;
+                type: string;
+            };
+            options?: {
+                label: string;
+                value: string;
+            }[];
+        };
+    }[];
+    onRemoveFilter: (filters: FilterStructure[]) => void;
+}
+export declare const FilterList: ({ appliedFilters, filtersSchema, onRemoveFilter }: FilterListProps) => (import("react/jsx-runtime").JSX.Element | null)[];
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/FilterList/FilterTag.d.ts

@@ -0,0 +1,23 @@
+import type { FilterStructure } from './FilterList';
+type FilterTagAttribute = {
+    fieldSchema?: {
+        type?: string;
+        options?: {
+            label: string;
+            value: string;
+        }[];
+    };
+    metadatas?: {
+        label?: string;
+    };
+    name: string;
+};
+interface FilterTagProps {
+    attribute: FilterTagAttribute;
+    operator: string;
+    value: string;
+    filter: FilterStructure;
+    onClick: (filter: FilterStructure) => void;
+}
+export declare const FilterTag: ({ attribute, filter, onClick, operator, value }: FilterTagProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/FilterPopover/FilterPopover.d.ts

@@ -0,0 +1,31 @@
+type Filter = {
+    [key in 'mime' | 'createdAt' | 'updatedAt']?: {
+        [key in '$contains' | '$notContains' | '$eq' | '$not']?: string[] | string | {
+            $contains: string[];
+        };
+    } | undefined;
+};
+export interface FilterPopoverProps {
+    displayedFilters: {
+        name: string;
+        metadatas?: {
+            label?: string;
+        };
+        fieldSchema: {
+            type: string;
+            options?: {
+                value: string;
+            }[];
+            mainField?: {
+                schema: {
+                    type: string;
+                };
+            };
+        };
+    }[];
+    filters: Filter[];
+    onSubmit: (filters: Filter[]) => void;
+    onToggle: () => void;
+}
+export declare const FilterPopover: ({ displayedFilters, filters, onSubmit, onToggle, }: FilterPopoverProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/FilterPopover/FilterValueInput.d.ts

@@ -0,0 +1,12 @@
+interface FilterValueInputProps {
+    label?: string;
+    onChange: (value: string) => void;
+    options?: {
+        label?: string;
+        value: string;
+    }[];
+    type?: string;
+    value?: string;
+}
+export declare const FilterValueInput: ({ label, onChange, options, type, value, }: FilterValueInputProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/FilterPopover/utils/getFilterList.d.ts

@@ -0,0 +1,21 @@
+interface GetFilterListProps {
+    fieldSchema: {
+        type: string;
+        options?: {
+            value: string;
+        }[];
+        mainField?: {
+            schema: {
+                type: string;
+            };
+        };
+    };
+}
+export declare const getFilterList: ({ fieldSchema: { type: fieldType, mainField }, }: GetFilterListProps) => {
+    intlLabel: {
+        id: string;
+        defaultMessage: string;
+    };
+    value: string;
+}[];
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/FolderCard/FolderCard/FolderCard.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { BoxProps } from '@strapi/design-system';
+import { LinkProps } from 'react-router-dom';
+export interface FolderCardProps extends Omit<BoxProps, 'id'> {
+    ariaLabel: string;
+    children: React.ReactNode;
+    id?: string;
+    startAction?: React.ReactNode;
+    cardActions?: React.ReactNode;
+    onClick?: () => void;
+    to?: LinkProps['to'];
+}
+export declare const FolderCard: React.ForwardRefExoticComponent<Omit<FolderCardProps, "ref"> & React.RefAttributes<unknown>>;

server/node_modules/@strapi/upload/dist/admin/src/components/FolderCard/FolderCardBody/FolderCardBody.d.ts

@@ -0,0 +1,2 @@
+import { FlexProps } from '@strapi/design-system';
+export declare const FolderCardBody: (props: FlexProps) => import("react/jsx-runtime").JSX.Element;

server/node_modules/@strapi/upload/dist/admin/src/components/FolderCard/FolderCardBodyAction/FolderCardBodyAction.d.ts

@@ -0,0 +1,7 @@
+import { BoxProps } from '@strapi/design-system';
+import { LinkProps } from 'react-router-dom';
+interface FolderCardBodyActionProps extends BoxProps {
+    to?: LinkProps['to'];
+}
+export declare const FolderCardBodyAction: ({ to, ...props }: FolderCardBodyActionProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/FolderCard/FolderCardCheckbox/FolderCardCheckbox.d.ts

@@ -0,0 +1,2 @@
+import { CheckboxProps } from '@strapi/design-system';
+export declare const FolderCardCheckbox: (props: CheckboxProps) => import("react/jsx-runtime").JSX.Element;

server/node_modules/@strapi/upload/dist/admin/src/components/FolderCard/contexts/FolderCard.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export declare const FolderCardContext: import("react").Context<{
+    id?: string | undefined;
+}>;
+export declare function useFolderCard(): {
+    id?: string | undefined;
+};

server/node_modules/@strapi/upload/dist/admin/src/components/FolderGridList/FolderGridList.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+export interface FolderGridListProps {
+    children: React.ReactNode;
+    title?: string | null;
+}
+export declare const FolderGridList: ({ title, children }: FolderGridListProps) => import("react/jsx-runtime").JSX.Element;

server/node_modules/@strapi/upload/dist/admin/src/components/MediaLibraryDialog/MediaLibraryDialog.d.ts

@@ -0,0 +1,8 @@
+import type { File } from '../../../../shared/contracts/files';
+import type { AllowedTypes } from '../AssetCard/AssetCard';
+export interface MediaLibraryDialogProps {
+    allowedTypes?: AllowedTypes[];
+    onClose: () => void;
+    onSelectAssets: (selectedAssets: File[]) => void;
+}
+export declare const MediaLibraryDialog: ({ onClose, onSelectAssets, allowedTypes, }: MediaLibraryDialogProps) => import("react/jsx-runtime").JSX.Element;

server/node_modules/@strapi/upload/dist/admin/src/components/MediaLibraryInput/Carousel/CarouselAsset.d.ts

@@ -0,0 +1,4 @@
+import type { File as FileAsset } from '../../../../../shared/contracts/files';
+export declare const CarouselAsset: ({ asset }: {
+    asset: FileAsset;
+}) => import("react/jsx-runtime").JSX.Element;

server/node_modules/@strapi/upload/dist/admin/src/components/MediaLibraryInput/Carousel/CarouselAssetActions.d.ts

@@ -0,0 +1,9 @@
+import type { File } from '../../../../../shared/contracts/files';
+interface CarouselAssetActionsProps {
+    asset: File;
+    onDeleteAsset?: (asset: File) => void;
+    onAddAsset?: (asset: File) => void;
+    onEditAsset?: () => void;
+}
+export declare const CarouselAssetActions: ({ asset, onDeleteAsset, onAddAsset, onEditAsset, }: CarouselAssetActionsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/MediaLibraryInput/Carousel/CarouselAssets.d.ts

@@ -0,0 +1,22 @@
+import * as React from 'react';
+import type { File as FileAsset } from '../../../../../shared/contracts/files';
+export type FileWithoutIdHash = Omit<FileAsset, 'id' | 'hash'>;
+export interface CarouselAssetsProps {
+    assets: FileAsset[];
+    disabled?: boolean;
+    error?: string;
+    hint?: string;
+    label: string;
+    labelAction?: React.ReactNode;
+    onAddAsset: (asset?: FileAsset, event?: React.MouseEventHandler<HTMLButtonElement>) => void;
+    onDeleteAsset: (asset: FileAsset) => void;
+    onDeleteAssetFromMediaLibrary: () => void;
+    onDropAsset?: (assets: FileWithoutIdHash[]) => void;
+    onEditAsset?: (asset: FileAsset) => void;
+    onNext: () => void;
+    onPrevious: () => void;
+    required?: boolean;
+    selectedAssetIndex: number;
+    trackedLocation?: string;
+}
+export declare const CarouselAssets: React.ForwardRefExoticComponent<CarouselAssetsProps & React.RefAttributes<unknown>>;

server/node_modules/@strapi/upload/dist/admin/src/components/MediaLibraryInput/Carousel/EmptyStateAsset.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import type { File } from '../../../../../shared/contracts/files';
+type FileWithoutIdHash = Omit<File, 'id' | 'hash'>;
+interface EmptyStateAssetProps {
+    disabled?: boolean;
+    onClick: (asset?: File, event?: React.MouseEventHandler<HTMLButtonElement>) => void;
+    onDropAsset: (assets: FileWithoutIdHash[]) => void;
+}
+export declare const EmptyStateAsset: ({ disabled, onClick, onDropAsset, }: EmptyStateAssetProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/MediaLibraryInput/MediaLibraryInput.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { CarouselAssetsProps } from './Carousel/CarouselAssets';
+type AllowedTypes = 'files' | 'images' | 'videos' | 'audios';
+export interface MediaLibraryInputProps {
+    required?: boolean;
+    name: string;
+    labelAction?: React.ReactNode;
+    label?: string;
+    hint?: string;
+    disabled?: boolean;
+    attribute?: {
+        allowedTypes?: AllowedTypes[];
+        multiple?: boolean;
+    };
+}
+export declare const MediaLibraryInput: React.ForwardRefExoticComponent<MediaLibraryInputProps & React.RefAttributes<CarouselAssetsProps>>;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/SelectTree/Option.d.ts

@@ -0,0 +1,16 @@
+import { OptionProps as ReactSelectOptionProps } from 'react-select';
+import type { Folder } from '../../../../shared/contracts/folders';
+interface SelectProps {
+    maxDisplayDepth: number;
+    openValues: string[];
+    onOptionToggle: (value: string) => void;
+}
+interface FolderWithDepth extends Folder {
+    depth: number;
+    value: string;
+}
+interface OptionProps extends ReactSelectOptionProps<FolderWithDepth, false> {
+    selectProps: SelectProps & ReactSelectOptionProps<FolderWithDepth, false>['selectProps'];
+}
+export declare const Option: ({ children, data, selectProps, ...props }: OptionProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/SelectTree/SelectTree.d.ts

@@ -0,0 +1,22 @@
+import { GroupBase } from 'react-select';
+export type OptionSelectTree = {
+    value: string | number | null;
+    label?: string;
+    children?: OptionSelectTree[];
+};
+export interface SelectTreeProps<Option = unknown, IsMulti extends boolean = false, Group extends GroupBase<Option> = GroupBase<Option>> {
+    maxDisplayDepth?: number;
+    defaultValue?: {
+        value?: string | number | null;
+    };
+    options: OptionSelectTree[];
+    onChange?: (value: Record<string, string | number>) => void;
+    name?: string;
+    menuPortalTarget?: HTMLElement | null;
+    inputId?: string;
+    error?: string;
+    ariaErrorMessage?: string;
+    isDisabled?: boolean;
+    disabled?: boolean;
+}
+export declare const SelectTree: ({ options: defaultOptions, maxDisplayDepth, defaultValue, ...props }: SelectTreeProps) => import("react/jsx-runtime").JSX.Element;

server/node_modules/@strapi/upload/dist/admin/src/components/SelectTree/utils/flattenTree.d.ts

@@ -0,0 +1,14 @@
+type TreeNode<T> = {
+    value: T;
+    children?: TreeNode<T>[];
+    label?: string;
+};
+export type FlattenedNode<T> = {
+    value: T;
+    parent?: T;
+    depth: number;
+    label?: string;
+    children?: TreeNode<T>[];
+};
+export declare function flattenTree<T>(tree: TreeNode<T>[], parent?: TreeNode<T> | null, depth?: number): FlattenedNode<T>[];
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/SelectTree/utils/getOpenValues.d.ts

@@ -0,0 +1,9 @@
+interface Option {
+    value: number | string | null;
+    parent?: number | string | null;
+}
+interface DefaultValue {
+    value?: number | string | null;
+}
+export declare function getOpenValues(options: Option[], defaultValue?: DefaultValue): (string | number | null)[];
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/SelectTree/utils/getValuesToClose.d.ts

@@ -0,0 +1,6 @@
+interface Option {
+    value: string | number | null;
+    depth: number;
+}
+export declare function getValuesToClose(options: Option[], value: number | string | null): (string | number | null)[];
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/SortPicker/SortPicker.d.ts

@@ -0,0 +1,7 @@
+import type { Query } from '../../../../shared/contracts/files';
+interface SortPickerProps {
+    onChangeSort: (value: Query['sort'] | string) => void;
+    value?: string;
+}
+export declare const SortPicker: ({ onChangeSort, value }: SortPickerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/TableList/CellContent.d.ts

@@ -0,0 +1,8 @@
+import type { File } from '../../../../shared/contracts/files';
+export interface CellContentProps {
+    cellType: string;
+    contentType?: string;
+    content: File;
+    name: string;
+}
+export declare const CellContent: ({ cellType, contentType, content, name }: CellContentProps) => import("react/jsx-runtime").JSX.Element;

server/node_modules/@strapi/upload/dist/admin/src/components/TableList/PreviewCell.d.ts

@@ -0,0 +1,7 @@
+import type { File } from '../../../../shared/contracts/files';
+interface PreviewCellProps {
+    content: File;
+    type?: string;
+}
+export declare const PreviewCell: ({ type, content }: PreviewCellProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/TableList/TableList.d.ts

@@ -0,0 +1,31 @@
+import type { File } from '../../../../shared/contracts/files';
+import type { Folder } from '../../../../shared/contracts/folders';
+import type { AllowedTypes } from '../AssetCard/AssetCard';
+export interface FileRow extends File {
+    folderURL?: string;
+    isSelectable?: boolean;
+    type?: string;
+}
+export interface FolderRow extends Folder {
+    folderURL?: string;
+    isSelectable?: boolean;
+    type?: string;
+}
+export interface TableListProps {
+    isFolderSelectionAllowed?: boolean;
+    allowedTypes?: AllowedTypes[];
+    assetCount?: number;
+    folderCount?: number;
+    indeterminate?: boolean;
+    onChangeSort?: ((sortQuery: string) => void) | null;
+    onChangeFolder?: ((folderId: number, folderPath?: string) => void) | null;
+    onEditAsset?: ((asset: FileRow) => void) | null;
+    onEditFolder?: ((folder: FolderRow) => void) | null;
+    onSelectAll: (checked: boolean | string, rows?: FolderRow[] | FileRow[]) => void;
+    onSelectOne: (element: FileRow | FolderRow) => void;
+    rows?: FileRow[] | FolderRow[];
+    selected?: FileRow[] | FolderRow[];
+    shouldDisableBulkSelect?: boolean;
+    sortQuery?: string;
+}
+export declare const TableList: ({ assetCount, folderCount, indeterminate, onChangeSort, onChangeFolder, onEditAsset, onEditFolder, onSelectAll, onSelectOne, rows, selected, shouldDisableBulkSelect, sortQuery, }: TableListProps) => import("react/jsx-runtime").JSX.Element;

server/node_modules/@strapi/upload/dist/admin/src/components/TableList/TableRows.d.ts

@@ -0,0 +1,22 @@
+import type { File } from '../../../../shared/contracts/files';
+import type { Folder } from '../../../../shared/contracts/folders';
+interface FileRow extends File {
+    folderURL?: string;
+    isSelectable?: boolean;
+    type?: string;
+}
+interface FolderRow extends Folder {
+    folderURL?: string;
+    isSelectable?: boolean;
+    type?: string;
+}
+export interface TableRowsProps {
+    onChangeFolder?: ((folderId: number, folderPath?: string) => void) | null;
+    onEditAsset: (asset: FileRow) => void;
+    onEditFolder: (folder: FolderRow) => void;
+    onSelectOne: (element: FileRow | FolderRow) => void;
+    rows: FileRow[] | FolderRow[];
+    selected: FileRow[] | FolderRow[];
+}
+export declare const TableRows: ({ onChangeFolder, onEditAsset, onEditFolder, onSelectOne, rows, selected, }: TableRowsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/UploadAssetDialog/AddAssetStep/AddAssetStep.d.ts

@@ -0,0 +1,13 @@
+import type { RawFile, File } from '../../../../../shared/contracts/files';
+export interface FileWithRawFile extends Omit<File, 'id' | 'hash'> {
+    id?: string;
+    hash?: string;
+    rawFile: RawFile;
+}
+interface AddAssetStepProps {
+    onClose: () => void;
+    onAddAsset: (assets: FileWithRawFile[]) => void;
+    trackedLocation?: string;
+}
+export declare const AddAssetStep: ({ onClose, onAddAsset, trackedLocation }: AddAssetStepProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/UploadAssetDialog/AddAssetStep/FromComputerForm.d.ts

@@ -0,0 +1,8 @@
+import type { FileWithRawFile } from './AddAssetStep';
+interface FromComputerFormProps {
+    onClose: () => void;
+    onAddAssets: (assets: FileWithRawFile[]) => void;
+    trackedLocation?: string;
+}
+export declare const FromComputerForm: ({ onClose, onAddAssets, trackedLocation, }: FromComputerFormProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/UploadAssetDialog/AddAssetStep/FromUrlForm.d.ts

@@ -0,0 +1,8 @@
+import type { FileWithRawFile } from './AddAssetStep';
+interface FromUrlFormProps {
+    onClose: () => void;
+    onAddAsset: (assets: FileWithRawFile[]) => void;
+    trackedLocation?: string;
+}
+export declare const FromUrlForm: ({ onClose, onAddAsset, trackedLocation }: FromUrlFormProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/UploadAssetDialog/PendingAssetStep/PendingAssetStep.d.ts

@@ -0,0 +1,22 @@
+import { AssetType } from '../../../constants';
+import type { File, RawFile } from '../../../../../shared/contracts/files';
+interface Asset extends File {
+    rawFile?: RawFile;
+    type?: AssetType;
+}
+interface PendingAssetStepProps {
+    addUploadedFiles?: (files: File[]) => void;
+    folderId?: string | number | null;
+    onClose: () => void;
+    onEditAsset: (asset: File) => void;
+    onRemoveAsset: (asset: File) => void;
+    onAddAsset?: (asset: File) => void;
+    assets: Asset[];
+    onClickAddAsset: () => void;
+    onCancelUpload: (rawFile: RawFile) => void;
+    onUploadSucceed: (file: RawFile) => void;
+    trackedLocation?: string;
+    initialAssetsToAdd?: File[];
+}
+export declare const PendingAssetStep: ({ addUploadedFiles, folderId, onClose, onEditAsset, onRemoveAsset, assets, onClickAddAsset, onCancelUpload, onUploadSucceed, trackedLocation, }: PendingAssetStepProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/UploadAssetDialog/UploadAssetDialog.d.ts

@@ -0,0 +1,21 @@
+import type { File, RawFile } from '../../../../shared/contracts/files';
+import type { AllowedFiles } from '../../utils';
+type FileWithoutIdHash = Omit<File, 'id' | 'hash'>;
+export interface Asset extends Omit<File, 'folder'> {
+    isLocal?: boolean;
+    rawFile?: RawFile;
+    folder?: File['folder'] & {
+        id: number;
+    };
+}
+export interface UploadAssetDialogProps {
+    addUploadedFiles?: (files: Asset[] | File[]) => void;
+    folderId?: string | number | null;
+    initialAssetsToAdd?: Asset[];
+    onClose: () => void;
+    open: boolean;
+    trackedLocation?: string;
+    validateAssetsTypes?: (assets: FileWithoutIdHash[] | Asset[], cb: (assets?: AllowedFiles[], error?: string) => void) => void;
+}
+export declare const UploadAssetDialog: ({ initialAssetsToAdd, folderId, onClose, addUploadedFiles, trackedLocation, open, validateAssetsTypes, }: UploadAssetDialogProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/components/UploadProgress/UploadProgress.d.ts

@@ -0,0 +1,7 @@
+import { UpdateFile } from '../../../../shared/contracts/files';
+export interface UploadProgressProps {
+    error?: UpdateFile.Response['error'] | Error | null;
+    onCancel: () => void;
+    progress?: number;
+}
+export declare const UploadProgress: ({ onCancel, progress, error }: UploadProgressProps) => import("react/jsx-runtime").JSX.Element;

server/node_modules/@strapi/upload/dist/admin/src/constants.d.ts

@@ -0,0 +1,70 @@
+export declare enum AssetType {
+    Video = "video",
+    Image = "image",
+    Document = "doc",
+    Audio = "audio"
+}
+export declare enum AssetSource {
+    Url = "url",
+    Computer = "computer"
+}
+export declare const PERMISSIONS: {
+    main: {
+        action: string;
+        subject: null;
+    }[];
+    copyLink: {
+        action: string;
+        subject: null;
+    }[];
+    create: {
+        action: string;
+        subject: null;
+    }[];
+    download: {
+        action: string;
+        subject: null;
+    }[];
+    read: {
+        action: string;
+        subject: null;
+    }[];
+    configureView: {
+        action: string;
+        subject: null;
+    }[];
+    settings: {
+        action: string;
+        subject: null;
+    }[];
+    update: {
+        action: string;
+        subject: null;
+        fields: null;
+    }[];
+};
+export declare const tableHeaders: {
+    name: string;
+    key: string;
+    metadatas: {
+        label: {
+            id: string;
+            defaultMessage: string;
+        };
+        isSortable: boolean;
+    };
+    type: string;
+}[];
+export declare const sortOptions: {
+    key: string;
+    value: string;
+}[];
+export declare const pageSizes: number[];
+export declare const localStorageKeys: {
+    modalView: string;
+    view: string;
+};
+export declare const viewOptions: {
+    GRID: number;
+    LIST: number;
+};

server/node_modules/@strapi/upload/dist/admin/src/hooks/useAssets.d.ts

@@ -0,0 +1,14 @@
+import { Query } from '../../../shared/contracts/files';
+interface UseAssetsOptions {
+    skipWhen?: boolean;
+    query?: Query;
+}
+export declare const useAssets: ({ skipWhen, query }?: UseAssetsOptions) => {
+    data: {
+        results: import("../../../shared/contracts/files").File[];
+        pagination: import("../../../shared/contracts/files").Pagination;
+    } | undefined;
+    error: import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").NotFoundError<string, unknown> | null | undefined;
+    isLoading: boolean;
+};
+export {};

server/node_modules/@strapi/upload/dist/admin/src/hooks/useBulkMove.d.ts

@@ -0,0 +1,78 @@
+import { File, BulkMoveFiles } from '../../../shared/contracts/files';
+import { Folder, BulkMoveFolders } from '../../../shared/contracts/folders';
+export interface FolderWithType extends Folder {
+    type: string;
+}
+export interface FileWithType extends File {
+    type: string;
+}
+interface BulkMoveParams {
+    destinationFolderId: number | string;
+    filesAndFolders: Array<FolderWithType | FileWithType>;
+}
+export declare const useBulkMove: () => {
+    move: (destinationFolderId: number | string, filesAndFolders: Array<FolderWithType | FileWithType>) => Promise<BulkMoveFiles.Response | BulkMoveFolders.Response>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isLoading: false;
+    isSuccess: false;
+    status: "idle";
+    mutate: import("react-query").UseMutateFunction<BulkMoveFiles.Response | BulkMoveFolders.Response, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, BulkMoveParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: BulkMoveParams | undefined;
+    mutateAsync: import("react-query").UseMutateAsyncFunction<BulkMoveFiles.Response | BulkMoveFolders.Response, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, BulkMoveParams, unknown>;
+} | {
+    move: (destinationFolderId: number | string, filesAndFolders: Array<FolderWithType | FileWithType>) => Promise<BulkMoveFiles.Response | BulkMoveFolders.Response>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isLoading: true;
+    isSuccess: false;
+    status: "loading";
+    mutate: import("react-query").UseMutateFunction<BulkMoveFiles.Response | BulkMoveFolders.Response, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, BulkMoveParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: BulkMoveParams | undefined;
+    mutateAsync: import("react-query").UseMutateAsyncFunction<BulkMoveFiles.Response | BulkMoveFolders.Response, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, BulkMoveParams, unknown>;
+} | {
+    move: (destinationFolderId: number | string, filesAndFolders: Array<FolderWithType | FileWithType>) => Promise<BulkMoveFiles.Response | BulkMoveFolders.Response>;
+    data: undefined;
+    error: import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined;
+    isError: true;
+    isIdle: false;
+    isLoading: false;
+    isSuccess: false;
+    status: "error";
+    mutate: import("react-query").UseMutateFunction<BulkMoveFiles.Response | BulkMoveFolders.Response, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, BulkMoveParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: BulkMoveParams | undefined;
+    mutateAsync: import("react-query").UseMutateAsyncFunction<BulkMoveFiles.Response | BulkMoveFolders.Response, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, BulkMoveParams, unknown>;
+} | {
+    move: (destinationFolderId: number | string, filesAndFolders: Array<FolderWithType | FileWithType>) => Promise<BulkMoveFiles.Response | BulkMoveFolders.Response>;
+    data: BulkMoveFiles.Response | BulkMoveFolders.Response;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isLoading: false;
+    isSuccess: true;
+    status: "success";
+    mutate: import("react-query").UseMutateFunction<BulkMoveFiles.Response | BulkMoveFolders.Response, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, BulkMoveParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: BulkMoveParams | undefined;
+    mutateAsync: import("react-query").UseMutateAsyncFunction<BulkMoveFiles.Response | BulkMoveFolders.Response, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, BulkMoveParams, unknown>;
+};
+export {};

server/node_modules/@strapi/upload/dist/admin/src/hooks/useBulkRemove.d.ts

@@ -0,0 +1,70 @@
+import { BulkDeleteFiles, File } from '../../../shared/contracts/files';
+import type { BulkDeleteFolders, FolderDefinition } from '../../../shared/contracts/folders';
+export interface FileWithType extends File {
+    type: string;
+}
+export declare const useBulkRemove: () => {
+    remove: (variables: (FolderDefinition | FileWithType)[], options?: import("react-query").MutateOptions<BulkDeleteFiles.Response | BulkDeleteFolders.Response, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, (FolderDefinition | FileWithType)[], unknown> | undefined) => Promise<BulkDeleteFiles.Response | BulkDeleteFolders.Response>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isLoading: false;
+    isSuccess: false;
+    status: "idle";
+    mutate: import("react-query").UseMutateFunction<BulkDeleteFiles.Response | BulkDeleteFolders.Response, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, (FolderDefinition | FileWithType)[], unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: (FolderDefinition | FileWithType)[] | undefined;
+    mutateAsync: import("react-query").UseMutateAsyncFunction<BulkDeleteFiles.Response | BulkDeleteFolders.Response, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, (FolderDefinition | FileWithType)[], unknown>;
+} | {
+    remove: (variables: (FolderDefinition | FileWithType)[], options?: import("react-query").MutateOptions<BulkDeleteFiles.Response | BulkDeleteFolders.Response, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, (FolderDefinition | FileWithType)[], unknown> | undefined) => Promise<BulkDeleteFiles.Response | BulkDeleteFolders.Response>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isLoading: true;
+    isSuccess: false;
+    status: "loading";
+    mutate: import("react-query").UseMutateFunction<BulkDeleteFiles.Response | BulkDeleteFolders.Response, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, (FolderDefinition | FileWithType)[], unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: (FolderDefinition | FileWithType)[] | undefined;
+    mutateAsync: import("react-query").UseMutateAsyncFunction<BulkDeleteFiles.Response | BulkDeleteFolders.Response, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, (FolderDefinition | FileWithType)[], unknown>;
+} | {
+    remove: (variables: (FolderDefinition | FileWithType)[], options?: import("react-query").MutateOptions<BulkDeleteFiles.Response | BulkDeleteFolders.Response, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, (FolderDefinition | FileWithType)[], unknown> | undefined) => Promise<BulkDeleteFiles.Response | BulkDeleteFolders.Response>;
+    data: undefined;
+    error: import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined;
+    isError: true;
+    isIdle: false;
+    isLoading: false;
+    isSuccess: false;
+    status: "error";
+    mutate: import("react-query").UseMutateFunction<BulkDeleteFiles.Response | BulkDeleteFolders.Response, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, (FolderDefinition | FileWithType)[], unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: (FolderDefinition | FileWithType)[] | undefined;
+    mutateAsync: import("react-query").UseMutateAsyncFunction<BulkDeleteFiles.Response | BulkDeleteFolders.Response, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, (FolderDefinition | FileWithType)[], unknown>;
+} | {
+    remove: (variables: (FolderDefinition | FileWithType)[], options?: import("react-query").MutateOptions<BulkDeleteFiles.Response | BulkDeleteFolders.Response, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, (FolderDefinition | FileWithType)[], unknown> | undefined) => Promise<BulkDeleteFiles.Response | BulkDeleteFolders.Response>;
+    data: BulkDeleteFiles.Response | BulkDeleteFolders.Response;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isLoading: false;
+    isSuccess: true;
+    status: "success";
+    mutate: import("react-query").UseMutateFunction<BulkDeleteFiles.Response | BulkDeleteFolders.Response, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, (FolderDefinition | FileWithType)[], unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: (FolderDefinition | FileWithType)[] | undefined;
+    mutateAsync: import("react-query").UseMutateAsyncFunction<BulkDeleteFiles.Response | BulkDeleteFolders.Response, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, (FolderDefinition | FileWithType)[], unknown>;
+};

server/node_modules/@strapi/upload/dist/admin/src/hooks/useConfig.d.ts

@@ -0,0 +1,5 @@
+import { UseMutationResult, UseQueryResult } from 'react-query';
+export declare const useConfig: () => {
+    config: UseQueryResult<import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").NotFoundError<string, unknown> | import("../../../shared/contracts/configuration").Configuration | undefined>;
+    mutateConfig: UseMutationResult<void, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, import("../../../shared/contracts/configuration").Configuration>;
+};

server/node_modules/@strapi/upload/dist/admin/src/hooks/useCropImg.d.ts

@@ -0,0 +1,9 @@
+export declare const useCropImg: () => {
+    width?: number | undefined;
+    height?: number | undefined;
+    crop: (image: HTMLImageElement) => void;
+    produceFile: (name: string, mimeType: string, lastModifiedDate: string) => Promise<unknown>;
+    stopCropping: () => void;
+    isCropping: boolean;
+    isCropperReady: boolean;
+};

server/node_modules/@strapi/upload/dist/admin/src/hooks/useEditAsset.d.ts

@@ -0,0 +1,119 @@
+import { File as FileAsset } from '../../../shared/contracts/files';
+export type ErrorMutation = {
+    message: string;
+    response: {
+        status: number;
+        data: {
+            error: Error;
+        };
+    };
+} | null;
+export declare const useEditAsset: () => {
+    cancel: () => void;
+    editAsset: (asset: FileAsset, file: File) => Promise<FileAsset>;
+    progress: number;
+    status: "error" | "success" | "idle" | "loading";
+    data: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isLoading: false;
+    isSuccess: false;
+    mutate: import("react-query").UseMutateFunction<FileAsset, ErrorMutation, {
+        asset: FileAsset;
+        file: File;
+    }, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: {
+        asset: FileAsset;
+        file: File;
+    } | undefined;
+    mutateAsync: import("react-query").UseMutateAsyncFunction<FileAsset, ErrorMutation, {
+        asset: FileAsset;
+        file: File;
+    }, unknown>;
+} | {
+    cancel: () => void;
+    editAsset: (asset: FileAsset, file: File) => Promise<FileAsset>;
+    progress: number;
+    status: "error" | "success" | "idle" | "loading";
+    data: undefined;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isLoading: true;
+    isSuccess: false;
+    mutate: import("react-query").UseMutateFunction<FileAsset, ErrorMutation, {
+        asset: FileAsset;
+        file: File;
+    }, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: {
+        asset: FileAsset;
+        file: File;
+    } | undefined;
+    mutateAsync: import("react-query").UseMutateAsyncFunction<FileAsset, ErrorMutation, {
+        asset: FileAsset;
+        file: File;
+    }, unknown>;
+} | {
+    cancel: () => void;
+    editAsset: (asset: FileAsset, file: File) => Promise<FileAsset>;
+    progress: number;
+    status: "error" | "success" | "idle" | "loading";
+    data: undefined;
+    error: ErrorMutation;
+    isError: true;
+    isIdle: false;
+    isLoading: false;
+    isSuccess: false;
+    mutate: import("react-query").UseMutateFunction<FileAsset, ErrorMutation, {
+        asset: FileAsset;
+        file: File;
+    }, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: {
+        asset: FileAsset;
+        file: File;
+    } | undefined;
+    mutateAsync: import("react-query").UseMutateAsyncFunction<FileAsset, ErrorMutation, {
+        asset: FileAsset;
+        file: File;
+    }, unknown>;
+} | {
+    cancel: () => void;
+    editAsset: (asset: FileAsset, file: File) => Promise<FileAsset>;
+    progress: number;
+    status: "error" | "success" | "idle" | "loading";
+    data: FileAsset;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isLoading: false;
+    isSuccess: true;
+    mutate: import("react-query").UseMutateFunction<FileAsset, ErrorMutation, {
+        asset: FileAsset;
+        file: File;
+    }, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: {
+        asset: FileAsset;
+        file: File;
+    } | undefined;
+    mutateAsync: import("react-query").UseMutateAsyncFunction<FileAsset, ErrorMutation, {
+        asset: FileAsset;
+        file: File;
+    }, unknown>;
+};

server/node_modules/@strapi/upload/dist/admin/src/hooks/useEditFolder.d.ts

@@ -0,0 +1,71 @@
+import { CreateFolders, UpdateFolder } from '../../../shared/contracts/folders';
+interface EditFolderRequestParams {
+    attrs: CreateFolders.Request['body'] | UpdateFolder.Request['body'];
+    id?: UpdateFolder.Request['params']['id'];
+}
+export declare const useEditFolder: () => {
+    editFolder: (attrs: EditFolderRequestParams['attrs'], id?: EditFolderRequestParams['id']) => Promise<import("../../../shared/contracts/folders").Folder>;
+    status: "error" | "success" | "idle" | "loading";
+    data: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isLoading: false;
+    isSuccess: false;
+    mutate: import("react-query").UseMutateFunction<import("../../../shared/contracts/folders").Folder, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").NotFoundError<string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, EditFolderRequestParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: EditFolderRequestParams | undefined;
+    mutateAsync: import("react-query").UseMutateAsyncFunction<import("../../../shared/contracts/folders").Folder, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").NotFoundError<string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, EditFolderRequestParams, unknown>;
+} | {
+    editFolder: (attrs: EditFolderRequestParams['attrs'], id?: EditFolderRequestParams['id']) => Promise<import("../../../shared/contracts/folders").Folder>;
+    status: "error" | "success" | "idle" | "loading";
+    data: undefined;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isLoading: true;
+    isSuccess: false;
+    mutate: import("react-query").UseMutateFunction<import("../../../shared/contracts/folders").Folder, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").NotFoundError<string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, EditFolderRequestParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: EditFolderRequestParams | undefined;
+    mutateAsync: import("react-query").UseMutateAsyncFunction<import("../../../shared/contracts/folders").Folder, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").NotFoundError<string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, EditFolderRequestParams, unknown>;
+} | {
+    editFolder: (attrs: EditFolderRequestParams['attrs'], id?: EditFolderRequestParams['id']) => Promise<import("../../../shared/contracts/folders").Folder>;
+    status: "error" | "success" | "idle" | "loading";
+    data: undefined;
+    error: import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").NotFoundError<string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined;
+    isError: true;
+    isIdle: false;
+    isLoading: false;
+    isSuccess: false;
+    mutate: import("react-query").UseMutateFunction<import("../../../shared/contracts/folders").Folder, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").NotFoundError<string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, EditFolderRequestParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: EditFolderRequestParams | undefined;
+    mutateAsync: import("react-query").UseMutateAsyncFunction<import("../../../shared/contracts/folders").Folder, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").NotFoundError<string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, EditFolderRequestParams, unknown>;
+} | {
+    editFolder: (attrs: EditFolderRequestParams['attrs'], id?: EditFolderRequestParams['id']) => Promise<import("../../../shared/contracts/folders").Folder>;
+    status: "error" | "success" | "idle" | "loading";
+    data: import("../../../shared/contracts/folders").Folder;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isLoading: false;
+    isSuccess: true;
+    mutate: import("react-query").UseMutateFunction<import("../../../shared/contracts/folders").Folder, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").NotFoundError<string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, EditFolderRequestParams, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    isPaused: boolean;
+    variables: EditFolderRequestParams | undefined;
+    mutateAsync: import("react-query").UseMutateAsyncFunction<import("../../../shared/contracts/folders").Folder, import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").NotFoundError<string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | undefined, EditFolderRequestParams, unknown>;
+};
+export {};

server/node_modules/@strapi/upload/dist/admin/src/hooks/useFolder.d.ts

@@ -0,0 +1,7 @@
+export declare const useFolder: (id: number | null | undefined, { enabled }?: {
+    enabled?: boolean | undefined;
+}) => {
+    data: import("../../../shared/contracts/folders").Folder | undefined;
+    error: import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").NotFoundError<string, unknown> | null | undefined;
+    isLoading: boolean;
+};

server/node_modules/@strapi/upload/dist/admin/src/hooks/useFolderStructure.d.ts

@@ -0,0 +1,18 @@
+import { FolderNode } from '../../../shared/contracts/folders';
+interface FolderNodeWithChildren extends Omit<FolderNode, 'children'> {
+    children: FolderNodeWithChildren[];
+    label?: string;
+    value: string | number | null;
+}
+export declare const useFolderStructure: ({ enabled }?: {
+    enabled?: boolean | undefined;
+}) => {
+    data: {
+        value: null;
+        label: string;
+        children: import("./utils/renameKeys").DeepRecord<FolderNodeWithChildren>[];
+    }[] | undefined;
+    error: unknown;
+    isLoading: boolean;
+};
+export {};

server/node_modules/@strapi/upload/dist/admin/src/hooks/useFolders.d.ts

@@ -0,0 +1,11 @@
+import type { Query } from '../../../shared/contracts/files';
+interface UseFoldersOptions {
+    enabled?: boolean;
+    query?: Query;
+}
+export declare const useFolders: ({ enabled, query }?: UseFoldersOptions) => {
+    data: import("../../../shared/contracts/folders").Folder[] | undefined;
+    error: import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").NotFoundError<string, unknown> | null | undefined;
+    isLoading: boolean;
+};
+export {};

server/node_modules/@strapi/upload/dist/admin/src/hooks/useMediaLibraryPermissions.d.ts

@@ -0,0 +1,4 @@
+import { type AllowedActions } from '@strapi/admin/strapi-admin';
+export declare const useMediaLibraryPermissions: () => AllowedActions & {
+    isLoading: boolean;
+};

server/node_modules/@strapi/upload/dist/admin/src/hooks/useModalQueryParams.d.ts

@@ -0,0 +1,20 @@
+import type { Query, FilterCondition } from '../../../shared/contracts/files';
+export declare const useModalQueryParams: (initialState?: Partial<Query>) => ({
+    queryObject: Query;
+    rawQuery: string;
+    onChangeFilters?: undefined;
+    onChangeFolder?: undefined;
+    onChangePage?: undefined;
+    onChangePageSize?: undefined;
+    onChangeSort?: undefined;
+    onChangeSearch?: undefined;
+} | {
+    onChangeFilters: (nextFilters: FilterCondition<string>[]) => void;
+    onChangeFolder: (folder: Query['folder'], folderPath: Query['folderPath']) => void;
+    onChangePage: (page: Query['page']) => void;
+    onChangePageSize: (pageSize: Query['pageSize']) => void;
+    onChangeSort: (sort: Query['sort']) => void;
+    onChangeSearch: (_q: Query['_q'] | null) => void;
+    queryObject?: undefined;
+    rawQuery?: undefined;
+})[];

server/node_modules/@strapi/upload/dist/admin/src/hooks/usePersistentState.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const usePersistentState: <T>(key: string, defaultValue: T) => readonly [T, import("react").Dispatch<import("react").SetStateAction<T>>];
+export { usePersistentState };

server/node_modules/@strapi/upload/dist/admin/src/hooks/useRemoveAsset.d.ts

@@ -0,0 +1,8 @@
+import { FetchResponse } from '@strapi/admin/strapi-admin';
+import { UseMutationResult } from 'react-query';
+import type { DeleteFile } from '../../../shared/contracts/files';
+type UseRemoveAsset = {
+    removeAsset: (assetId: number) => Promise<void>;
+} & UseMutationResult<FetchResponse<DeleteFile.Response>, Error, number>;
+export declare const useRemoveAsset: (onSuccess: () => void) => UseRemoveAsset;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/hooks/useSelectionState.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+export declare const useSelectionState: <TValues extends object>(keys: Array<keyof TValues>, initialValue: TValues[]) => readonly [TValues[], {
+    readonly selectOne: (selection: TValues) => void;
+    readonly selectAll: (nextSelections?: TValues[]) => void;
+    readonly selectOnly: (nextSelection: TValues) => void;
+    readonly selectMultiple: (nextSelections: TValues[]) => void;
+    readonly deselectMultiple: (nextSelections: TValues[]) => void;
+    readonly setSelections: React.Dispatch<React.SetStateAction<TValues[]>>;
+}];

server/node_modules/@strapi/upload/dist/admin/src/hooks/useUpload.d.ts

@@ -0,0 +1,15 @@
+import { File, RawFile } from '../../../shared/contracts/files';
+interface Asset extends Omit<File, 'id' | 'hash'> {
+    rawFile?: RawFile;
+    id?: File['id'];
+    hash?: File['hash'];
+}
+export declare const useUpload: () => {
+    upload: (asset: Asset, folderId: number | null) => Promise<File[]>;
+    isLoading: boolean;
+    cancel: () => void;
+    error: import("@strapi/utils/dist/errors").ApplicationError<"ApplicationError", string, unknown> | import("@strapi/utils/dist/errors").ValidationError<string, unknown> | null | undefined;
+    progress: number;
+    status: "error" | "success" | "idle" | "loading";
+};
+export {};

server/node_modules/@strapi/upload/dist/admin/src/hooks/utils/renameKeys.d.ts

@@ -0,0 +1,6 @@
+type Primitive = string | number | boolean | null | undefined;
+export type DeepRecord<T> = {
+    [K in keyof T]: T[K] extends Primitive ? T[K] : DeepRecord<T[K]>;
+};
+export declare const recursiveRenameKeys: <T extends object>(obj: T, fn: (key: string) => string) => DeepRecord<T>;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '@strapi/types';
+declare const admin: Plugin.Config.AdminInput;
+export default admin;

server/node_modules/@strapi/upload/dist/admin/src/pages/App/App.d.ts

@@ -0,0 +1 @@
+export declare const Upload: () => import("react/jsx-runtime").JSX.Element;

server/node_modules/@strapi/upload/dist/admin/src/pages/App/ConfigureTheView/ConfigureTheView.d.ts

@@ -0,0 +1,6 @@
+import type { Configuration } from '../../../../../shared/contracts/configuration';
+interface ConfigureTheViewProps {
+    config: Configuration;
+}
+export declare const ConfigureTheView: ({ config }: ConfigureTheViewProps) => import("react/jsx-runtime").JSX.Element;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/pages/App/ConfigureTheView/components/Settings.d.ts

@@ -0,0 +1,13 @@
+import type { Configuration } from '../../../../../../shared/contracts/configuration';
+interface SettingsProps {
+    sort: string;
+    pageSize: string | number;
+    onChange: ({ target: { name, value }, }: {
+        target: {
+            name: keyof Configuration;
+            value: string | number;
+        };
+    }) => void;
+}
+declare const Settings: ({ sort, pageSize, onChange }: SettingsProps) => import("react/jsx-runtime").JSX.Element;
+export { Settings };

server/node_modules/@strapi/upload/dist/admin/src/pages/App/ConfigureTheView/state/actionTypes.d.ts

@@ -0,0 +1,2 @@
+export declare const ON_CHANGE: string;
+export declare const SET_LOADED: string;

server/node_modules/@strapi/upload/dist/admin/src/pages/App/ConfigureTheView/state/actions.d.ts

@@ -0,0 +1,12 @@
+import type { InitialState } from './init';
+export declare const onChange: ({ name, value, }: {
+    name: keyof NonNullable<InitialState['initialData']>;
+    value: number | string;
+}) => {
+    type: string;
+    keys: keyof import("../../../../../../shared/contracts/configuration").Configuration;
+    value: string | number;
+};
+export declare const setLoaded: () => {
+    type: string;
+};

server/node_modules/@strapi/upload/dist/admin/src/pages/App/ConfigureTheView/state/init.d.ts

@@ -0,0 +1,8 @@
+import type { Configuration } from '../../../../../../shared/contracts/configuration';
+export type InitialState = {
+    initialData: Partial<Configuration>;
+    modifiedData: Partial<Configuration>;
+};
+declare const initialState: InitialState;
+declare const init: (configData: InitialState['initialData']) => InitialState;
+export { init, initialState };

server/node_modules/@strapi/upload/dist/admin/src/pages/App/ConfigureTheView/state/reducer.d.ts

@@ -0,0 +1,15 @@
+import type { InitialState } from './init';
+export interface ActionOnChange {
+    type: string;
+    keys?: string;
+    value: string | number;
+}
+export interface ActionSetLoaded {
+    type: string;
+}
+interface ActionInitialValue {
+    type: string;
+}
+export type Action = ActionSetLoaded | ActionOnChange | ActionInitialValue;
+export declare const reducer: (state?: InitialState, action?: Action) => InitialState;
+export {};

server/node_modules/@strapi/upload/dist/admin/src/pages/App/MediaLibrary/MediaLibrary.d.ts

@@ -0,0 +1 @@
+export declare const MediaLibrary: () => import("react/jsx-runtime").JSX.Element;

server/node_modules/@strapi/upload/dist/admin/src/pages/App/MediaLibrary/components/BulkActions.d.ts

@@ -0,0 +1,15 @@
+import type { File } from '../../../../../../shared/contracts/files';
+import type { FolderDefinition, Folder as FolderInitial } from '../../../../../../shared/contracts/folders';
+interface FolderWithType extends FolderInitial {
+    type: string;
+}
+export interface FileWithType extends File {
+    type: string;
+}
+export interface BulkActionsProps {
+    selected: Array<FileWithType | FolderDefinition> | Array<FolderWithType | FileWithType>;
+    onSuccess: () => void;
+    currentFolder?: FolderWithType;
+}
+export declare const BulkActions: ({ selected, onSuccess, currentFolder }: BulkActionsProps) => import("react/jsx-runtime").JSX.Element;
+export {};