import { errors } from '@strapi/utils';
type SortOrder = 'ASC' | 'DESC';
type SortKey = 'createdAt' | 'name' | 'updatedAt';
type ComparisonOperators<T> = {
    [operator: string]: T | T[] | boolean;
};
export type FilterCondition<T> = {
    [field: string]: T | ComparisonOperators<T> | FilterCondition<T>;
};
type Filters<T> = {
    [logicOperator: string]: FilterCondition<T>[];
};
export type Query = {
    _q?: string;
    folderPath?: string;
    folder?: null | number | {
        id: number;
    };
    page?: string | number | {
        id: string | number;
    };
    pageSize?: string | number;
    pagination?: {
        pageSize: number;
    };
    sort?: `${SortKey}:${SortOrder}`;
    filters?: Filters<string | number | boolean>;
    state?: boolean;
};
type FileFormat = {
    name: string;
    hash: string;
    ext: string;
    mime: string;
    path: null | string;
    width: number;
    height: number;
    size: number;
    sizeInBytes: number;
    url: string;
};
export interface FocalPoint {
    x: number;
    y: number;
}
export interface File {
    id: number;
    name: string;
    alternativeText?: string | null;
    caption?: string | null;
    focalPoint?: FocalPoint | null;
    width?: number | null;
    height?: number | null;
    formats?: Record<string, FileFormat> | {
        thumbnail: {
            url: string;
        };
    } | null;
    hash: string;
    ext?: string;
    mime?: string;
    size?: number;
    sizeInBytes?: number;
    url?: string;
    previewUrl?: string | null;
    path?: string | null;
    provider?: string;
    provider_metadata?: Record<string, unknown> | null;
    isUrlSigned?: boolean;
    folder?: number | string | null;
    folderPath?: string;
    related?: {
        id: string | number;
        __type: string;
        __pivot: {
            field: string;
        };
    }[];
    createdAt?: string;
    updatedAt?: string;
    createdBy?: number;
    publishedAt?: string;
    updatedBy?: number;
    isLocal?: boolean;
}
export type UploadFileInfo = Pick<File, 'name' | 'alternativeText' | 'caption' | 'focalPoint' | 'folder'>;
export interface RawFile extends Blob {
    size: number;
    lastModified: number;
    name: string;
    type: string;
}
export interface Pagination {
    page: number;
    pageSize: number;
    pageCount: number;
    total: number;
}
/**
 * GET /upload/files - Get files
 */
export declare namespace GetFiles {
    interface Request {
        body: {};
        query: {
            page?: string;
            pageSize?: string;
            folder: number | null;
            sort?: `${SortKey}:${SortOrder}`;
        };
    }
    interface Response {
        data: {
            results: File[];
            pagination: Pagination;
        };
        error?: errors.ApplicationError | errors.NotFoundError;
    }
}
/**
 * GET /upload/files/:id - Get specific file
 */
export declare namespace GetFile {
    interface Request {
        params: {
            id: number;
        };
        query: {};
    }
    interface Response {
        data: File;
        error?: errors.ApplicationError | errors.NotFoundError;
    }
}
/**
 * POST /upload/actions/bulk-delete - Delete Files
 */
export declare namespace BulkDeleteFiles {
    interface Request {
        body: {
            fileIds: number[];
        };
    }
    interface Response {
        data: {
            data: {
                files: File[];
                folders: [];
            };
        };
        error?: errors.ApplicationError | errors.ValidationError;
    }
}
/**
 * POST /upload/actions/bulk-move - Move Files
 */
export declare namespace BulkMoveFiles {
    interface Request {
        body: {
            fileIds: number[];
            destinationFolderId: number;
        };
    }
    interface Response {
        data: {
            data: {
                files: File[];
                folders: [];
            };
        };
        error?: errors.ApplicationError | errors.ValidationError;
    }
}
/**
 * DELETE /upload/files/:id - Delete a specific asset
 */
export declare namespace DeleteFile {
    interface Request {
        params: {
            id: number;
        };
        query: {};
    }
    interface Response {
        data: File;
        error?: errors.ApplicationError | errors.NotFoundError;
    }
}
/**
 * POST /upload - Create a file
 * @deprecated Use CreateFilesStream instead
 */
export declare namespace CreateFile {
    interface Request {
        body: FormData;
        files: File[];
    }
    interface Response {
        data: File[];
        error?: errors.ApplicationError | errors.ValidationError;
    }
}
/**
 * POST /upload/unstable/stream - Stream upload files with partial success support
 */
export declare namespace CreateFilesStream {
    interface FileUploadError {
        name: string;
        message: string;
    }
    interface Request {
        body: FormData;
    }
    interface Response {
        data: File[];
        errors?: FileUploadError[];
    }
}
/**
 * POST /upload/unstable/stream - SSE streaming event types
 *
 * The endpoint streams Server-Sent Events as each file is processed.
 * The final `stream:complete` event carries the same shape as CreateFilesStream.Response.
 */
export declare namespace CreateFilesStreamEvents {
    interface FileUploadingEvent {
        name: string;
        index: number;
        total: number;
        size: number;
    }
    interface FileCompleteEvent {
        name: string;
        index: number;
        file: File;
    }
    interface FileErrorEvent {
        name: string;
        index: number;
        message: string;
    }
    interface StreamCompleteEvent {
        data: File[];
        errors: CreateFilesStream.FileUploadError[];
    }
    type SSEEventMap = {
        'file:uploading': FileUploadingEvent;
        'file:complete': FileCompleteEvent;
        'file:error': FileErrorEvent;
        'stream:complete': StreamCompleteEvent;
    };
}
/**
 * POST /upload?id=:id - Update asset
 */
export declare namespace UpdateFile {
    interface Request {
        body: FormData;
        params: {
            id: number;
        };
    }
    interface Response {
        data: File;
        error?: errors.ApplicationError | errors.ValidationError;
    }
}
/**
 * POST /upload/actions/bulk-update - Bulk update files
 */
export declare namespace BulkUpdateFiles {
    interface Request {
        body: {
            updates: Array<{
                id: number;
                fileInfo: {
                    name?: string;
                    alternativeText?: string | null;
                    caption?: string | null;
                    focalPoint?: FocalPoint | null;
                    folder?: number | null;
                };
            }>;
        };
    }
    interface Response {
        data: File[];
        error?: errors.ApplicationError | errors.ValidationError;
    }
}
/**
 * GET /upload/actions/generate-ai-metadata/count - Get count of images without metadata
 */
export declare namespace GetAIMetadataCount {
    interface Request {
        query: {};
    }
    interface Response {
        data: {
            imagesWithoutMetadataCount: number;
            totalImages: number;
        };
        error?: errors.ApplicationError;
    }
}
/**
 * POST /upload/actions/generate-ai-metadata - Start AI metadata generation job
 */
export declare namespace GenerateAIMetadata {
    interface Request {
        body: {};
    }
    interface Response {
        data: {
            jobId: number;
            status: 'pending';
        } | {
            count: 0;
            message: string;
        };
        error?: errors.ApplicationError;
    }
}
/** User object returned when createdBy is populated (GET /upload/files/:id) */
export interface PopulatedCreatedBy {
    id: number;
    firstname?: string;
    lastname?: string;
    username?: string | null;
    email?: string;
}
export type AssetWithPopulatedCreatedBy = Omit<File, 'createdBy'> & {
    createdBy?: PopulatedCreatedBy | null;
};
export {};