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

package/dist/react/index.d.ts

@@ -1,61 +1,839 @@
-export type { UploadMethod, UploadResult } from "./types.d.ts";
-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";
+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;
+}
+/**
+* React hook 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;
+}
+/**
+* React hook 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;
+}
+/**
+* React hook 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;
+}
+/**
+* React hook 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;
+}
+/**
+* React hook 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;
+  /** Callback when request fails */
+  onError?: (error: Error) => void;
+  /** Callback when request succeeds */
+  onSuccess?: (result: BatchDeleteResult) => void;
+}
+interface UseBatchDeleteFilesReturn {
+  /** Delete multiple files by IDs */
+  batchDeleteFiles: (ids: string[]) => Promise<BatchDeleteResult>;
+  /** Last request error, if any */
+  error: Error | undefined;
+  /** Whether a request is currently in progress */
+  isLoading: boolean;
+  /** Reset mutation state */
+  reset: () => void;
+}
+/**
+* React hook 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;
+}
+/**
+* React hook 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;
+}
+/**
+* React hook 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;
+}
+/**
+* React hook 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;
+}
+/**
+* React hook 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;
+}
+/**
+* React hook 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;
+}
+/**
+* React hook 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: number;
+  /** Last batch error, if any */
+  error: Error | undefined;
+  /** Number of failed items in current batch */
+  errorCount: number;
+  /** Whether a batch is currently uploading */
+  isUploading: boolean;
+  /** All upload items in current batch */
+  items: UploadItem[];
+  /** Current batch progress (0-100) */
+  progress: number;
+  /** Reset batch state */
+  reset: () => void;
+  /** Upload multiple files as a batch */
+  uploadBatch: (files: File[]) => string[];
+}
+/**
+* React hook 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: Error | undefined;
+  /** Whether the upload is paused */
+  isPaused: boolean;
+  /** Whether an upload is currently in progress */
+  isUploading: boolean;
+  /** Current upload offset (bytes uploaded) */
+  offset: number;
+  /** Pause the current upload */
+  pause: () => void;
+  /** Current upload progress (0-100) */
+  progress: number;
+  /** Reset upload state */
+  reset: () => void;
+  /** Last upload result, if any */
+  result: UploadResult | undefined;
+  /** Resume a paused upload */
+  resume: () => Promise<void>;
+  /** Upload a file using chunked REST protocol */
+  upload: (file: File) => Promise<UploadResult>;
+}
+/**
+* React hook 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;
+  /** Callback when request fails */
+  onError?: (error: Error) => void;
+  /** Callback when request succeeds */
+  onSuccess?: () => void;
+}
+interface UseDeleteFileReturn {
+  /** Delete a file by ID */
+  deleteFile: (id: string) => Promise<void>;
+  /** Last request error, if any */
+  error: Error | undefined;
+  /** Whether a request is currently in progress */
+  isLoading: boolean;
+  /** Reset mutation state */
+  reset: () => void;
+}
+/**
+* React hook 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: File[];
+  /** Handle drag leave event */
+  handleDragLeave: (event: React.DragEvent<HTMLElement>) => void;
+  /** Handle drag and drop events */
+  handleDragOver: (event: React.DragEvent<HTMLElement>) => void;
+  /** Handle drop event */
+  handleDrop: (event: React.DragEvent<HTMLElement>) => void;
+  /** Handle file input change event */
+  handleFileChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
+  /** File input element ref */
+  inputRef: React.RefObject<HTMLInputElement | null>;
+  /** Open file dialog programmatically */
+  openFileDialog: () => void;
+  /** Reset selected files */
+  reset: () => void;
+}
+/**
+* React hook 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?: boolean;
+  /** Base endpoint URL for file operations */
+  endpoint: string;
+  /** File ID to fetch */
+  id: 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?: Record<string, string | number | boolean>;
+}
+interface UseGetFileReturn {
+  /** File data as Blob */
+  data: Blob | undefined;
+  /** Last request error, if any */
+  error: Error | undefined;
+  /** Whether a request is currently in progress */
+  isLoading: boolean;
+  /** File metadata from response headers */
+  meta: FileMeta | undefined;
+  /** Refetch the file */
+  refetch: () => void;
+}
+/**
+* React hook 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?: boolean;
+  /** Base endpoint URL for file operations */
+  endpoint: string;
+  /** Maximum number of elements to retrieve */
+  limit?: number;
+  /** Callback when request fails */
+  onError?: (error: Error) => void;
+  /** Callback when request succeeds */
+  onSuccess?: (data: FileListResponse) => void;
+  /** Page number for pagination */
+  page?: number;
+}
+interface UseGetFileListReturn {
+  /** File list data */
+  data: FileListResponse | undefined;
+  /** Last request error, if any */
+  error: Error | undefined;
+  /** Whether a request is currently in progress */
+  isLoading: boolean;
+  /** Refetch the file list */
+  refetch: () => void;
+}
+/**
+* React hook 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?: boolean;
+  /** Base endpoint URL for file operations */
+  endpoint: string;
+  /** File ID to fetch metadata for */
+  id: string;
+  /** Callback when request fails */
+  onError?: (error: Error) => void;
+  /** Callback when request succeeds */
+  onSuccess?: (meta: FileMeta) => void;
+}
+interface UseGetFileMetaReturn {
+  /** File metadata */
+  data: FileMeta | undefined;
+  /** Last request error, if any */
+  error: Error | undefined;
+  /** Whether a request is currently in progress */
+  isLoading: boolean;
+  /** Refetch the file metadata */
+  refetch: () => void;
+}
+/**
+* React hook 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?: boolean;
+  /** Base endpoint URL for file operations */
+  endpoint: string;
+  /** File ID to fetch metadata for */
+  id: string;
+  /** Callback when request fails */
+  onError?: (error: Error) => void;
+  /** Callback when request succeeds */
+  onSuccess?: (meta: FileHeadMetadata) => void;
+}
+interface UseHeadFileReturn {
+  /** File metadata from HEAD request */
+  data: FileHeadMetadata | undefined;
+  /** Last request error, if any */
+  error: Error | undefined;
+  /** Whether a request is currently in progress */
+  isLoading: boolean;
+  /** Refetch the file metadata */
+  refetch: () => void;
+}
+/**
+* React hook 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: Error | undefined;
+  /** Whether an upload is currently in progress */
+  isUploading: boolean;
+  /** Current upload progress (0-100) */
+  progress: number;
+  /** Reset upload state */
+  reset: () => void;
+  /** Last upload result, if any */
+  result: UploadResult | undefined;
+  /** Upload a file using multipart/form-data */
+  upload: (file: File) => Promise<UploadResult>;
+}
+/**
+* React hook for multipart/form-data file uploads using custom uploader implementation.
+* @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: React.ClipboardEvent<HTMLElement>) => void;
+  /** Files that were pasted */
+  pastedFiles: File[];
+  /** Reset pasted files */
+  reset: () => void;
+}
+/**
+* React hook 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;
+  /** Callback when request fails */
+  onError?: (error: Error) => void;
+  /** Callback when request succeeds */
+  onSuccess?: (result: UploadResult) => void;
+}
+interface UsePatchChunkReturn {
+  /** Last upload result, if any */
+  data: UploadResult | undefined;
+  /** Last request error, if any */
+  error: Error | undefined;
+  /** Whether a request is currently in progress */
+  isLoading: boolean;
+  /** Upload a chunk for chunked uploads */
+  patchChunk: (id: string, chunk: Blob, offset: number, checksum?: string) => Promise<UploadResult>;
+  /** Reset mutation state */
+  reset: () => void;
+}
+/**
+* React hook 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 request fails */
+  onError?: (error: Error) => void;
+  /** Callback when upload progress updates */
+  onProgress?: (progress: number) => void;
+  /** Callback when request succeeds */
+  onSuccess?: (result: UploadResult) => void;
+}
+interface UsePutFileReturn {
+  /** Last upload result, if any */
+  data: UploadResult | undefined;
+  /** Last request error, if any */
+  error: Error | undefined;
+  /** Whether a request is currently in progress */
+  isLoading: boolean;
+  /** Current upload progress (0-100) */
+  progress: number;
+  /** Create or update a file by ID */
+  putFile: (id: string, file: File | Blob) => Promise<UploadResult>;
+  /** Reset mutation state */
+  reset: () => void;
+}
+/**
+* React hook 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;
+}
+/**
+* React hook 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;
+}
+/**
+* React hook 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?: boolean;
+  /** Base endpoint URL for transform operations */
+  endpoint: string;
+  /** File ID to transform */
+  id: string;
+  /** Callback when request fails */
+  onError?: (error: Error) => void;
+  /** Callback when request succeeds */
+  onSuccess?: (data: Blob, meta: FileMeta | undefined) => void;
+  /** Transformation parameters */
+  transform: TransformOptions;
+}
+interface UseTransformFileReturn {
+  /** Transformed file data as Blob */
+  data: Blob | undefined;
+  /** Last request error, if any */
+  error: Error | undefined;
+  /** Whether a request is currently in progress */
+  isLoading: boolean;
+  /** File metadata from response headers */
+  meta: FileMeta | undefined;
+  /** Refetch the transformed file */
+  refetch: () => void;
+}
+/**
+* React hook 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?: boolean;
+  /** Base endpoint URL for transform operations */
+  endpoint: string;
+  /** Callback when request fails */
+  onError?: (error: Error) => void;
+  /** Callback when request succeeds */
+  onSuccess?: (metadata: TransformMetadata) => void;
+}
+interface UseTransformMetadataReturn {
+  /** Transform metadata */
+  data: TransformMetadata | undefined;
+  /** Last request error, if any */
+  error: Error | undefined;
+  /** Whether a request is currently in progress */
+  isLoading: boolean;
+  /** Refetch the transform metadata */
+  refetch: () => void;
+}
+/**
+* React hook 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: Error | undefined;
+  /** Whether the upload is paused */
+  isPaused: boolean;
+  /** Whether an upload is currently in progress */
+  isUploading: boolean;
+  /** Current upload offset (bytes uploaded) */
+  offset: number;
+  /** Pause the current upload */
+  pause: () => void;
+  /** Current upload progress (0-100) */
+  progress: number;
+  /** Reset upload state */
+  reset: () => void;
+  /** Last upload result, if any */
+  result: UploadResult | undefined;
+  /** Resume a paused upload */
+  resume: () => Promise<void>;
+  /** Upload a file using TUS protocol */
+  upload: (file: File) => Promise<UploadResult>;
+}
+/**
+* React hook 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: UploadMethod;
+  /** Last upload error, if any */
+  error: Error | undefined;
+  /** Whether the upload is paused (TUS and chunked REST only) */
+  isPaused?: boolean;
+  /** Whether an upload is currently in progress */
+  isUploading: boolean;
+  /** Current upload offset in bytes (TUS and chunked REST only) */
+  offset?: number;
+  /** Pause the current upload (TUS and chunked REST only) */
+  pause?: () => void;
+  /** Current upload progress (0-100) */
+  progress: number;
+  /** Reset upload state */
+  reset: () => void;
+  /** Last upload result, if any */
+  result: UploadResult | undefined;
+  /** Resume a paused upload (TUS and chunked REST only) */
+  resume?: () => Promise<void>;
+  /** Upload a file using the configured method */
+  upload: (file: File) => Promise<UploadResult>;
+}
+/**
+* React hook 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 UploadMethod, type UploadResult, 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 };