@visulima/storage-client 1.0.0-alpha.1

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

@@ -0,0 +1,43 @@
+import type { Accessor } from "solid-js";
+import type { UploadItem } from "../core/uploader.d.ts";
+import type { UploadResult } from "../react/types.d.ts";
+export interface CreateBatchUploadOptions {
+    /** 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;
+}
+export interface CreateBatchUploadReturn {
+    /** Abort a specific batch */
+    abortBatch: (batchId: string) => void;
+    /** Number of completed items in current batch */
+    completedCount: Accessor<number>;
+    /** Last batch error, if any */
+    error: Accessor<Error | undefined>;
+    /** Number of failed items in current batch */
+    errorCount: Accessor<number>;
+    /** Whether a batch is currently uploading */
+    isUploading: Accessor<boolean>;
+    /** All upload items in current batch */
+    items: Accessor<UploadItem[]>;
+    /** Current batch progress (0-100) */
+    progress: Accessor<number>;
+    /** Reset batch state */
+    reset: () => void;
+    /** Upload multiple files as a batch */
+    uploadBatch: (files: File[]) => string[];
+}
+/**
+ * Solid.js primitive for batch file uploads using multipart/form-data.
+ * @param options Upload configuration options
+ * @returns Batch upload functions and state signals
+ */
+export declare const createBatchUpload: (options: CreateBatchUploadOptions) => CreateBatchUploadReturn;

package/dist/solid/create-chunked-rest-upload.d.ts

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

package/dist/solid/create-delete-file.d.ts

@@ -0,0 +1,22 @@
+import type { Accessor } from "solid-js";
+export interface CreateDeleteFileOptions {
+    /** Base endpoint URL for file operations */
+    endpoint: string;
+}
+export interface CreateDeleteFileReturn {
+    /** Delete a file by ID */
+    deleteFile: (id: string) => Promise<void>;
+    /** 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 deleting a single file using TanStack Query.
+ * Automatically invalidates related queries.
+ * @param options Hook configuration options
+ * @returns File deletion functions and state signals
+ */
+export declare const createDeleteFile: (options: CreateDeleteFileOptions) => CreateDeleteFileReturn;

package/dist/solid/create-file-input.d.ts

@@ -0,0 +1,20 @@
+import type { Accessor } from "solid-js";
+export interface CreateFileInputOptions {
+    accept?: string;
+    multiple?: boolean;
+    onFilesSelected?: (files: File[]) => void;
+}
+export interface CreateFileInputReturn {
+    files: Accessor<File[]>;
+    handleDragLeave: (event: DragEvent) => void;
+    handleDragOver: (event: DragEvent) => void;
+    handleDrop: (event: DragEvent) => void;
+    handleFileChange: (event: Event) => void;
+    inputRef: {
+        current: HTMLInputElement | undefined;
+    };
+    isDragging: Accessor<boolean>;
+    openFileDialog: () => void;
+    reset: () => void;
+}
+export declare const createFileInput: (options?: CreateFileInputOptions) => CreateFileInputReturn;

package/dist/solid/create-get-file-list.d.ts

@@ -0,0 +1,46 @@
+import type { QueryClient } from "@tanstack/solid-query";
+import type { Accessor } from "solid-js";
+import type { FileMeta } from "../react/types.d.ts";
+export interface FileListResponse {
+    data: FileMeta[];
+    meta?: {
+        firstPage?: number;
+        firstPageUrl?: string;
+        lastPage?: number;
+        lastPageUrl?: string;
+        nextPageUrl?: string | undefined;
+        page?: number;
+        perPage?: number;
+        previousPageUrl?: string | undefined;
+        total?: number;
+    };
+}
+export interface CreateGetFileListOptions {
+    /** Whether to enable the query */
+    enabled?: Accessor<boolean> | boolean;
+    /** Base endpoint URL for file operations */
+    endpoint: string;
+    /** Maximum number of elements to retrieve */
+    limit?: Accessor<number> | number;
+    /** Page number for pagination */
+    page?: Accessor<number> | number;
+    /** Optional QueryClient to use */
+    queryClient?: QueryClient;
+}
+export interface CreateGetFileListReturn {
+    /** File list data */
+    data: Accessor<FileListResponse | undefined>;
+    /** Last request error, if any */
+    error: Accessor<Error | undefined>;
+    /** Whether a request is currently in progress */
+    isLoading: Accessor<boolean>;
+    /** Refetch the file list */
+    refetch: () => void;
+}
+/**
+ * Solid.js primitive 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 signals
+ */
+export declare const createGetFileList: (options: CreateGetFileListOptions) => CreateGetFileListReturn;

package/dist/solid/create-get-file-meta.d.ts

@@ -0,0 +1,29 @@
+import type { QueryClient } from "@tanstack/solid-query";
+import type { Accessor } from "solid-js";
+import type { FileMeta } from "../react/types.d.ts";
+export interface CreateGetFileMetaOptions {
+    /** Whether to enable the query */
+    enabled?: Accessor<boolean> | boolean;
+    /** Base endpoint URL for file operations */
+    endpoint: string;
+    /** File ID to fetch metadata for */
+    id: Accessor<string> | string;
+    /** Optional QueryClient to use */
+    queryClient?: QueryClient;
+}
+export interface CreateGetFileMetaReturn {
+    /** File metadata */
+    data: Accessor<FileMeta | undefined>;
+    /** Last request error, if any */
+    error: Accessor<Error | undefined>;
+    /** Whether a request is currently in progress */
+    isLoading: Accessor<boolean>;
+    /** Refetch the file metadata */
+    refetch: () => void;
+}
+/**
+ * Solid.js primitive for fetching file metadata using TanStack Query.
+ * @param options Hook configuration options
+ * @returns File metadata fetching functions and state signals
+ */
+export declare const createGetFileMeta: (options: CreateGetFileMetaOptions) => CreateGetFileMetaReturn;

package/dist/solid/create-get-file.d.ts

@@ -0,0 +1,38 @@
+import type { QueryClient } from "@tanstack/solid-query";
+import type { Accessor } from "solid-js";
+import type { FileMeta } from "../react/types.d.ts";
+export interface CreateGetFileOptions {
+    /** Whether to enable the query */
+    enabled?: Accessor<boolean> | boolean;
+    /** Base endpoint URL for file operations */
+    endpoint: string;
+    /** File ID to fetch */
+    id: Accessor<string> | string;
+    /** Callback when request fails */
+    onError?: (error: Error) => void;
+    /** Callback when request succeeds */
+    onSuccess?: (data: Blob, meta: FileMeta | undefined) => void;
+    /** Optional QueryClient to use */
+    queryClient?: QueryClient;
+    /** Transformation parameters for media files */
+    transform?: Accessor<Record<string, string | number | boolean> | undefined> | Record<string, string | number | boolean>;
+}
+export interface CreateGetFileReturn {
+    /** File data as Blob */
+    data: Accessor<Blob | undefined>;
+    /** Last request error, if any */
+    error: Accessor<Error | undefined>;
+    /** Whether a request is currently in progress */
+    isLoading: Accessor<boolean>;
+    /** File metadata from response headers */
+    meta: Accessor<FileMeta | undefined>;
+    /** Refetch the file */
+    refetch: () => void;
+}
+/**
+ * Solid.js primitive 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 signals
+ */
+export declare const createGetFile: (options: CreateGetFileOptions) => CreateGetFileReturn;

package/dist/solid/create-head-file.d.ts

@@ -0,0 +1,46 @@
+import type { Accessor } from "solid-js";
+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 CreateHeadFileOptions {
+    /** Whether to enable the query */
+    enabled?: Accessor<boolean> | boolean;
+    /** Base endpoint URL for file operations */
+    endpoint: string;
+    /** File ID to fetch metadata for */
+    id: Accessor<string> | string;
+}
+export interface CreateHeadFileReturn {
+    /** File metadata from HEAD request */
+    data: Accessor<FileHeadMetadata | undefined>;
+    /** Last request error, if any */
+    error: Accessor<Error | undefined>;
+    /** Whether a request is currently in progress */
+    isLoading: Accessor<boolean>;
+    /** Refetch the file metadata */
+    refetch: () => void;
+}
+/**
+ * Solid.js primitive 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 signals
+ */
+export declare const createHeadFile: (options: CreateHeadFileOptions) => CreateHeadFileReturn;

package/dist/solid/create-multipart-upload.d.ts

@@ -0,0 +1,36 @@
+import type { Accessor } from "solid-js";
+import type { UploadResult } from "../react/types.d.ts";
+export interface CreateMultipartUploadOptions {
+    /** 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 CreateMultipartUploadReturn {
+    /** Last upload error, if any */
+    error: Accessor<Error | undefined>;
+    /** Whether an upload is currently in progress */
+    isUploading: Accessor<boolean>;
+    /** Current upload progress (0-100) */
+    progress: Accessor<number>;
+    /** Reset upload state */
+    reset: () => void;
+    /** Last upload result, if any */
+    result: Accessor<UploadResult | undefined>;
+    /** Upload a file using multipart/form-data */
+    upload: (file: File) => Promise<UploadResult>;
+}
+/**
+ * Solid.js primitive for multipart/form-data file uploads using rpldy uploader core.
+ * @param options Upload configuration options
+ * @returns Upload functions and state signals
+ */
+export declare const createMultipartUpload: (options: CreateMultipartUploadOptions) => CreateMultipartUploadReturn;

package/dist/solid/create-paste-upload.d.ts

@@ -0,0 +1,11 @@
+import type { Accessor } from "solid-js";
+export interface CreatePasteUploadOptions {
+    filter?: (file: File) => boolean;
+    onFilesPasted?: (files: File[]) => void;
+}
+export interface CreatePasteUploadReturn {
+    handlePaste: (event: ClipboardEvent) => void;
+    pastedFiles: Accessor<File[]>;
+    reset: () => void;
+}
+export declare const createPasteUpload: (options?: CreatePasteUploadOptions) => CreatePasteUploadReturn;

package/dist/solid/create-patch-chunk.d.ts

@@ -0,0 +1,26 @@
+import type { Accessor } from "solid-js";
+import type { UploadResult } from "../react/types.d.ts";
+export interface CreatePatchChunkOptions {
+    /** Base endpoint URL for file operations */
+    endpoint: string;
+}
+export interface CreatePatchChunkReturn {
+    /** Last upload result, if any */
+    data: Accessor<UploadResult | undefined>;
+    /** Last request error, if any */
+    error: Accessor<Error | undefined>;
+    /** Whether a request is currently in progress */
+    isLoading: Accessor<boolean>;
+    /** Upload a chunk for chunked uploads */
+    patchChunk: (id: string, chunk: Blob, offset: number, checksum?: string) => Promise<UploadResult>;
+    /** Reset mutation state */
+    reset: () => void;
+}
+/**
+ * Solid.js primitive 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 signals
+ */
+export declare const createPatchChunk: (options: CreatePatchChunkOptions) => CreatePatchChunkReturn;

package/dist/solid/create-put-file.d.ts

@@ -0,0 +1,29 @@
+import type { Accessor } from "solid-js";
+import type { UploadResult } from "../react/types.d.ts";
+export interface CreatePutFileOptions {
+    /** Base endpoint URL for file operations */
+    endpoint: string;
+    /** Callback when upload progress updates */
+    onProgress?: (progress: number) => void;
+}
+export interface CreatePutFileReturn {
+    /** Last upload result, if any */
+    data: Accessor<UploadResult | undefined>;
+    /** Last request error, if any */
+    error: Accessor<Error | undefined>;
+    /** Whether a request is currently in progress */
+    isLoading: Accessor<boolean>;
+    /** Current upload progress (0-100) */
+    progress: Accessor<number>;
+    /** Create or update a file by ID */
+    putFile: (id: string, file: File | Blob) => Promise<UploadResult>;
+    /** Reset mutation state */
+    reset: () => void;
+}
+/**
+ * Solid.js primitive 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 signals
+ */
+export declare const createPutFile: (options: CreatePutFileOptions) => CreatePutFileReturn;

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

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

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

@@ -0,0 +1,8 @@
+export interface CreateRetryOptions {
+    endpoint: string;
+    metadata?: Record<string, string>;
+}
+export interface CreateRetryReturn {
+    retryItem: (id: string) => void;
+}
+export declare const createRetry: (options: CreateRetryOptions) => CreateRetryReturn;

package/dist/solid/create-transform-file.d.ts

@@ -0,0 +1,45 @@
+import type { Accessor } from "solid-js";
+import type { FileMeta } from "../react/types.d.ts";
+export interface TransformOptions {
+    /** Additional transformation parameters */
+    [key: string]: string | number | boolean | undefined;
+    /** Resize fit mode */
+    fit?: "cover" | "contain" | "fill" | "inside" | "outside";
+    /** Output format (jpeg, png, webp, etc.) */
+    format?: string;
+    /** Desired height in pixels */
+    height?: number;
+    /** Quality setting (0-100) */
+    quality?: number;
+    /** Desired width in pixels */
+    width?: number;
+}
+export interface CreateTransformFileOptions {
+    /** Whether to enable the query */
+    enabled?: Accessor<boolean> | boolean;
+    /** Base endpoint URL for transform operations */
+    endpoint: string;
+    /** File ID to transform */
+    id: Accessor<string> | string;
+    /** Transformation parameters */
+    transform: Accessor<TransformOptions> | TransformOptions;
+}
+export interface CreateTransformFileReturn {
+    /** Transformed file data as Blob */
+    data: Accessor<Blob | undefined>;
+    /** Last request error, if any */
+    error: Accessor<Error | undefined>;
+    /** Whether a request is currently in progress */
+    isLoading: Accessor<boolean>;
+    /** File metadata from response headers */
+    meta: Accessor<FileMeta | undefined>;
+    /** Refetch the transformed file */
+    refetch: () => void;
+}
+/**
+ * Solid.js primitive 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 signals
+ */
+export declare const createTransformFile: (options: CreateTransformFileOptions) => CreateTransformFileReturn;

package/dist/solid/create-transform-metadata.d.ts

@@ -0,0 +1,30 @@
+import type { Accessor } from "solid-js";
+export interface TransformMetadata {
+    /** Available transformation formats */
+    formats?: string[];
+    /** Supported transformation parameters */
+    parameters?: string[];
+}
+export interface CreateTransformMetadataOptions {
+    /** Whether to enable the query */
+    enabled?: Accessor<boolean> | boolean;
+    /** Base endpoint URL for transform operations */
+    endpoint: string;
+}
+export interface CreateTransformMetadataReturn {
+    /** Transform metadata */
+    data: Accessor<TransformMetadata | undefined>;
+    /** Last request error, if any */
+    error: Accessor<Error | undefined>;
+    /** Whether a request is currently in progress */
+    isLoading: Accessor<boolean>;
+    /** Refetch the transform metadata */
+    refetch: () => void;
+}
+/**
+ * Solid.js primitive 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 signals
+ */
+export declare const createTransformMetadata: (options: CreateTransformMetadataOptions) => CreateTransformMetadataReturn;

package/dist/solid/create-tus-upload.d.ts

@@ -0,0 +1,56 @@
+import type { Accessor } from "solid-js";
+import type { UploadResult } from "../react/types.d.ts";
+export interface CreateTusUploadOptions {
+    /** 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 CreateTusUploadReturn {
+    /** Abort the current upload */
+    abort: () => void;
+    /** Last upload error, if any */
+    error: Accessor<Error | undefined>;
+    /** Whether the upload is paused */
+    isPaused: Accessor<boolean>;
+    /** Whether an upload is currently in progress */
+    isUploading: Accessor<boolean>;
+    /** Current upload offset (bytes uploaded) */
+    offset: Accessor<number>;
+    /** Pause the current upload */
+    pause: () => void;
+    /** Current upload progress (0-100) */
+    progress: Accessor<number>;
+    /** Reset upload state */
+    reset: () => void;
+    /** Last upload result, if any */
+    result: Accessor<UploadResult | undefined>;
+    /** Resume a paused upload */
+    resume: () => Promise<void>;
+    /** Upload a file using TUS protocol */
+    upload: (file: File) => Promise<UploadResult>;
+}
+/**
+ * Solid.js primitive for TUS resumable file uploads.
+ * @param options Upload configuration options
+ * @returns Upload functions and state signals
+ */
+export declare const createTusUpload: (options: CreateTusUploadOptions) => CreateTusUploadReturn;

package/dist/solid/create-upload.d.ts

@@ -0,0 +1,70 @@
+import type { Accessor } from "solid-js";
+import type { UploadMethod, UploadResult } from "../react/types.d.ts";
+interface CreateUploadOptions {
+    /** 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 CreateUploadReturn {
+    /** Abort the current upload */
+    abort: () => void;
+    /** Current upload method being used */
+    currentMethod: Accessor<UploadMethod>;
+    /** Last upload error, if any */
+    error: Accessor<Error | undefined>;
+    /** Whether the upload is paused (TUS and chunked REST only) */
+    isPaused: Accessor<boolean | undefined>;
+    /** Whether an upload is currently in progress */
+    isUploading: Accessor<boolean>;
+    /** Current upload offset in bytes (TUS and chunked REST only) */
+    offset: Accessor<number | undefined>;
+    /** Pause the current upload (TUS and chunked REST only) */
+    pause: Accessor<(() => void) | undefined>;
+    /** Current upload progress (0-100) */
+    progress: Accessor<number>;
+    /** Reset upload state */
+    reset: () => void;
+    /** Last upload result, if any */
+    result: Accessor<UploadResult | undefined>;
+    /** Resume a paused upload (TUS and chunked REST only) */
+    resume: Accessor<(() => Promise<void>) | undefined>;
+    /** Upload a file using the configured method */
+    upload: (file: File) => Promise<UploadResult>;
+}
+/**
+ * Solid.js primitive 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 signals
+ */
+declare const createUpload: (options: CreateUploadOptions) => CreateUploadReturn;
+export type { CreateUploadOptions, CreateUploadReturn };
+export { createUpload };