@visulima/storage-client 1.0.0-alpha.1

package/dist/vue/use-chunked-rest-upload.d.ts

@@ -0,0 +1,56 @@
+import type { Ref } from "vue";
+import type { UploadResult } from "../react/types.d.ts";
+export interface UseChunkedRestUploadOptions {
+    /** Chunk size for chunked REST uploads (default: 5MB) */
+    chunkSize?: number;
+    /** Chunked REST upload endpoint URL */
+    endpoint: string;
+    /** Maximum number of retry attempts */
+    maxRetries?: number;
+    /** Additional metadata to include with the upload */
+    metadata?: Record<string, string>;
+    /** Callback when upload fails */
+    onError?: (error: Error) => void;
+    /** Callback when upload is paused */
+    onPause?: () => void;
+    /** Callback when upload progress updates */
+    onProgress?: (progress: number, offset: number) => void;
+    /** Callback when upload is resumed */
+    onResume?: () => void;
+    /** Callback when upload starts */
+    onStart?: () => void;
+    /** Callback when upload completes successfully */
+    onSuccess?: (file: UploadResult) => void;
+    /** Enable automatic retry on failure */
+    retry?: boolean;
+}
+export interface UseChunkedRestUploadReturn {
+    /** Abort the current upload */
+    abort: () => void;
+    /** Last upload error, if any */
+    error: Ref<Error | undefined>;
+    /** Whether the upload is paused */
+    isPaused: Ref<boolean>;
+    /** Whether an upload is currently in progress */
+    isUploading: Ref<boolean>;
+    /** Current upload offset (bytes uploaded) */
+    offset: Ref<number>;
+    /** Pause the current upload */
+    pause: () => void;
+    /** Current upload progress (0-100) */
+    progress: Ref<number>;
+    /** Reset upload state */
+    reset: () => void;
+    /** Last upload result, if any */
+    result: Ref<UploadResult | undefined>;
+    /** Resume a paused upload */
+    resume: () => Promise<void>;
+    /** Upload a file using chunked REST protocol */
+    upload: (file: File) => Promise<UploadResult>;
+}
+/**
+ * Vue composable for chunked REST file uploads.
+ * @param options Upload configuration options
+ * @returns Upload functions and state
+ */
+export declare const useChunkedRestUpload: (options: UseChunkedRestUploadOptions) => UseChunkedRestUploadReturn;

package/dist/vue/use-delete-file.d.ts

@@ -0,0 +1,22 @@
+import type { Ref } from "vue";
+export interface UseDeleteFileOptions {
+    /** Base endpoint URL for file operations */
+    endpoint: string;
+}
+export interface UseDeleteFileReturn {
+    /** Delete a file by ID */
+    deleteFile: (id: string) => Promise<void>;
+    /** Last request error, if any */
+    error: Readonly<Ref<Error | undefined>>;
+    /** Whether a request is currently in progress */
+    isLoading: Readonly<Ref<boolean>>;
+    /** Reset mutation state */
+    reset: () => void;
+}
+/**
+ * Vue composable for deleting a single file using TanStack Query.
+ * Automatically invalidates related queries.
+ * @param options Hook configuration options
+ * @returns File deletion functions and state
+ */
+export declare const useDeleteFile: (options: UseDeleteFileOptions) => UseDeleteFileReturn;

package/dist/vue/use-file-input.d.ts

@@ -0,0 +1,33 @@
+import type { Ref } from "vue";
+export interface UseFileInputOptions {
+    /** Accept file types (e.g., "image/*", ".pdf") */
+    accept?: string;
+    /** Whether to allow multiple file selection */
+    multiple?: boolean;
+    /** Callback when files are selected */
+    onFilesSelected?: (files: File[]) => void;
+}
+export interface UseFileInputReturn {
+    /** Currently selected files */
+    files: Ref<File[]>;
+    /** Handle drag leave event */
+    handleDragLeave: (event: DragEvent) => void;
+    /** Handle drag and drop events */
+    handleDragOver: (event: DragEvent) => void;
+    /** Handle drop event */
+    handleDrop: (event: DragEvent) => void;
+    /** Handle file input change event */
+    handleFileChange: (event: Event) => void;
+    /** File input element ref */
+    inputRef: Ref<HTMLInputElement | undefined>;
+    /** Open file dialog programmatically */
+    openFileDialog: () => void;
+    /** Reset selected files */
+    reset: () => void;
+}
+/**
+ * Vue composable for file input handling with drag & drop support.
+ * @param options Configuration options
+ * @returns File input functions and state
+ */
+export declare const useFileInput: (options?: UseFileInputOptions) => UseFileInputReturn;

package/dist/vue/use-get-file-list.d.ts

@@ -0,0 +1,43 @@
+import type { MaybeRefOrGetter, Ref } from "vue";
+import type { FileMeta } from "../react/types.d.ts";
+export interface FileListResponse {
+    data: FileMeta[];
+    meta?: {
+        firstPage?: number;
+        firstPageUrl?: string;
+        lastPage?: number;
+        lastPageUrl?: string;
+        nextPageUrl?: string | undefined;
+        page?: number;
+        perPage?: number;
+        previousPageUrl?: string | undefined;
+        total?: number;
+    };
+}
+export interface UseGetFileListOptions {
+    /** Whether to enable the query */
+    enabled?: MaybeRefOrGetter<boolean>;
+    /** Base endpoint URL for file operations */
+    endpoint: string;
+    /** Maximum number of elements to retrieve */
+    limit?: MaybeRefOrGetter<number | undefined>;
+    /** Page number for pagination */
+    page?: MaybeRefOrGetter<number | undefined>;
+}
+export interface UseGetFileListReturn {
+    /** File list data */
+    data: Readonly<Ref<FileListResponse | undefined>>;
+    /** Last request error, if any */
+    error: Readonly<Ref<Error | undefined>>;
+    /** Whether a request is currently in progress */
+    isLoading: Readonly<Ref<boolean>>;
+    /** Refetch the file list */
+    refetch: () => void;
+}
+/**
+ * Vue composable for fetching a list of files using TanStack Query.
+ * Supports pagination via query parameters.
+ * @param options Hook configuration options
+ * @returns File list fetching functions and state
+ */
+export declare const useGetFileList: (options: UseGetFileListOptions) => UseGetFileListReturn;

package/dist/vue/use-get-file-meta.d.ts

@@ -0,0 +1,26 @@
+import type { MaybeRefOrGetter, Ref } from "vue";
+import type { FileMeta } from "../react/types.d.ts";
+export interface UseGetFileMetaOptions {
+    /** Whether to enable the query */
+    enabled?: MaybeRefOrGetter<boolean>;
+    /** Base endpoint URL for file operations */
+    endpoint: string;
+    /** File ID to fetch metadata for */
+    id: MaybeRefOrGetter<string>;
+}
+export interface UseGetFileMetaReturn {
+    /** File metadata */
+    data: Readonly<Ref<FileMeta | undefined>>;
+    /** Last request error, if any */
+    error: Readonly<Ref<Error | undefined>>;
+    /** Whether a request is currently in progress */
+    isLoading: Readonly<Ref<boolean>>;
+    /** Refetch the file metadata */
+    refetch: () => void;
+}
+/**
+ * Vue composable for fetching file metadata using TanStack Query.
+ * @param options Hook configuration options
+ * @returns File metadata fetching functions and state
+ */
+export declare const useGetFileMeta: (options: UseGetFileMetaOptions) => UseGetFileMetaReturn;

package/dist/vue/use-get-file.d.ts

@@ -0,0 +1,35 @@
+import type { MaybeRefOrGetter, Ref } from "vue";
+import type { FileMeta } from "../react/types.d.ts";
+export interface UseGetFileOptions {
+    /** Whether to enable the query */
+    enabled?: MaybeRefOrGetter<boolean>;
+    /** Base endpoint URL for file operations */
+    endpoint: string;
+    /** File ID to fetch */
+    id: MaybeRefOrGetter<string>;
+    /** Callback when request fails */
+    onError?: (error: Error) => void;
+    /** Callback when request succeeds */
+    onSuccess?: (data: Blob, meta: FileMeta | undefined) => void;
+    /** Transformation parameters for media files */
+    transform?: MaybeRefOrGetter<Record<string, string | number | boolean> | undefined>;
+}
+export interface UseGetFileReturn {
+    /** File data as Blob */
+    data: Readonly<Ref<Blob | undefined>>;
+    /** Last request error, if any */
+    error: Readonly<Ref<Error | undefined>>;
+    /** Whether a request is currently in progress */
+    isLoading: Readonly<Ref<boolean>>;
+    /** File metadata from response headers */
+    meta: Readonly<Ref<FileMeta | undefined>>;
+    /** Refetch the file */
+    refetch: () => void;
+}
+/**
+ * Vue composable for fetching/downloading files using TanStack Query.
+ * Supports optional transformation parameters for media files.
+ * @param options Hook configuration options
+ * @returns File fetching functions and state
+ */
+export declare const useGetFile: (options: UseGetFileOptions) => UseGetFileReturn;

package/dist/vue/use-head-file.d.ts

@@ -0,0 +1,46 @@
+import type { MaybeRefOrGetter, Ref } from "vue";
+export interface FileHeadMetadata {
+    /** Whether this is a chunked upload session */
+    chunkedUpload?: boolean;
+    /** Content length in bytes */
+    contentLength?: number;
+    /** Content type */
+    contentType?: string;
+    /** Entity tag for caching */
+    etag?: string;
+    /** Last modified date */
+    lastModified?: string;
+    /** Received chunk offsets (chunked uploads) */
+    receivedChunks?: number[];
+    /** Whether upload is complete (chunked uploads) */
+    uploadComplete?: boolean;
+    /** Upload expiration date */
+    uploadExpires?: string;
+    /** Upload offset for chunked uploads */
+    uploadOffset?: number;
+}
+export interface UseHeadFileOptions {
+    /** Whether to enable the query */
+    enabled?: MaybeRefOrGetter<boolean>;
+    /** Base endpoint URL for file operations */
+    endpoint: string;
+    /** File ID to fetch metadata for */
+    id: MaybeRefOrGetter<string>;
+}
+export interface UseHeadFileReturn {
+    /** File metadata from HEAD request */
+    data: Readonly<Ref<FileHeadMetadata | undefined>>;
+    /** Last request error, if any */
+    error: Readonly<Ref<Error | undefined>>;
+    /** Whether a request is currently in progress */
+    isLoading: Readonly<Ref<boolean>>;
+    /** Refetch the file metadata */
+    refetch: () => void;
+}
+/**
+ * Vue composable for fetching file metadata via HEAD request using TanStack Query.
+ * Useful for checking upload progress and file status without downloading.
+ * @param options Hook configuration options
+ * @returns File HEAD request functions and state
+ */
+export declare const useHeadFile: (options: UseHeadFileOptions) => UseHeadFileReturn;

package/dist/vue/use-multipart-upload.d.ts

@@ -0,0 +1,36 @@
+import type { Ref } from "vue";
+import type { UploadResult } from "../react/types.d.ts";
+export interface UseMultipartUploadOptions {
+    /** Upload endpoint URL */
+    endpoint: string;
+    /** Additional metadata to include with the upload */
+    metadata?: Record<string, string>;
+    /** Callback when upload fails */
+    onError?: (error: Error) => void;
+    /** Callback when upload progress updates */
+    onProgress?: (progress: number) => void;
+    /** Callback when upload starts */
+    onStart?: () => void;
+    /** Callback when upload completes successfully */
+    onSuccess?: (file: UploadResult) => void;
+}
+export interface UseMultipartUploadReturn {
+    /** Last upload error, if any */
+    error: Ref<Error | undefined>;
+    /** Whether an upload is currently in progress */
+    isUploading: Ref<boolean>;
+    /** Current upload progress (0-100) */
+    progress: Ref<number>;
+    /** Reset upload state */
+    reset: () => void;
+    /** Last upload result, if any */
+    result: Ref<UploadResult | undefined>;
+    /** Upload a file using multipart/form-data */
+    upload: (file: File) => Promise<UploadResult>;
+}
+/**
+ * Vue composable for multipart/form-data file uploads using rpldy uploader core.
+ * @param options Upload configuration options
+ * @returns Upload functions and state
+ */
+export declare const useMultipartUpload: (options: UseMultipartUploadOptions) => UseMultipartUploadReturn;

package/dist/vue/use-paste-upload.d.ts

@@ -0,0 +1,21 @@
+import type { Ref } from "vue";
+export interface UsePasteUploadOptions {
+    /** Filter function to determine which files to accept */
+    filter?: (file: File) => boolean;
+    /** Callback when files are pasted */
+    onFilesPasted?: (files: File[]) => void;
+}
+export interface UsePasteUploadReturn {
+    /** Handle paste event */
+    handlePaste: (event: ClipboardEvent) => void;
+    /** Files that were pasted */
+    pastedFiles: Ref<File[]>;
+    /** Reset pasted files */
+    reset: () => void;
+}
+/**
+ * Vue composable for handling paste uploads from clipboard.
+ * @param options Configuration options
+ * @returns Paste upload functions and state
+ */
+export declare const usePasteUpload: (options?: UsePasteUploadOptions) => UsePasteUploadReturn;

package/dist/vue/use-patch-chunk.d.ts

@@ -0,0 +1,26 @@
+import type { Ref } from "vue";
+import type { UploadResult } from "../react/types.d.ts";
+export interface UsePatchChunkOptions {
+    /** Base endpoint URL for file operations */
+    endpoint: string;
+}
+export interface UsePatchChunkReturn {
+    /** Last upload result, if any */
+    data: Readonly<Ref<UploadResult | undefined>>;
+    /** Last request error, if any */
+    error: Readonly<Ref<Error | undefined>>;
+    /** Whether a request is currently in progress */
+    isLoading: Readonly<Ref<boolean>>;
+    /** Upload a chunk for chunked uploads */
+    patchChunk: (id: string, chunk: Blob, offset: number, checksum?: string) => Promise<UploadResult>;
+    /** Reset mutation state */
+    reset: () => void;
+}
+/**
+ * Vue composable for uploading chunks in chunked uploads using TanStack Query.
+ * Requires X-Chunk-Offset header and chunk data.
+ * Automatically invalidates related queries when upload is complete.
+ * @param options Hook configuration options
+ * @returns Chunk upload functions and state
+ */
+export declare const usePatchChunk: (options: UsePatchChunkOptions) => UsePatchChunkReturn;

package/dist/vue/use-put-file.d.ts

@@ -0,0 +1,29 @@
+import type { Ref } from "vue";
+import type { UploadResult } from "../react/types.d.ts";
+export interface UsePutFileOptions {
+    /** Base endpoint URL for file operations */
+    endpoint: string;
+    /** Callback when upload progress updates */
+    onProgress?: (progress: number) => void;
+}
+export interface UsePutFileReturn {
+    /** Last upload result, if any */
+    data: Readonly<Ref<UploadResult | undefined>>;
+    /** Last request error, if any */
+    error: Readonly<Ref<Error | undefined>>;
+    /** Whether a request is currently in progress */
+    isLoading: Readonly<Ref<boolean>>;
+    /** Current upload progress (0-100) */
+    progress: Readonly<Ref<number>>;
+    /** Create or update a file by ID */
+    putFile: (id: string, file: File | Blob) => Promise<UploadResult>;
+    /** Reset mutation state */
+    reset: () => void;
+}
+/**
+ * Vue composable for creating or updating files via PUT request using TanStack Query.
+ * Automatically invalidates related queries.
+ * @param options Hook configuration options
+ * @returns File PUT functions and state
+ */
+export declare const usePutFile: (options: UsePutFileOptions) => UsePutFileReturn;

package/dist/vue/use-retry-listener.d.ts

@@ -0,0 +1,15 @@
+import type { UploadItem } from "../core/uploader.d.ts";
+export interface UseRetryListenerOptions {
+    /** Upload endpoint URL (used to create uploader instance) */
+    endpoint: string;
+    /** Additional metadata to include with the upload */
+    metadata?: Record<string, string>;
+    /** Callback when an item is retried */
+    onRetry: (item: UploadItem) => void;
+}
+/**
+ * Vue composable to listen to retry events.
+ * Note: This listens to ITEM_START events for items that have been retried (retryCount > 0).
+ * @param options Listener configuration options
+ */
+export declare const useRetryListener: (options: UseRetryListenerOptions) => void;

package/dist/vue/use-retry.d.ts

@@ -0,0 +1,16 @@
+export interface UseRetryOptions {
+    /** Upload endpoint URL (used to create uploader instance) */
+    endpoint: string;
+    /** Additional metadata to include with the upload */
+    metadata?: Record<string, string>;
+}
+export interface UseRetryReturn {
+    /** Retry a failed upload item by ID */
+    retryItem: (id: string) => void;
+}
+/**
+ * Vue composable to retry a failed upload item.
+ * @param options Configuration options
+ * @returns Retry function
+ */
+export declare const useRetry: (options: UseRetryOptions) => UseRetryReturn;

package/dist/vue/use-transform-file.d.ts

@@ -0,0 +1,45 @@
+import type { MaybeRefOrGetter, Ref } from "vue";
+import type { FileMeta } from "../react/types.d.ts";
+export interface TransformOptions {
+    /** Additional transformation parameters */
+    [key: string]: string | number | boolean | undefined;
+    /** Resize fit mode */
+    fit?: "cover" | "contain" | "fill" | "inside" | "outside";
+    /** Output format (jpeg, png, webp, etc.) */
+    format?: string;
+    /** Desired height in pixels */
+    height?: number;
+    /** Quality setting (0-100) */
+    quality?: number;
+    /** Desired width in pixels */
+    width?: number;
+}
+export interface UseTransformFileOptions {
+    /** Whether to enable the query */
+    enabled?: MaybeRefOrGetter<boolean>;
+    /** Base endpoint URL for transform operations */
+    endpoint: string;
+    /** File ID to transform */
+    id: MaybeRefOrGetter<string>;
+    /** Transformation parameters */
+    transform: MaybeRefOrGetter<TransformOptions>;
+}
+export interface UseTransformFileReturn {
+    /** Transformed file data as Blob */
+    data: Readonly<Ref<Blob | undefined>>;
+    /** Last request error, if any */
+    error: Readonly<Ref<Error | undefined>>;
+    /** Whether a request is currently in progress */
+    isLoading: Readonly<Ref<boolean>>;
+    /** File metadata from response headers */
+    meta: Readonly<Ref<FileMeta | undefined>>;
+    /** Refetch the transformed file */
+    refetch: () => void;
+}
+/**
+ * Vue composable for fetching transformed files using TanStack Query.
+ * Supports image, video, and audio transformation parameters.
+ * @param options Hook configuration options
+ * @returns Transform file fetching functions and state
+ */
+export declare const useTransformFile: (options: UseTransformFileOptions) => UseTransformFileReturn;

package/dist/vue/use-transform-metadata.d.ts

@@ -0,0 +1,30 @@
+import type { MaybeRefOrGetter, Ref } from "vue";
+export interface TransformMetadata {
+    /** Available transformation formats */
+    formats?: string[];
+    /** Supported transformation parameters */
+    parameters?: string[];
+}
+export interface UseTransformMetadataOptions {
+    /** Whether to enable the query */
+    enabled?: MaybeRefOrGetter<boolean>;
+    /** Base endpoint URL for transform operations */
+    endpoint: string;
+}
+export interface UseTransformMetadataReturn {
+    /** Transform metadata */
+    data: Readonly<Ref<TransformMetadata | undefined>>;
+    /** Last request error, if any */
+    error: Readonly<Ref<Error | undefined>>;
+    /** Whether a request is currently in progress */
+    isLoading: Readonly<Ref<boolean>>;
+    /** Refetch the transform metadata */
+    refetch: () => void;
+}
+/**
+ * Vue composable for fetching transformation metadata using TanStack Query.
+ * Returns available formats and transformation parameters.
+ * @param options Hook configuration options
+ * @returns Transform metadata fetching functions and state
+ */
+export declare const useTransformMetadata: (options: UseTransformMetadataOptions) => UseTransformMetadataReturn;

package/dist/vue/use-tus-upload.d.ts

@@ -0,0 +1,56 @@
+import type { Ref } from "vue";
+import type { UploadResult } from "../react/types.d.ts";
+export interface UseTusUploadOptions {
+    /** Chunk size for TUS uploads (default: 1MB) */
+    chunkSize?: number;
+    /** TUS upload endpoint URL */
+    endpoint: string;
+    /** Maximum number of retry attempts */
+    maxRetries?: number;
+    /** Additional metadata to include with the upload */
+    metadata?: Record<string, string>;
+    /** Callback when upload fails */
+    onError?: (error: Error) => void;
+    /** Callback when upload is paused */
+    onPause?: () => void;
+    /** Callback when upload progress updates */
+    onProgress?: (progress: number) => void;
+    /** Callback when upload is resumed */
+    onResume?: () => void;
+    /** Callback when upload starts */
+    onStart?: () => void;
+    /** Callback when upload completes successfully */
+    onSuccess?: (file: UploadResult) => void;
+    /** Enable automatic retry on failure */
+    retry?: boolean;
+}
+export interface UseTusUploadReturn {
+    /** Abort the current upload */
+    abort: () => void;
+    /** Last upload error, if any */
+    error: Ref<Error | undefined>;
+    /** Whether the upload is paused */
+    isPaused: Ref<boolean>;
+    /** Whether an upload is currently in progress */
+    isUploading: Ref<boolean>;
+    /** Current upload offset (bytes uploaded) */
+    offset: Ref<number>;
+    /** Pause the current upload */
+    pause: () => void;
+    /** Current upload progress (0-100) */
+    progress: Ref<number>;
+    /** Reset upload state */
+    reset: () => void;
+    /** Last upload result, if any */
+    result: Ref<UploadResult | undefined>;
+    /** Resume a paused upload */
+    resume: () => Promise<void>;
+    /** Upload a file using TUS protocol */
+    upload: (file: File) => Promise<UploadResult>;
+}
+/**
+ * Vue composable for TUS resumable file uploads.
+ * @param options Upload configuration options
+ * @returns Upload functions and state
+ */
+export declare const useTusUpload: (options: UseTusUploadOptions) => UseTusUploadReturn;

package/dist/vue/use-upload.d.ts

@@ -0,0 +1,68 @@
+import type { ComputedRef } from "vue";
+import type { UploadMethod, UploadResult } from "../react/types.d.ts";
+export interface UseUploadOptions {
+    /** Chunk size for TUS and chunked REST uploads (default: 1MB for TUS, 5MB for chunked REST) */
+    chunkSize?: number;
+    /** Chunked REST upload endpoint URL */
+    endpointChunkedRest?: string;
+    /** Multipart upload endpoint URL */
+    endpointMultipart?: string;
+    /** TUS upload endpoint URL */
+    endpointTus?: string;
+    /** Maximum number of retry attempts (TUS and chunked REST only) */
+    maxRetries?: number;
+    /** Additional metadata to include with the upload */
+    metadata?: Record<string, string>;
+    /** Upload method to use: 'multipart', 'tus', 'chunked-rest', or 'auto'. If undefined, auto-detected based on provided endpoints */
+    method?: UploadMethod;
+    /** Callback when upload fails */
+    onError?: (error: Error) => void;
+    /** Callback when upload is paused (TUS and chunked REST only) */
+    onPause?: () => void;
+    /** Callback when upload progress updates */
+    onProgress?: (progress: number) => void;
+    /** Callback when upload is resumed (TUS and chunked REST only) */
+    onResume?: () => void;
+    /** Callback when upload starts */
+    onStart?: () => void;
+    /** Callback when upload completes successfully */
+    onSuccess?: (file: UploadResult) => void;
+    /** Enable automatic retry on failure (TUS and chunked REST only) */
+    retry?: boolean;
+    /** File size threshold for auto-selecting TUS (default: 10MB) */
+    tusThreshold?: number;
+}
+export interface UseUploadReturn {
+    /** Abort the current upload */
+    abort: () => void;
+    /** Current upload method being used */
+    currentMethod: ComputedRef<UploadMethod>;
+    /** Last upload error, if any */
+    error: ComputedRef<Error | undefined>;
+    /** Whether the upload is paused (TUS and chunked REST only) */
+    isPaused: ComputedRef<boolean | undefined>;
+    /** Whether an upload is currently in progress */
+    isUploading: ComputedRef<boolean>;
+    /** Current upload offset in bytes (TUS and chunked REST only) */
+    offset: ComputedRef<number | undefined>;
+    /** Pause the current upload (TUS and chunked REST only) */
+    pause: ComputedRef<(() => void) | undefined>;
+    /** Current upload progress (0-100) */
+    progress: ComputedRef<number>;
+    /** Reset upload state */
+    reset: () => void;
+    /** Last upload result, if any */
+    result: ComputedRef<UploadResult | undefined>;
+    /** Resume a paused upload (TUS and chunked REST only) */
+    resume: ComputedRef<(() => Promise<void>) | undefined>;
+    /** Upload a file using the configured method */
+    upload: (file: File) => Promise<UploadResult>;
+}
+/**
+ * Vue composable for file uploads with automatic method selection.
+ * Uses custom uploader implementations for multipart, TUS, and chunked REST.
+ * Automatically chooses between methods based on file size and method preference.
+ * @param options Upload configuration options
+ * @returns Upload functions and state
+ */
+export declare const useUpload: (options: UseUploadOptions) => UseUploadReturn;