@visulima/storage-client 1.0.0-alpha.1

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

@@ -0,0 +1,46 @@
+import type { FileMeta } from "./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?: 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;
+}
+export 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
+ */
+export declare const useGetFileList: (options: UseGetFileListOptions) => UseGetFileListReturn;

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

@@ -0,0 +1,29 @@
+import type { FileMeta } from "./types.d.ts";
+export 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;
+}
+export 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
+ */
+export declare const useGetFileMeta: (options: UseGetFileMetaOptions) => UseGetFileMetaReturn;

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

@@ -0,0 +1,34 @@
+import type { FileMeta } from "./types.d.ts";
+export 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>;
+}
+export 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.
+ */
+export declare const useGetFile: (options: UseGetFileOptions) => UseGetFileReturn;

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

@@ -0,0 +1,49 @@
+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?: 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;
+}
+export 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
+ */
+export declare const useHeadFile: (options: UseHeadFileOptions) => UseHeadFileReturn;

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

@@ -0,0 +1,35 @@
+import type { UploadResult } from "./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: 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
+ */
+export declare const useMultipartUpload: (options: UseMultipartUploadOptions) => UseMultipartUploadReturn;

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

@@ -0,0 +1,20 @@
+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: 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
+ */
+export declare const usePasteUpload: (options?: UsePasteUploadOptions) => UsePasteUploadReturn;

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

@@ -0,0 +1,29 @@
+import type { UploadResult } from "./types.d.ts";
+export 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;
+}
+export 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
+ */
+export declare const usePatchChunk: (options: UsePatchChunkOptions) => UsePatchChunkReturn;

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

@@ -0,0 +1,32 @@
+import type { UploadResult } from "./types.d.ts";
+export 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;
+}
+export 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
+ */
+export declare const usePutFile: (options: UsePutFileOptions) => UsePutFileReturn;

package/dist/react/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;
+}
+/**
+ * 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
+ */
+export declare const useRetryListener: (options: UseRetryListenerOptions) => void;

package/dist/react/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;
+}
+/**
+ * React hook to retry a failed upload item.
+ * @param options Configuration options
+ * @returns Retry function
+ */
+export declare const useRetry: (options: UseRetryOptions) => UseRetryReturn;

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

@@ -0,0 +1,48 @@
+import type { FileMeta } from "./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?: 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;
+}
+export 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
+ */
+export declare const useTransformFile: (options: UseTransformFileOptions) => UseTransformFileReturn;

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

@@ -0,0 +1,33 @@
+export interface TransformMetadata {
+    /** Available transformation formats */
+    formats?: string[];
+    /** Supported transformation parameters */
+    parameters?: string[];
+}
+export 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;
+}
+export 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
+ */
+export declare const useTransformMetadata: (options: UseTransformMetadataOptions) => UseTransformMetadataReturn;

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

@@ -0,0 +1,55 @@
+import type { UploadResult } from "./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: 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
+ */
+export declare const useTusUpload: (options: UseTusUploadOptions) => UseTusUploadReturn;

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

@@ -0,0 +1,69 @@
+import type { UploadMethod, UploadResult } from "./types.d.ts";
+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 { UseUploadOptions, UseUploadReturn };
+export { useUpload };

package/dist/solid/create-abort-all.d.ts

@@ -0,0 +1,8 @@
+export interface CreateAbortAllOptions {
+    endpoint: string;
+    metadata?: Record<string, string>;
+}
+export interface CreateAbortAllReturn {
+    abortAll: () => void;
+}
+export declare const createAbortAll: (options: CreateAbortAllOptions) => CreateAbortAllReturn;

package/dist/solid/create-abort-batch.d.ts

@@ -0,0 +1,8 @@
+export interface CreateAbortBatchOptions {
+    endpoint: string;
+    metadata?: Record<string, string>;
+}
+export interface CreateAbortBatchReturn {
+    abortBatch: (batchId: string) => void;
+}
+export declare const createAbortBatch: (options: CreateAbortBatchOptions) => CreateAbortBatchReturn;

package/dist/solid/create-abort-item.d.ts

@@ -0,0 +1,8 @@
+export interface CreateAbortItemOptions {
+    endpoint: string;
+    metadata?: Record<string, string>;
+}
+export interface CreateAbortItemReturn {
+    abortItem: (id: string) => void;
+}
+export declare const createAbortItem: (options: CreateAbortItemOptions) => CreateAbortItemReturn;

package/dist/solid/create-all-abort-listener.d.ts

@@ -0,0 +1,7 @@
+import type { UploadItem } from "../core/uploader.d.ts";
+export interface CreateAllAbortListenerOptions {
+    endpoint: string;
+    metadata?: Record<string, string>;
+    onAbort: (item: UploadItem) => void;
+}
+export declare const createAllAbortListener: (options: CreateAllAbortListenerOptions) => void;

package/dist/solid/create-batch-cancelled-listener.d.ts

@@ -0,0 +1,7 @@
+import type { BatchState } from "../core/uploader.d.ts";
+export interface CreateBatchCancelledListenerOptions {
+    endpoint: string;
+    metadata?: Record<string, string>;
+    onBatchCancelled: (batch: BatchState) => void;
+}
+export declare const createBatchCancelledListener: (options: CreateBatchCancelledListenerOptions) => void;

package/dist/solid/create-batch-delete-files.d.ts

@@ -0,0 +1,29 @@
+import type { Accessor } from "solid-js";
+export interface BatchDeleteResult {
+    /** Number of files that failed to delete */
+    failed?: number;
+    /** Number of files successfully deleted */
+    successful?: number;
+}
+export interface CreateBatchDeleteFilesOptions {
+    /** Base endpoint URL for file operations */
+    endpoint: string;
+}
+export interface CreateBatchDeleteFilesReturn {
+    /** Delete multiple files by IDs */
+    batchDeleteFiles: (ids: string[]) => Promise<BatchDeleteResult>;
+    /** Last request error, if any */
+    error: Accessor<Error | undefined>;
+    /** Whether a request is currently in progress */
+    isLoading: Accessor<boolean>;
+    /** Reset mutation state */
+    reset: () => void;
+}
+/**
+ * Solid.js primitive 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 signals
+ */
+export declare const createBatchDeleteFiles: (options: CreateBatchDeleteFilesOptions) => CreateBatchDeleteFilesReturn;

package/dist/solid/create-batch-error-listener.d.ts

@@ -0,0 +1,7 @@
+import type { BatchState } from "../core/uploader.d.ts";
+export interface CreateBatchErrorListenerOptions {
+    endpoint: string;
+    metadata?: Record<string, string>;
+    onBatchError: (batch: BatchState) => void;
+}
+export declare const createBatchErrorListener: (options: CreateBatchErrorListenerOptions) => void;

package/dist/solid/create-batch-finalize-listener.d.ts

@@ -0,0 +1,7 @@
+import type { BatchState } from "../core/uploader.d.ts";
+export interface CreateBatchFinalizeListenerOptions {
+    endpoint: string;
+    metadata?: Record<string, string>;
+    onBatchFinalize: (batch: BatchState) => void;
+}
+export declare const createBatchFinalizeListener: (options: CreateBatchFinalizeListenerOptions) => void;

package/dist/solid/create-batch-finish-listener.d.ts

@@ -0,0 +1,7 @@
+import type { BatchState } from "../core/uploader.d.ts";
+export interface CreateBatchFinishListenerOptions {
+    endpoint: string;
+    metadata?: Record<string, string>;
+    onBatchFinish: (batch: BatchState) => void;
+}
+export declare const createBatchFinishListener: (options: CreateBatchFinishListenerOptions) => void;

package/dist/solid/create-batch-progress-listener.d.ts

@@ -0,0 +1,7 @@
+import type { BatchState } from "../core/uploader.d.ts";
+export interface CreateBatchProgressListenerOptions {
+    endpoint: string;
+    metadata?: Record<string, string>;
+    onBatchProgress: (batch: BatchState) => void;
+}
+export declare const createBatchProgressListener: (options: CreateBatchProgressListenerOptions) => void;

package/dist/solid/create-batch-retry.d.ts

@@ -0,0 +1,8 @@
+export interface CreateBatchRetryOptions {
+    endpoint: string;
+    metadata?: Record<string, string>;
+}
+export interface CreateBatchRetryReturn {
+    retryBatch: (batchId: string) => void;
+}
+export declare const createBatchRetry: (options: CreateBatchRetryOptions) => CreateBatchRetryReturn;

package/dist/solid/create-batch-start-listener.d.ts

@@ -0,0 +1,7 @@
+import type { BatchState } from "../core/uploader.d.ts";
+export interface CreateBatchStartListenerOptions {
+    endpoint: string;
+    metadata?: Record<string, string>;
+    onBatchStart: (batch: BatchState) => void;
+}
+export declare const createBatchStartListener: (options: CreateBatchStartListenerOptions) => void;