@visulima/storage-client 1.0.0-alpha.12 → 1.0.0-alpha.14

package/dist/vue/index.d.ts

@@ -1,60 +1,804 @@
-export type { UseAbortAllOptions, UseAbortAllReturn } from "./use-abort-all.d.ts";
-export { useAbortAll } from "./use-abort-all.d.ts";
-export type { UseAbortBatchOptions, UseAbortBatchReturn } from "./use-abort-batch.d.ts";
-export { useAbortBatch } from "./use-abort-batch.d.ts";
-export type { UseAbortItemOptions, UseAbortItemReturn } from "./use-abort-item.d.ts";
-export { useAbortItem } from "./use-abort-item.d.ts";
-export type { UseAllAbortListenerOptions } from "./use-all-abort-listener.d.ts";
-export { useAllAbortListener } from "./use-all-abort-listener.d.ts";
-export type { UseBatchCancelledListenerOptions } from "./use-batch-cancelled-listener.d.ts";
-export { useBatchCancelledListener } from "./use-batch-cancelled-listener.d.ts";
-export type { BatchDeleteResult, UseBatchDeleteFilesOptions, UseBatchDeleteFilesReturn } from "./use-batch-delete-files.d.ts";
-export { useBatchDeleteFiles } from "./use-batch-delete-files.d.ts";
-export type { UseBatchErrorListenerOptions } from "./use-batch-error-listener.d.ts";
-export { useBatchErrorListener } from "./use-batch-error-listener.d.ts";
-export type { UseBatchFinalizeListenerOptions } from "./use-batch-finalize-listener.d.ts";
-export { useBatchFinalizeListener } from "./use-batch-finalize-listener.d.ts";
-export type { UseBatchFinishListenerOptions } from "./use-batch-finish-listener.d.ts";
-export { useBatchFinishListener } from "./use-batch-finish-listener.d.ts";
-export type { UseBatchProgressListenerOptions } from "./use-batch-progress-listener.d.ts";
-export { useBatchProgressListener } from "./use-batch-progress-listener.d.ts";
-export type { UseBatchRetryOptions, UseBatchRetryReturn } from "./use-batch-retry.d.ts";
-export { useBatchRetry } from "./use-batch-retry.d.ts";
-export type { UseBatchStartListenerOptions } from "./use-batch-start-listener.d.ts";
-export { useBatchStartListener } from "./use-batch-start-listener.d.ts";
-export type { UseBatchUploadOptions, UseBatchUploadReturn } from "./use-batch-upload.d.ts";
-export { useBatchUpload } from "./use-batch-upload.d.ts";
-export type { UseChunkedRestUploadOptions, UseChunkedRestUploadReturn } from "./use-chunked-rest-upload.d.ts";
-export { useChunkedRestUpload } from "./use-chunked-rest-upload.d.ts";
-export type { UseDeleteFileOptions, UseDeleteFileReturn } from "./use-delete-file.d.ts";
-export { useDeleteFile } from "./use-delete-file.d.ts";
-export type { UseFileInputOptions, UseFileInputReturn } from "./use-file-input.d.ts";
-export { useFileInput } from "./use-file-input.d.ts";
-export type { UseGetFileOptions, UseGetFileReturn } from "./use-get-file.d.ts";
-export { useGetFile } from "./use-get-file.d.ts";
-export type { FileListResponse, UseGetFileListOptions, UseGetFileListReturn } from "./use-get-file-list.d.ts";
-export { useGetFileList } from "./use-get-file-list.d.ts";
-export type { UseGetFileMetaOptions, UseGetFileMetaReturn } from "./use-get-file-meta.d.ts";
-export { useGetFileMeta } from "./use-get-file-meta.d.ts";
-export type { FileHeadMetadata, UseHeadFileOptions, UseHeadFileReturn } from "./use-head-file.d.ts";
-export { useHeadFile } from "./use-head-file.d.ts";
-export type { UseMultipartUploadOptions, UseMultipartUploadReturn } from "./use-multipart-upload.d.ts";
-export { useMultipartUpload } from "./use-multipart-upload.d.ts";
-export type { UsePasteUploadOptions, UsePasteUploadReturn } from "./use-paste-upload.d.ts";
-export { usePasteUpload } from "./use-paste-upload.d.ts";
-export type { UsePatchChunkOptions, UsePatchChunkReturn } from "./use-patch-chunk.d.ts";
-export { usePatchChunk } from "./use-patch-chunk.d.ts";
-export type { UsePutFileOptions, UsePutFileReturn } from "./use-put-file.d.ts";
-export { usePutFile } from "./use-put-file.d.ts";
-export type { UseRetryOptions, UseRetryReturn } from "./use-retry.d.ts";
-export { useRetry } from "./use-retry.d.ts";
-export type { UseRetryListenerOptions } from "./use-retry-listener.d.ts";
-export { useRetryListener } from "./use-retry-listener.d.ts";
-export type { TransformOptions, UseTransformFileOptions, UseTransformFileReturn } from "./use-transform-file.d.ts";
-export { useTransformFile } from "./use-transform-file.d.ts";
-export type { TransformMetadata, UseTransformMetadataOptions, UseTransformMetadataReturn } from "./use-transform-metadata.d.ts";
-export { useTransformMetadata } from "./use-transform-metadata.d.ts";
-export type { UseTusUploadOptions, UseTusUploadReturn } from "./use-tus-upload.d.ts";
-export { useTusUpload } from "./use-tus-upload.d.ts";
-export type { UseUploadOptions, UseUploadReturn } from "./use-upload.d.ts";
-export { useUpload } from "./use-upload.d.ts";
+import { c as UploadItem, B as BatchState, U as UploadResult, F as FileMeta, g as UploadMethod } from "../packem_shared/uploader.d-DsC50BbX.js";
+import { Ref, MaybeRefOrGetter, ComputedRef } from 'vue';
+interface UseAbortAllOptions {
+  /** Upload endpoint URL (used to create uploader instance) */
+  endpoint: string;
+  /** Additional metadata to include with the upload */
+  metadata?: Record<string, string>;
+}
+interface UseAbortAllReturn {
+  /** Abort all active uploads */
+  abortAll: () => void;
+}
+/**
+* Vue composable to abort all active uploads.
+* @param options Configuration options
+* @returns Abort all function
+*/
+declare const useAbortAll: (options: UseAbortAllOptions) => UseAbortAllReturn;
+interface UseAbortBatchOptions {
+  /** Upload endpoint URL (used to create uploader instance) */
+  endpoint: string;
+  /** Additional metadata to include with the upload */
+  metadata?: Record<string, string>;
+}
+interface UseAbortBatchReturn {
+  /** Abort a batch of uploads by batch ID */
+  abortBatch: (batchId: string) => void;
+}
+/**
+* Vue composable to abort a batch of uploads.
+* @param options Configuration options
+* @returns Abort batch function
+*/
+declare const useAbortBatch: (options: UseAbortBatchOptions) => UseAbortBatchReturn;
+interface UseAbortItemOptions {
+  /** Upload endpoint URL (used to create uploader instance) */
+  endpoint: string;
+  /** Additional metadata to include with the upload */
+  metadata?: Record<string, string>;
+}
+interface UseAbortItemReturn {
+  /** Abort a specific upload item by ID */
+  abortItem: (id: string) => void;
+}
+/**
+* Vue composable to abort a specific upload item.
+* @param options Configuration options
+* @returns Abort function
+*/
+declare const useAbortItem: (options: UseAbortItemOptions) => UseAbortItemReturn;
+interface UseAllAbortListenerOptions {
+  /** Upload endpoint URL (used to create uploader instance) */
+  endpoint: string;
+  /** Additional metadata to include with the upload */
+  metadata?: Record<string, string>;
+  /** Callback when any item is aborted */
+  onAbort: (item: UploadItem) => void;
+}
+/**
+* Vue composable to listen to all abort events (item aborts).
+* @param options Listener configuration options
+*/
+declare const useAllAbortListener: (options: UseAllAbortListenerOptions) => void;
+interface UseBatchCancelledListenerOptions {
+  /** Upload endpoint URL (used to create uploader instance) */
+  endpoint: string;
+  /** Additional metadata to include with the upload */
+  metadata?: Record<string, string>;
+  /** Callback when batch is cancelled */
+  onBatchCancelled: (batch: BatchState) => void;
+}
+/**
+* Vue composable to listen to batch cancelled events.
+* @param options Listener configuration options
+*/
+declare const useBatchCancelledListener: (options: UseBatchCancelledListenerOptions) => void;
+interface BatchDeleteResult {
+  /** Number of files that failed to delete */
+  failed?: number;
+  /** Number of files successfully deleted */
+  successful?: number;
+}
+interface UseBatchDeleteFilesOptions {
+  /** Base endpoint URL for file operations */
+  endpoint: string;
+}
+interface UseBatchDeleteFilesReturn {
+  /** Delete multiple files by IDs */
+  batchDeleteFiles: (ids: string[]) => Promise<BatchDeleteResult>;
+  /** 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 batch deleting files using TanStack Query.
+* Supports both query parameter and JSON body methods.
+* Automatically invalidates related queries.
+* @param options Hook configuration options
+* @returns Batch file deletion functions and state
+*/
+declare const useBatchDeleteFiles: (options: UseBatchDeleteFilesOptions) => UseBatchDeleteFilesReturn;
+interface UseBatchErrorListenerOptions {
+  /** Upload endpoint URL (used to create uploader instance) */
+  endpoint: string;
+  /** Additional metadata to include with the upload */
+  metadata?: Record<string, string>;
+  /** Callback when batch encounters an error */
+  onBatchError: (batch: BatchState) => void;
+}
+/**
+* Vue composable to listen to batch error events.
+* @param options Listener configuration options
+*/
+declare const useBatchErrorListener: (options: UseBatchErrorListenerOptions) => void;
+interface UseBatchFinalizeListenerOptions {
+  /** Upload endpoint URL (used to create uploader instance) */
+  endpoint: string;
+  /** Additional metadata to include with the upload */
+  metadata?: Record<string, string>;
+  /** Callback when batch finalizes (after all items complete) */
+  onBatchFinalize: (batch: BatchState) => void;
+}
+/**
+* Vue composable to listen to batch finalize events.
+* This event fires after all items in a batch have completed (successfully or with errors).
+* @param options Listener configuration options
+*/
+declare const useBatchFinalizeListener: (options: UseBatchFinalizeListenerOptions) => void;
+interface UseBatchFinishListenerOptions {
+  /** Upload endpoint URL (used to create uploader instance) */
+  endpoint: string;
+  /** Additional metadata to include with the upload */
+  metadata?: Record<string, string>;
+  /** Callback when batch finishes successfully */
+  onBatchFinish: (batch: BatchState) => void;
+}
+/**
+* Vue composable to listen to batch finish events.
+* @param options Listener configuration options
+*/
+declare const useBatchFinishListener: (options: UseBatchFinishListenerOptions) => void;
+interface UseBatchProgressListenerOptions {
+  /** Upload endpoint URL (used to create uploader instance) */
+  endpoint: string;
+  /** Additional metadata to include with the upload */
+  metadata?: Record<string, string>;
+  /** Callback when batch progress updates */
+  onBatchProgress: (batch: BatchState) => void;
+}
+/**
+* Vue composable to listen to batch progress events.
+* @param options Listener configuration options
+*/
+declare const useBatchProgressListener: (options: UseBatchProgressListenerOptions) => void;
+interface UseBatchRetryOptions {
+  /** Upload endpoint URL (used to create uploader instance) */
+  endpoint: string;
+  /** Additional metadata to include with the upload */
+  metadata?: Record<string, string>;
+}
+interface UseBatchRetryReturn {
+  /** Retry all failed items in a batch */
+  retryBatch: (batchId: string) => void;
+}
+/**
+* Vue composable to retry all failed items in a batch.
+* @param options Configuration options
+* @returns Retry batch function
+*/
+declare const useBatchRetry: (options: UseBatchRetryOptions) => UseBatchRetryReturn;
+interface UseBatchStartListenerOptions {
+  /** Upload endpoint URL (used to create uploader instance) */
+  endpoint: string;
+  /** Additional metadata to include with the upload */
+  metadata?: Record<string, string>;
+  /** Callback when batch starts */
+  onBatchStart: (batch: BatchState) => void;
+}
+/**
+* Vue composable to listen to batch start events.
+* @param options Listener configuration options
+*/
+declare const useBatchStartListener: (options: UseBatchStartListenerOptions) => void;
+interface UseBatchUploadOptions {
+  /** Upload endpoint URL */
+  endpoint: string;
+  /** Additional metadata to include with the upload */
+  metadata?: Record<string, string>;
+  /** Callback when batch fails */
+  onError?: (error: Error, batchId: string) => void;
+  /** Callback when batch progress updates */
+  onProgress?: (progress: number, batchId: string) => void;
+  /** Callback when batch starts */
+  onStart?: (batchId: string) => void;
+  /** Callback when batch completes successfully */
+  onSuccess?: (results: UploadResult[], batchId: string) => void;
+}
+interface UseBatchUploadReturn {
+  /** Abort a specific batch */
+  abortBatch: (batchId: string) => void;
+  /** Number of completed items in current batch */
+  completedCount: Ref<number>;
+  /** Last batch error, if any */
+  error: Ref<Error | undefined>;
+  /** Number of failed items in current batch */
+  errorCount: Ref<number>;
+  /** Whether a batch is currently uploading */
+  isUploading: Ref<boolean>;
+  /** All upload items in current batch */
+  items: Ref<UploadItem[]>;
+  /** Current batch progress (0-100) */
+  progress: Ref<number>;
+  /** Reset batch state */
+  reset: () => void;
+  /** Upload multiple files as a batch */
+  uploadBatch: (files: File[]) => string[];
+}
+/**
+* Vue composable for batch file uploads using multipart/form-data.
+* @param options Upload configuration options
+* @returns Batch upload functions and state
+*/
+declare const useBatchUpload: (options: UseBatchUploadOptions) => UseBatchUploadReturn;
+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;
+}
+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
+*/
+declare const useChunkedRestUpload: (options: UseChunkedRestUploadOptions) => UseChunkedRestUploadReturn;
+interface UseDeleteFileOptions {
+  /** Base endpoint URL for file operations */
+  endpoint: string;
+}
+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
+*/
+declare const useDeleteFile: (options: UseDeleteFileOptions) => UseDeleteFileReturn;
+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;
+}
+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
+*/
+declare const useFileInput: (options?: UseFileInputOptions) => UseFileInputReturn;
+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>;
+}
+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
+*/
+declare const useGetFile: (options: UseGetFileOptions) => UseGetFileReturn;
+interface FileListResponse {
+  data: FileMeta[];
+  meta?: {
+    firstPage?: number;
+    firstPageUrl?: string;
+    lastPage?: number;
+    lastPageUrl?: string;
+    nextPageUrl?: string;
+    page?: number;
+    perPage?: number;
+    previousPageUrl?: string;
+    total?: number;
+  };
+}
+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>;
+}
+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
+*/
+declare const useGetFileList: (options: UseGetFileListOptions) => UseGetFileListReturn;
+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>;
+}
+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
+*/
+declare const useGetFileMeta: (options: UseGetFileMetaOptions) => UseGetFileMetaReturn;
+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;
+}
+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>;
+}
+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
+*/
+declare const useHeadFile: (options: UseHeadFileOptions) => UseHeadFileReturn;
+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;
+}
+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
+*/
+declare const useMultipartUpload: (options: UseMultipartUploadOptions) => UseMultipartUploadReturn;
+interface UsePasteUploadOptions {
+  /** Filter function to determine which files to accept */
+  filter?: (file: File) => boolean;
+  /** Callback when files are pasted */
+  onFilesPasted?: (files: File[]) => void;
+}
+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
+*/
+declare const usePasteUpload: (options?: UsePasteUploadOptions) => UsePasteUploadReturn;
+interface UsePatchChunkOptions {
+  /** Base endpoint URL for file operations */
+  endpoint: string;
+}
+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
+*/
+declare const usePatchChunk: (options: UsePatchChunkOptions) => UsePatchChunkReturn;
+interface UsePutFileOptions {
+  /** Base endpoint URL for file operations */
+  endpoint: string;
+  /** Callback when upload progress updates */
+  onProgress?: (progress: number) => void;
+}
+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
+*/
+declare const usePutFile: (options: UsePutFileOptions) => UsePutFileReturn;
+interface UseRetryOptions {
+  /** Upload endpoint URL (used to create uploader instance) */
+  endpoint: string;
+  /** Additional metadata to include with the upload */
+  metadata?: Record<string, string>;
+}
+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
+*/
+declare const useRetry: (options: UseRetryOptions) => UseRetryReturn;
+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
+*/
+declare const useRetryListener: (options: UseRetryListenerOptions) => void;
+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;
+}
+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>;
+}
+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
+*/
+declare const useTransformFile: (options: UseTransformFileOptions) => UseTransformFileReturn;
+interface TransformMetadata {
+  /** Available transformation formats */
+  formats?: string[];
+  /** Supported transformation parameters */
+  parameters?: string[];
+}
+interface UseTransformMetadataOptions {
+  /** Whether to enable the query */
+  enabled?: MaybeRefOrGetter<boolean>;
+  /** Base endpoint URL for transform operations */
+  endpoint: string;
+}
+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
+*/
+declare const useTransformMetadata: (options: UseTransformMetadataOptions) => UseTransformMetadataReturn;
+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;
+}
+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
+*/
+declare const useTusUpload: (options: UseTusUploadOptions) => UseTusUploadReturn;
+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;
+}
+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
+*/
+declare const useUpload: (options: UseUploadOptions) => UseUploadReturn;
+export { type BatchDeleteResult, type FileHeadMetadata, type FileListResponse, type TransformMetadata, type TransformOptions, type UseAbortAllOptions, type UseAbortAllReturn, type UseAbortBatchOptions, type UseAbortBatchReturn, type UseAbortItemOptions, type UseAbortItemReturn, type UseAllAbortListenerOptions, type UseBatchCancelledListenerOptions, type UseBatchDeleteFilesOptions, type UseBatchDeleteFilesReturn, type UseBatchErrorListenerOptions, type UseBatchFinalizeListenerOptions, type UseBatchFinishListenerOptions, type UseBatchProgressListenerOptions, type UseBatchRetryOptions, type UseBatchRetryReturn, type UseBatchStartListenerOptions, type UseBatchUploadOptions, type UseBatchUploadReturn, type UseChunkedRestUploadOptions, type UseChunkedRestUploadReturn, type UseDeleteFileOptions, type UseDeleteFileReturn, type UseFileInputOptions, type UseFileInputReturn, type UseGetFileListOptions, type UseGetFileListReturn, type UseGetFileMetaOptions, type UseGetFileMetaReturn, type UseGetFileOptions, type UseGetFileReturn, type UseHeadFileOptions, type UseHeadFileReturn, type UseMultipartUploadOptions, type UseMultipartUploadReturn, type UsePasteUploadOptions, type UsePasteUploadReturn, type UsePatchChunkOptions, type UsePatchChunkReturn, type UsePutFileOptions, type UsePutFileReturn, type UseRetryListenerOptions, type UseRetryOptions, type UseRetryReturn, type UseTransformFileOptions, type UseTransformFileReturn, type UseTransformMetadataOptions, type UseTransformMetadataReturn, type UseTusUploadOptions, type UseTusUploadReturn, type UseUploadOptions, type UseUploadReturn, useAbortAll, useAbortBatch, useAbortItem, useAllAbortListener, useBatchCancelledListener, useBatchDeleteFiles, useBatchErrorListener, useBatchFinalizeListener, useBatchFinishListener, useBatchProgressListener, useBatchRetry, useBatchStartListener, useBatchUpload, useChunkedRestUpload, useDeleteFile, useFileInput, useGetFile, useGetFileList, useGetFileMeta, useHeadFile, useMultipartUpload, usePasteUpload, usePatchChunk, usePutFile, useRetry, useRetryListener, useTransformFile, useTransformMetadata, useTusUpload, useUpload };