/**
 * Asset & File Methods Mixin
 */
import type { AssetInitResponse, AssetUrlResponse, AssetVariant } from '../../models/interfaces';
import type { OxyServicesBase } from '../OxyServices.base';
export declare function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T): {
    new (...args: any[]): {
        /**
         * Delete file
         */
        deleteFile(fileId: string): Promise<any>;
        /**
         * Get file download URL (synchronous - uses stream endpoint for images to avoid ORB blocking)
         * The stream endpoint serves images directly with proper CORS headers, avoiding browser ORB blocking
         * For better performance with signed URLs, use getFileDownloadUrlAsync when possible
         */
        getFileDownloadUrl(fileId: string, variant?: string, expiresIn?: number): string;
        /**
         * Get file download URL asynchronously (returns signed URL directly from CDN)
         * This is more efficient than the synchronous version as it avoids redirects
         * Use this when you can handle async operations (e.g., in useEffect, useMemo with async)
         */
        getFileDownloadUrlAsync(fileId: string, variant?: string, expiresIn?: number): Promise<string>;
        /**
         * List user files
         */
        listUserFiles(limit?: number, offset?: number): Promise<{
            files: any[];
            total: number;
            hasMore: boolean;
        }>;
        /**
         * Get file content as text
         */
        getFileContentAsText(fileId: string, variant?: string): Promise<string>;
        /**
         * Get file content as blob
         */
        getFileContentAsBlob(fileId: string, variant?: string): Promise<Blob>;
        /**
         * Get batch access to multiple files
         * Returns URLs and access status for each file
         */
        getBatchFileAccess(fileIds: string[], context?: string): Promise<Record<string, any>>;
        /**
         * Get download URLs for multiple files efficiently
         */
        getFileDownloadUrls(fileIds: string[], context?: string): Promise<Record<string, string>>;
        /**
         * Upload raw file data
         */
        uploadRawFile(file: File | Blob, visibility?: "private" | "public" | "unlisted", metadata?: Record<string, any>): Promise<any>;
        /**
         * Calculate SHA256 hash of file content
         */
        calculateSHA256(file: File | Blob): Promise<string>;
        /**
         * Initialize asset upload - returns pre-signed URL and file ID
         */
        assetInit(sha256: string, size: number, mime: string): Promise<AssetInitResponse>;
        /**
         * Complete asset upload - commit metadata and trigger variant generation
         */
        assetComplete(fileId: string, originalName: string, size: number, mime: string, visibility?: "private" | "public" | "unlisted", metadata?: Record<string, any>): Promise<any>;
        /**
         * Upload file using Central Asset Service
         */
        assetUpload(file: File, visibility?: "private" | "public" | "unlisted", metadata?: Record<string, any>, onProgress?: (progress: number) => void): Promise<any>;
        /**
         * Upload file to pre-signed URL
         */
        uploadToPresignedUrl(url: string, file: File, onProgress?: (progress: number) => void): Promise<void>;
        /**
         * Link asset to an entity
         */
        assetLink(fileId: string, app: string, entityType: string, entityId: string, visibility?: "private" | "public" | "unlisted", webhookUrl?: string): Promise<any>;
        /**
         * Unlink asset from an entity
         */
        assetUnlink(fileId: string, app: string, entityType: string, entityId: string): Promise<any>;
        /**
         * Get asset metadata
         */
        assetGet(fileId: string): Promise<any>;
        /**
         * Get asset URL (CDN or signed URL)
         */
        assetGetUrl(fileId: string, variant?: string, expiresIn?: number): Promise<AssetUrlResponse>;
        /**
         * Restore asset from trash
         */
        assetRestore(fileId: string): Promise<any>;
        /**
         * Delete asset with optional force
         */
        assetDelete(fileId: string, force?: boolean): Promise<any>;
        /**
         * Get list of available variants for an asset
         */
        assetGetVariants(fileId: string): Promise<AssetVariant[]>;
        /**
         * Update asset visibility
         * @param fileId - The file ID
         * @param visibility - New visibility level ('private', 'public', or 'unlisted')
         * @returns Updated asset information
         */
        assetUpdateVisibility(fileId: string, visibility: "private" | "public" | "unlisted"): Promise<any>;
        /**
         * Helper: Upload and link avatar with automatic public visibility
         * @param file - The avatar file
         * @param userId - User ID to link to
         * @param app - App name (defaults to 'profiles')
         * @returns The uploaded and linked asset
         */
        uploadAvatar(file: File, userId: string, app?: string): Promise<any>;
        /**
         * Helper: Upload and link profile banner with automatic public visibility
         * @param file - The banner file
         * @param userId - User ID to link to
         * @param app - App name (defaults to 'profiles')
         * @returns The uploaded and linked asset
         */
        uploadProfileBanner(file: File, userId: string, app?: string): Promise<any>;
        getAssetUrlCacheTTL(expiresIn?: number): number;
        fetchAssetDownloadUrl(fileId: string, variant?: string, cacheTTL?: number, expiresIn?: number): Promise<string | null>;
        fetchAssetContent(url: string, type: "text"): Promise<string>;
        fetchAssetContent(url: string, type: "blob"): Promise<Blob>;
        httpService: import("../HttpService").HttpService;
        cloudURL: string;
        config: import("../OxyServices.base").OxyConfig;
        makeRequest<T_1>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../HttpService").RequestOptions): Promise<T_1>;
        getBaseURL(): string;
        getClient(): import("../HttpService").HttpService;
        getMetrics(): {
            totalRequests: number;
            successfulRequests: number;
            failedRequests: number;
            cacheHits: number;
            cacheMisses: number;
            averageResponseTime: number;
        };
        clearCache(): void;
        clearCacheEntry(key: string): void;
        getCacheStats(): {
            size: number;
            hits: number;
            misses: number;
            hitRate: number;
        };
        getCloudURL(): string;
        setTokens(accessToken: string, refreshToken?: string): void;
        clearTokens(): void;
        getCurrentUserId(): string | null;
        hasValidToken(): boolean;
        getAccessToken(): string | null;
        waitForAuth(timeoutMs?: number): Promise<boolean>;
        withAuthRetry<T_1>(operation: () => Promise<T_1>, operationName: string, options?: {
            maxRetries?: number;
            retryDelay?: number;
            authTimeoutMs?: number;
        }): Promise<T_1>;
        validate(): Promise<boolean>;
        handleError(error: unknown): Error;
        healthCheck(): Promise<{
            status: string;
            users?: number;
            timestamp?: string;
            [key: string]: any;
        }>;
    };
    __resetTokensForTests(): void;
} & T;
//# sourceMappingURL=OxyServices.assets.d.ts.map