@visulima/storage-client 1.0.0-alpha.1

package/dist/solid/index.d.ts

@@ -0,0 +1,60 @@
+export type { CreateAbortAllOptions, CreateAbortAllReturn } from "./create-abort-all.d.ts";
+export { createAbortAll } from "./create-abort-all.d.ts";
+export type { CreateAbortBatchOptions, CreateAbortBatchReturn } from "./create-abort-batch.d.ts";
+export { createAbortBatch } from "./create-abort-batch.d.ts";
+export type { CreateAbortItemOptions, CreateAbortItemReturn } from "./create-abort-item.d.ts";
+export { createAbortItem } from "./create-abort-item.d.ts";
+export type { CreateAllAbortListenerOptions } from "./create-all-abort-listener.d.ts";
+export { createAllAbortListener } from "./create-all-abort-listener.d.ts";
+export type { CreateBatchCancelledListenerOptions } from "./create-batch-cancelled-listener.d.ts";
+export { createBatchCancelledListener } from "./create-batch-cancelled-listener.d.ts";
+export type { BatchDeleteResult, CreateBatchDeleteFilesOptions, CreateBatchDeleteFilesReturn } from "./create-batch-delete-files.d.ts";
+export { createBatchDeleteFiles } from "./create-batch-delete-files.d.ts";
+export type { CreateBatchErrorListenerOptions } from "./create-batch-error-listener.d.ts";
+export { createBatchErrorListener } from "./create-batch-error-listener.d.ts";
+export type { CreateBatchFinalizeListenerOptions } from "./create-batch-finalize-listener.d.ts";
+export { createBatchFinalizeListener } from "./create-batch-finalize-listener.d.ts";
+export type { CreateBatchFinishListenerOptions } from "./create-batch-finish-listener.d.ts";
+export { createBatchFinishListener } from "./create-batch-finish-listener.d.ts";
+export type { CreateBatchProgressListenerOptions } from "./create-batch-progress-listener.d.ts";
+export { createBatchProgressListener } from "./create-batch-progress-listener.d.ts";
+export type { CreateBatchRetryOptions, CreateBatchRetryReturn } from "./create-batch-retry.d.ts";
+export { createBatchRetry } from "./create-batch-retry.d.ts";
+export type { CreateBatchStartListenerOptions } from "./create-batch-start-listener.d.ts";
+export { createBatchStartListener } from "./create-batch-start-listener.d.ts";
+export type { CreateBatchUploadOptions, CreateBatchUploadReturn } from "./create-batch-upload.d.ts";
+export { createBatchUpload } from "./create-batch-upload.d.ts";
+export type { CreateChunkedRestUploadOptions, CreateChunkedRestUploadReturn } from "./create-chunked-rest-upload.d.ts";
+export { createChunkedRestUpload } from "./create-chunked-rest-upload.d.ts";
+export type { CreateDeleteFileOptions, CreateDeleteFileReturn } from "./create-delete-file.d.ts";
+export { createDeleteFile } from "./create-delete-file.d.ts";
+export type { CreateFileInputOptions, CreateFileInputReturn } from "./create-file-input.d.ts";
+export { createFileInput } from "./create-file-input.d.ts";
+export type { CreateGetFileOptions, CreateGetFileReturn } from "./create-get-file.d.ts";
+export { createGetFile } from "./create-get-file.d.ts";
+export type { CreateGetFileListOptions, CreateGetFileListReturn, FileListResponse } from "./create-get-file-list.d.ts";
+export { createGetFileList } from "./create-get-file-list.d.ts";
+export type { CreateGetFileMetaOptions, CreateGetFileMetaReturn } from "./create-get-file-meta.d.ts";
+export { createGetFileMeta } from "./create-get-file-meta.d.ts";
+export type { CreateHeadFileOptions, CreateHeadFileReturn, FileHeadMetadata } from "./create-head-file.d.ts";
+export { createHeadFile } from "./create-head-file.d.ts";
+export type { CreateMultipartUploadOptions, CreateMultipartUploadReturn } from "./create-multipart-upload.d.ts";
+export { createMultipartUpload } from "./create-multipart-upload.d.ts";
+export type { CreatePasteUploadOptions, CreatePasteUploadReturn } from "./create-paste-upload.d.ts";
+export { createPasteUpload } from "./create-paste-upload.d.ts";
+export type { CreatePatchChunkOptions, CreatePatchChunkReturn } from "./create-patch-chunk.d.ts";
+export { createPatchChunk } from "./create-patch-chunk.d.ts";
+export type { CreatePutFileOptions, CreatePutFileReturn } from "./create-put-file.d.ts";
+export { createPutFile } from "./create-put-file.d.ts";
+export type { CreateRetryOptions, CreateRetryReturn } from "./create-retry.d.ts";
+export { createRetry } from "./create-retry.d.ts";
+export type { CreateRetryListenerOptions } from "./create-retry-listener.d.ts";
+export { createRetryListener } from "./create-retry-listener.d.ts";
+export type { CreateTransformFileOptions, CreateTransformFileReturn, TransformOptions } from "./create-transform-file.d.ts";
+export { createTransformFile } from "./create-transform-file.d.ts";
+export type { CreateTransformMetadataOptions, CreateTransformMetadataReturn, TransformMetadata } from "./create-transform-metadata.d.ts";
+export { createTransformMetadata } from "./create-transform-metadata.d.ts";
+export type { CreateTusUploadOptions, CreateTusUploadReturn } from "./create-tus-upload.d.ts";
+export { createTusUpload } from "./create-tus-upload.d.ts";
+export type { CreateUploadOptions, CreateUploadReturn } from "./create-upload.d.ts";
+export { createUpload } from "./create-upload.d.ts";

package/dist/solid/index.js

@@ -0,0 +1 @@
+import{createAbortAll as t}from"../packem_shared/createAbortAll-B5vFFliA.js";import{createAbortBatch as a}from"../packem_shared/createAbortBatch-zA0PTnOB.js";import{createAbortItem as p}from"../packem_shared/createAbortItem-CIRlRD4X.js";import{createAllAbortListener as f}from"../packem_shared/createAllAbortListener-CYLEWan0.js";import{createBatchCancelledListener as l}from"../packem_shared/createBatchCancelledListener-l9c0mi15.js";import{createBatchDeleteFiles as s}from"../packem_shared/createBatchDeleteFiles-B0SYSdYj.js";import{createBatchErrorListener as h}from"../packem_shared/createBatchErrorListener-CJQFdXW2.js";import{createBatchFinalizeListener as d}from"../packem_shared/createBatchFinalizeListener-Og0rELSL.js";import{createBatchFinishListener as L}from"../packem_shared/createBatchFinishListener-BeE6-b6E.js";import{createBatchProgressListener as A}from"../packem_shared/createBatchProgressListener-1KpCpw7e.js";import{createBatchRetry as b}from"../packem_shared/createBatchRetry-D_F4v9oA.js";import{createBatchStartListener as R}from"../packem_shared/createBatchStartListener-CkcMX3tq.js";import{createBatchUpload as C}from"../packem_shared/createBatchUpload-DWcVWF9h.js";import{createChunkedRestUpload as M}from"../packem_shared/createChunkedRestUpload-CJNQp68Z.js";import{createDeleteFile as k}from"../packem_shared/createDeleteFile-_Znrnika.js";import{createFileInput as I}from"../packem_shared/createFileInput-B7WPz_-r.js";import{createGetFile as z}from"../packem_shared/createGetFile-CY2ohQF-.js";import{createGetFileList as H}from"../packem_shared/createGetFileList-DGZQymc5.js";import{createGetFileMeta as j}from"../packem_shared/createGetFileMeta-50LymNvf.js";import{createHeadFile as v}from"../packem_shared/createHeadFile-CGD6bHDS.js";import{createMultipartUpload as J}from"../packem_shared/createMultipartUpload-CTats5BN.js";import{createPasteUpload as N}from"../packem_shared/createPasteUpload-DemCREgp.js";import{createPatchChunk as Q}from"../packem_shared/createPatchChunk-Zy6I60LN.js";import{createPutFile as W}from"../packem_shared/createPutFile-D8hN-9Ai.js";import{createRetry as Y}from"../packem_shared/createRetry-DPaN9i_a.js";import{createRetryListener as _}from"../packem_shared/createRetryListener-bMqMm13Y.js";import{createTransformFile as ee}from"../packem_shared/createTransformFile-CJXLJEfg.js";import{createTransformMetadata as te}from"../packem_shared/createTransformMetadata-zyl5UymO.js";import{createTusUpload as ae}from"../packem_shared/createTusUpload-ClmXqmcz.js";import{createUpload as pe}from"../packem_shared/createUpload-LRQ4N_cF.js";export{t as createAbortAll,a as createAbortBatch,p as createAbortItem,f as createAllAbortListener,l as createBatchCancelledListener,s as createBatchDeleteFiles,h as createBatchErrorListener,d as createBatchFinalizeListener,L as createBatchFinishListener,A as createBatchProgressListener,b as createBatchRetry,R as createBatchStartListener,C as createBatchUpload,M as createChunkedRestUpload,k as createDeleteFile,I as createFileInput,z as createGetFile,H as createGetFileList,j as createGetFileMeta,v as createHeadFile,J as createMultipartUpload,N as createPasteUpload,Q as createPatchChunk,W as createPutFile,Y as createRetry,_ as createRetryListener,ee as createTransformFile,te as createTransformMetadata,ae as createTusUpload,pe as createUpload};

package/dist/svelte/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/svelte/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/svelte/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/svelte/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/svelte/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/svelte/create-batch-delete-files.d.ts

@@ -0,0 +1,29 @@
+import type { Readable } from "svelte/store";
+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: Readable<Error | undefined>;
+    /** Whether a request is currently in progress */
+    isLoading: Readable<boolean>;
+    /** Reset mutation state */
+    reset: () => void;
+}
+/**
+ * Svelte store-based utility 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 stores
+ */
+export declare const createBatchDeleteFiles: (options: CreateBatchDeleteFilesOptions) => CreateBatchDeleteFilesReturn;

package/dist/svelte/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/svelte/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/svelte/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/svelte/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/svelte/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/svelte/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;

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

@@ -0,0 +1,23 @@
+import type { Readable } from "svelte/store";
+import type { UploadItem } from "../core/uploader.d.ts";
+import type { UploadResult } from "../react/types.d.ts";
+export interface CreateBatchUploadOptions {
+    endpoint: string;
+    metadata?: Record<string, string>;
+    onError?: (error: Error, batchId: string) => void;
+    onProgress?: (progress: number, batchId: string) => void;
+    onStart?: (batchId: string) => void;
+    onSuccess?: (results: UploadResult[], batchId: string) => void;
+}
+export interface CreateBatchUploadReturn {
+    abortBatch: (batchId: string) => void;
+    completedCount: Readable<number>;
+    error: Readable<Error | undefined>;
+    errorCount: Readable<number>;
+    isUploading: Readable<boolean>;
+    items: Readable<UploadItem[]>;
+    progress: Readable<number>;
+    reset: () => void;
+    uploadBatch: (files: File[]) => string[];
+}
+export declare const createBatchUpload: (options: CreateBatchUploadOptions) => CreateBatchUploadReturn;

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

@@ -0,0 +1,56 @@
+import type { Readable } from "svelte/store";
+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: Readable<Error | undefined>;
+    /** Whether the upload is paused */
+    isPaused: Readable<boolean>;
+    /** Whether an upload is currently in progress */
+    isUploading: Readable<boolean>;
+    /** Current upload offset (bytes uploaded) */
+    offset: Readable<number>;
+    /** Pause the current upload */
+    pause: () => void;
+    /** Current upload progress (0-100) */
+    progress: Readable<number>;
+    /** Reset upload state */
+    reset: () => void;
+    /** Last upload result, if any */
+    result: Readable<UploadResult | undefined>;
+    /** Resume a paused upload */
+    resume: () => Promise<void>;
+    /** Upload a file using chunked REST protocol */
+    upload: (file: File) => Promise<UploadResult>;
+}
+/**
+ * Svelte store-based utility for chunked REST file uploads.
+ * @param options Upload configuration options
+ * @returns Upload functions and state stores
+ */
+export declare const createChunkedRestUpload: (options: CreateChunkedRestUploadOptions) => CreateChunkedRestUploadReturn;

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

@@ -0,0 +1,26 @@
+import type { Readable } from "svelte/store";
+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: Readable<Error | undefined>;
+    /** Whether a request is currently in progress */
+    isLoading: Readable<boolean>;
+    /** Reset mutation state */
+    reset: () => void;
+}
+/**
+ * Svelte store-based utility for deleting a single file using TanStack Query.
+ * Automatically invalidates related queries.
+ *
+ * IMPORTANT: Due to TanStack Query Svelte requirements, createMutation must be called
+ * at the component's top level, not inside utility functions. For proper usage, call
+ * createMutation directly in your component and use the returned stores.
+ * @param options Hook configuration options
+ * @returns File deletion functions and state stores
+ */
+export declare const createDeleteFile: (options: CreateDeleteFileOptions) => CreateDeleteFileReturn;

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

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

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

@@ -0,0 +1,43 @@
+import type { Readable } from "svelte/store";
+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?: Readable<boolean> | boolean;
+    /** Base endpoint URL for file operations */
+    endpoint: string;
+    /** Maximum number of elements to retrieve */
+    limit?: Readable<number> | number;
+    /** Page number for pagination */
+    page?: Readable<number> | number;
+}
+export interface CreateGetFileListReturn {
+    /** File list data */
+    data: Readable<FileListResponse | undefined>;
+    /** Last request error, if any */
+    error: Readable<Error | undefined>;
+    /** Whether a request is currently in progress */
+    isLoading: Readable<boolean>;
+    /** Refetch the file list */
+    refetch: () => void;
+}
+/**
+ * Svelte store-based utility 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 stores
+ */
+export declare const createGetFileList: (options: CreateGetFileListOptions) => CreateGetFileListReturn;

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

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

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

@@ -0,0 +1,41 @@
+import type { Readable } from "svelte/store";
+import type { FileMeta } from "../react/types.d.ts";
+type TransformParams = Record<string, string | number | boolean> | undefined;
+export interface CreateGetFileOptions {
+    /** Whether to enable the query */
+    enabled?: Readable<boolean> | boolean;
+    /** Base endpoint URL for file operations */
+    endpoint: string;
+    /** File ID to fetch */
+    id: Readable<string> | 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?: Readable<TransformParams> | TransformParams;
+}
+export interface CreateGetFileReturn {
+    /** File data as Blob */
+    data: Readable<Blob | undefined>;
+    /** Last request error, if any */
+    error: Readable<Error | undefined>;
+    /** Whether a request is currently in progress */
+    isLoading: Readable<boolean>;
+    /** File metadata from response headers */
+    meta: Readable<FileMeta | undefined>;
+    /** Refetch the file */
+    refetch: () => void;
+}
+/**
+ * Svelte store-based utility for fetching/downloading files using TanStack Query.
+ * Supports optional transformation parameters for media files.
+ *
+ * IMPORTANT: Due to TanStack Query Svelte requirements, createQuery must be called
+ * at the component's top level, not inside utility functions. For proper usage, call
+ * createQuery directly in your component and use the returned stores.
+ * @param options Hook configuration options
+ * @returns File fetching functions and state stores
+ */
+export declare const createGetFile: (options: CreateGetFileOptions) => CreateGetFileReturn;
+export {};

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

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

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

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

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

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

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

@@ -0,0 +1,26 @@
+import type { Readable } from "svelte/store";
+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: Readable<UploadResult | undefined>;
+    /** Last request error, if any */
+    error: Readable<Error | undefined>;
+    /** Whether a request is currently in progress */
+    isLoading: Readable<boolean>;
+    /** Upload a chunk for chunked uploads */
+    patchChunk: (id: string, chunk: Blob, offset: number, checksum?: string) => Promise<UploadResult>;
+    /** Reset mutation state */
+    reset: () => void;
+}
+/**
+ * Svelte store-based utility 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 stores
+ */
+export declare const createPatchChunk: (options: CreatePatchChunkOptions) => CreatePatchChunkReturn;

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

@@ -0,0 +1,29 @@
+import type { Readable } from "svelte/store";
+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: Readable<UploadResult | undefined>;
+    /** Last request error, if any */
+    error: Readable<Error | undefined>;
+    /** Whether a request is currently in progress */
+    isLoading: Readable<boolean>;
+    /** Current upload progress (0-100) */
+    progress: Readable<number>;
+    /** Create or update a file by ID */
+    putFile: (id: string, file: File | Blob) => Promise<UploadResult>;
+    /** Reset mutation state */
+    reset: () => void;
+}
+/**
+ * Svelte store-based utility 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 stores
+ */
+export declare const createPutFile: (options: CreatePutFileOptions) => CreatePutFileReturn;

package/dist/svelte/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/svelte/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;