import { ICloudbase } from '@cloudbase/types';
import { Camelize, FileBody, FileObject, FileObjectV2, FileOptions, TransformOptions } from './supabase/types';
import { StorageError } from './supabase/errors';
import { ICloudbaseUploadFileParams, ICloudbaseUploadFileResult, ICloudbaseGetUploadMetadataParams, ICloudbaseDeleteFileParams, ICloudbaseDeleteFileResult, ICloudbaseGetTempFileURLResult, ICloudbaseGetTempFileURLParams, ICloudbaseDownloadFileResult, ICloudbaseDownloadFileParams, ICloudbaseCopyFileParams, ICloudbaseCopyFileResult } from '@cloudbase/types/storage';
declare enum EUploadMethod {
    put = "put",
    post = "post"
}
interface IUploadMetadata {
    url: string;
    token: string;
    authorization: string;
    fileId: string;
    cosFileId: string;
    download_url?: string;
}
export declare const COMPONENT_NAME = "storage";
export interface ICloudbaseContext {
    config: any;
    request: any;
}
export declare class CloudbaseStorage {
    isGateWay(): boolean;
    uploadFile(params: Omit<ICloudbaseUploadFileParams, 'filePath'> & {
        filePath?: string;
    }, callback?: Function): Promise<ICloudbaseUploadFileResult>;
    getUploadMetadata(params: ICloudbaseGetUploadMetadataParams & {
        method?: EUploadMethod;
        headers?: Record<string, string>;
    }, callback?: Function): Promise<{
        data: IUploadMetadata;
        requestId: string;
    }>;
    deleteFile(params: ICloudbaseDeleteFileParams, callback?: Function): Promise<ICloudbaseDeleteFileResult>;
    getTempFileURL(params: ICloudbaseGetTempFileURLParams, callback?: Function): Promise<ICloudbaseGetTempFileURLResult>;
    downloadFile(params: ICloudbaseDownloadFileParams, callback?: Function): Promise<ICloudbaseDownloadFileResult>;
    copyFile(params: ICloudbaseCopyFileParams, callback?: Function): Promise<ICloudbaseCopyFileResult>;
    getFileInfo(params: ICloudbaseGetTempFileURLParams): Promise<{
        fileList: (Pick<ICloudbaseGetTempFileURLResult['fileList'][0], 'code' | 'fileID' | 'tempFileURL' | 'message'> & {
            fileName?: string;
            cloudId?: ICloudbaseGetTempFileURLResult['fileList'][0]['fileID'];
            contentType?: string;
            mime?: string;
            size?: number;
            cacheControl?: string;
            lastModified?: string;
            etag?: string;
        })[];
        requestId: string;
    }>;
}
export declare class SupabaseFileAPILikeStorage extends CloudbaseStorage {
    private shouldThrowOnError;
    private bucketId;
    private context;
    constructor(context?: ICloudbaseContext);
    get config(): any;
    get request(): any;
    throwOnError(): this;
    from(bucket?: string): this;
    upload(path: string, fileBody: FileBody, fileOptions?: FileOptions): Promise<{
        data: {
            id: string;
            path: string;
            fullPath: string;
        };
        error: null;
    } | {
        data: null;
        error: StorageError;
    }>;
    uploadToSignedUrl(path: string, _token: string, fileBody: FileBody, fileOptions?: FileOptions): Promise<{
        data: {
            id: string;
            path: string;
            fullPath: string;
        };
        error: null;
    } | {
        data: null;
        error: StorageError;
    }>;
    createSignedUploadUrl(path: string): Promise<{
        data: {
            signedUrl: string;
            token: string;
            path: string;
            authorization?: string;
            id?: string;
            cosFileId?: string;
            downloadUrl?: string;
        };
        error: null;
    } | {
        data: null;
        error: StorageError;
    }>;
    update(path: string, fileBody: FileBody, fileOptions?: FileOptions): Promise<{
        data: {
            id: string;
            path: string;
            fullPath: string;
        };
        error: null;
    } | {
        data: null;
        error: StorageError;
    }>;
    move(fromPath: string, toPath: string): Promise<{
        data: {
            message: string;
        };
        error: null;
    } | {
        data: null;
        error: StorageError;
    }>;
    copy(fromPath: string, toPath: string): Promise<{
        data: {
            path: string;
        };
        error: null;
    } | {
        data: null;
        error: StorageError;
    }>;
    createSignedUrl(path: string, expiresIn: number, options?: {
        download?: string | boolean;
        transform?: TransformOptions;
    }): Promise<{
        data: {
            signedUrl: string;
        };
        error: null;
    } | {
        data: null;
        error: StorageError;
    }>;
    createSignedUrls(paths: string[], expiresIn: number): Promise<{
        data: Array<{
            path: string;
            signedUrl: string;
            error: string | null;
        }>;
        error: null;
    } | {
        data: null;
        error: StorageError;
    }>;
    download(path: string, options?: TransformOptions): Promise<{
        data: Blob;
        error: StorageError | null;
    }>;
    info(pathOrFileId: string): Promise<{
        data: Camelize<FileObjectV2>;
        error: null;
    } | {
        data: null;
        error: StorageError;
    }>;
    exists(pathOrFileId: string): Promise<{
        data: boolean;
        error: null;
    } | {
        data: null;
        error: StorageError;
    }>;
    getPublicUrl(path: string, options?: {
        download?: string | boolean;
        transform?: TransformOptions;
    }): Promise<{
        data: {
            publicUrl: string;
        };
    } | {
        data: null;
        error: StorageError;
    }>;
    remove(paths: string[]): Promise<{
        data: FileObject[];
        error: null;
    } | {
        data: null;
        error: StorageError;
    }>;
    list(): Promise<void>;
    private _getCloudPath;
    private _normalizeCloudId;
    private toBase64;
    private _transformOptsToQueryString;
    private _extractPathFromFileId;
    private _extractBucketFromFileId;
}
export declare function registerStorage(app: Pick<ICloudbase, 'registerComponent'>): void;
export {};