@useupup/core 3.3.0

package/dist/context-shapes-27b24c8f.d.ts

@@ -0,0 +1,207 @@
+import { a as UploadFile, c as UploadStatus, F as FileSource } from './contracts-pipeline-cf177270.js';
+import { F as FilesProgressMap, R as ResolvedImageEditorOptions, U as UpupCore, b as CloudDrivesConfig } from './core-141335ac.js';
+import { c as Translations, T as Translator } from './ui-translations-c5d00392.js';
+import { e as UpupThemeMode, d as UpupThemeTokens, I as InternalFlatClassNames, l as DeepPartialSlots, g as UpupResolvedTheme } from './vars-d3421f6c.js';
+
+interface UploadProgressInfo {
+    loaded: number;
+    total: number;
+    percentage: number;
+}
+interface OrchestratorState {
+    files: Map<string, UploadFile>;
+    uploadStatus: UploadStatus;
+    uploadError: string;
+    /** Machine code from a typed UpupError (e.g. 'SignatureDoesNotMatch', 'bad_signature'), when the failure carried one. */
+    uploadErrorCode?: string | undefined;
+    totalProgress: number;
+    filesProgressMap: FilesProgressMap;
+    uploadSpeed: number;
+    uploadEta: number;
+    uploadedBytes: number;
+    totalBytes: number;
+    activeSource?: FileSource | undefined;
+    editingFile: UploadFile | null;
+    editorQueue: UploadFile[];
+    isAddingMore: boolean;
+    viewMode: 'grid' | 'list';
+    isOnline: boolean;
+}
+interface OrchestratorCallbacks {
+    onError?: ((message: string) => void) | undefined;
+    onWarn?: ((message: string) => void) | undefined;
+    onUploadComplete?: ((files: UploadFile[]) => void) | undefined;
+    onUploadStart?: (() => void) | undefined;
+    onFileUploadStart?: ((file: UploadFile) => void) | undefined;
+    onFileUploadProgress?: ((file: UploadFile, progress: UploadProgressInfo) => void) | undefined;
+    onFileUploadComplete?: ((file: UploadFile, key: string) => void) | undefined;
+    onFilesUploadProgress?: ((completedFiles: number, totalFiles: number) => void) | undefined;
+    onFilesUploadComplete?: ((files: UploadFile[]) => void) | undefined;
+    onFileRemoved?: ((file: UploadFile) => void) | undefined;
+    onFilesSelected?: ((files: UploadFile[]) => void) | undefined;
+    onFileDrop?: ((files: File[]) => void) | undefined;
+    onDoneClicked?: (() => void) | undefined;
+    onPrepareFiles?: ((files: UploadFile[]) => Promise<UploadFile[] | File[]> | UploadFile[] | File[]) | undefined;
+    imageEditorOptions?: ResolvedImageEditorOptions | undefined;
+    /** When true, triggers upload automatically after files are added. */
+    autoUpload?: boolean | undefined;
+}
+
+declare class UploaderOrchestrator {
+    private state;
+    private listeners;
+    private core;
+    private callbacks;
+    private unsubs;
+    private disposed;
+    constructor(core: UpupCore, callbacks: OrchestratorCallbacks);
+    /** useSyncExternalStore-compatible subscribe (bound). */
+    subscribe: (listener: () => void) => (() => void);
+    /** useSyncExternalStore-compatible getSnapshot (bound). */
+    getSnapshot: () => OrchestratorState;
+    protected setState(partial: Partial<OrchestratorState>): void;
+    private notify;
+    /** Remove a file by id: revoke its blob URL, then delegate to core. */
+    removeFile(fileId: string): void;
+    /** Set the active upload source. */
+    setActiveSource(source: FileSource | undefined): void;
+    /** Toggle between grid and list view. */
+    setViewMode(mode: 'grid' | 'list'): void;
+    /** Toggle the "adding more files" state. */
+    setIsAddingMore(value: boolean): void;
+    /** Trigger upload for all current files. Calls onPrepareFiles if provided. */
+    startUpload(): Promise<UploadFile[] | undefined>;
+    /** Retry upload for a specific file or all failed files. */
+    retryUpload(fileId?: string): Promise<UploadFile[] | undefined>;
+    /** Cancel in-progress upload, revoke blob URLs, clear all files and progress. */
+    handleCancel(): void;
+    /** Pause in-progress upload. */
+    handlePause(): void;
+    /** Resume paused upload. */
+    handleResume(): void;
+    /** Mark upload as done: invoke callback, emit event, then cancel/clear. */
+    handleDone(): void;
+    /** Full state reset: clear isAddingMore, emit state-reset, then handleDone. */
+    resetState(): void;
+    /** Open the image editor for a given file. Invokes onOpen callback and emits event. */
+    openImageEditor(file: UploadFile): void;
+    /**
+     * Close the image editor without saving. Invokes onCancel callback.
+     * If the editor queue is non-empty, the next file is automatically opened.
+     */
+    closeImageEditor(): void;
+    /**
+     * Save an edited image. Converts the data URL to a blob, creates a new
+     * UploadFile preserving the original's identity, replaces it in state
+     * and core, then invokes the onSave callback.
+     */
+    saveImageEdit(editedImageData: string, mimeType?: string): void;
+    /** Replace a single file in state by id (revokes old blob URL). Also replaces in core. */
+    replaceFile(fileId: string, newFile: UploadFile): void;
+    /** Enqueue files for auto-opening in the image editor. */
+    enqueueForEditor(files: UploadFile[]): void;
+    /** Pop the next file from the editor queue and open it. */
+    private processEditorQueue;
+    private speedSamples;
+    /**
+     * Project orchestrator state from core — the single source of truth (F-145).
+     * `uploadStatus` is derived from the `status` each status-carrying `state-change`
+     * event supplies (core sets `_status` before every such emit); the discrete
+     * upload-start/upload-all-complete/upload-error listeners no longer write it. `files`
+     * is rebuilt from `core.files`, and is a no-op when the file set is unchanged (same
+     * size + ordered ids + same UploadFile refs) so the `files` reference stays stable
+     * across the many status-only `state-change` events core emits during upload —
+     * preserving referential stability for useSyncExternalStore / computed consumers.
+     */
+    private projectFromCore;
+    private filesProjectionChanged;
+    init(): void;
+    destroy(): void;
+}
+
+/**
+ * Base context shape types shared across the framework bindings.
+ *
+ * Each framework package defines its own concrete context types that extend
+ * these bases with framework-specific fields (e.g. React refs, Vue refs,
+ * Dispatch<SetStateAction<...>> vs plain setters).
+ *
+ * This file intentionally uses plain function signatures for state setters
+ * so both React (Dispatch<SetStateAction<T>>) and Vue ((v: T) => void) are
+ * compatible supertypes.
+ */
+
+type BaseContextUpload = {
+    uploadStatus: UploadStatus;
+    uploadError?: string | undefined;
+    /** Machine code from a typed UpupError, when the failure carried one. */
+    uploadErrorCode?: string | undefined;
+    totalProgress: number;
+    filesProgressMap: FilesProgressMap;
+    startUpload: () => Promise<UploadFile[] | undefined>;
+    retryUpload: (fileId?: string) => Promise<UploadFile[] | undefined>;
+    uploadSpeed: number;
+    uploadEta: number;
+    uploadedBytes: number;
+    totalBytes: number;
+};
+type BaseContextRuntime = {
+    core: UpupCore | null;
+    orchestrator: UploaderOrchestrator | null;
+    mode: 'client' | 'server';
+    serverUrl?: string | undefined;
+    openFilePicker: () => void;
+    isOnline: boolean;
+};
+type BaseContextSource = {
+    activeSource?: FileSource | undefined;
+    setActiveSource: (source: FileSource | undefined) => void;
+    cloudDrives?: CloudDrivesConfig | undefined;
+};
+type BaseContextI18n = {
+    translations: Translations;
+    translator?: Translator | undefined;
+    lang: string;
+    dir: 'ltr' | 'rtl';
+};
+type BaseContextFiles = {
+    files: Map<string, UploadFile>;
+    setFiles: (newFiles: File[]) => void;
+    replaceFiles: (files: File[] | UploadFile[]) => void;
+    resetState: () => void;
+    uploadFiles: (files: File[] | UploadFile[]) => Promise<UploadFile[] | undefined>;
+    handleFileRemove: (fileId: string) => void;
+};
+type BaseContextUploadControls = {
+    upload: BaseContextUpload;
+    handleDone: () => void;
+    handleCancel: () => void;
+    handlePause: () => void;
+    handleResume: () => void;
+};
+type BaseContextView = {
+    isAddingMore: boolean;
+    setIsAddingMore: (value: boolean) => void;
+    viewMode: 'grid' | 'list';
+    setViewMode: (mode: 'grid' | 'list') => void;
+};
+type BaseContextEditor = {
+    editingFile: UploadFile | null;
+    openImageEditor: (file: UploadFile) => void;
+    closeImageEditor: () => void;
+    saveImageEdit: (editedImageData: string, mimeType?: string) => void;
+    replaceFile: (fileId: string, newFile: UploadFile) => void;
+};
+type BaseResolvedTheme = Omit<UpupResolvedTheme, 'mode'> & {
+    mode: Exclude<UpupThemeMode, 'system'>;
+};
+type BaseContextTheme = {
+    themeMode: Exclude<UpupThemeMode, 'system'>;
+    isDark: boolean;
+    tokens: UpupThemeTokens;
+    resolved: BaseResolvedTheme;
+    slotOverrides: InternalFlatClassNames;
+    slots: DeepPartialSlots;
+};
+
+export { type BaseContextUpload as B, type OrchestratorCallbacks as O, UploaderOrchestrator as U, type BaseContextRuntime as a, type BaseContextSource as b, type BaseContextI18n as c, type BaseContextFiles as d, type BaseContextUploadControls as e, type BaseContextView as f, type BaseContextEditor as g, type BaseContextTheme as h, type OrchestratorState as i, type UploadProgressInfo as j };

package/dist/contracts-pipeline-cf177270.d.cts

@@ -0,0 +1,78 @@
+declare enum FileSource {
+    LOCAL = "local",
+    GOOGLE_DRIVE = "googleDrive",
+    ONE_DRIVE = "oneDrive",
+    DROPBOX = "dropbox",
+    BOX = "box",
+    URL = "url",
+    CAMERA = "camera",
+    MICROPHONE = "microphone",
+    SCREEN = "screen"
+}
+
+declare enum UploadStatus {
+    IDLE = "IDLE",
+    PROCESSING = "PROCESSING",
+    READY = "READY",
+    UPLOADING = "UPLOADING",
+    PAUSED = "PAUSED",
+    SUCCESSFUL = "SUCCESSFUL",
+    FAILED = "FAILED"
+}
+
+type UploadFileMetadata = {
+    width?: number;
+    height?: number;
+    duration?: number;
+    thumbnailUrl?: string;
+    checksum?: string;
+    originalContentHash?: string;
+    originalSize?: number;
+    processedSize?: number;
+    compressed?: boolean;
+    exifStripped?: boolean;
+    heicConverted?: boolean;
+};
+type UploadFile = File & {
+    id: string;
+    source: FileSource;
+    status: UploadStatus;
+    metadata: UploadFileMetadata;
+    url?: string;
+    relativePath?: string;
+    key?: string;
+    etag?: string;
+    /** @deprecated Use metadata.originalContentHash instead */
+    fileHash?: string;
+    /** @deprecated Use metadata.checksum instead */
+    checksumSHA256?: string;
+    /** @deprecated Use metadata.thumbnailUrl instead */
+    thumbnail?: {
+        file: File;
+        key?: string;
+    };
+};
+type UploadFileWithProgress = UploadFile & {
+    progress: number;
+};
+
+interface PipelineStep {
+    name: string;
+    process(file: UploadFile, context: PipelineContext): Promise<UploadFile>;
+    shouldProcess?(file: UploadFile): boolean;
+}
+interface PipelineContext {
+    files: ReadonlyMap<string, UploadFile>;
+    options: Record<string, unknown>;
+    emit(event: string, data?: unknown): void;
+    t: (key: string, vars?: Record<string, unknown>) => string;
+    worker?: {
+        execute<T>(task: {
+            type: string;
+            data: ArrayBuffer;
+            params?: Record<string, unknown>;
+        }): Promise<T>;
+    } | undefined;
+}
+
+export { FileSource as F, type PipelineStep as P, type UploadFileMetadata as U, type UploadFile as a, type UploadFileWithProgress as b, UploadStatus as c, type PipelineContext as d };

package/dist/contracts-pipeline-cf177270.d.ts

@@ -0,0 +1,78 @@
+declare enum FileSource {
+    LOCAL = "local",
+    GOOGLE_DRIVE = "googleDrive",
+    ONE_DRIVE = "oneDrive",
+    DROPBOX = "dropbox",
+    BOX = "box",
+    URL = "url",
+    CAMERA = "camera",
+    MICROPHONE = "microphone",
+    SCREEN = "screen"
+}
+
+declare enum UploadStatus {
+    IDLE = "IDLE",
+    PROCESSING = "PROCESSING",
+    READY = "READY",
+    UPLOADING = "UPLOADING",
+    PAUSED = "PAUSED",
+    SUCCESSFUL = "SUCCESSFUL",
+    FAILED = "FAILED"
+}
+
+type UploadFileMetadata = {
+    width?: number;
+    height?: number;
+    duration?: number;
+    thumbnailUrl?: string;
+    checksum?: string;
+    originalContentHash?: string;
+    originalSize?: number;
+    processedSize?: number;
+    compressed?: boolean;
+    exifStripped?: boolean;
+    heicConverted?: boolean;
+};
+type UploadFile = File & {
+    id: string;
+    source: FileSource;
+    status: UploadStatus;
+    metadata: UploadFileMetadata;
+    url?: string;
+    relativePath?: string;
+    key?: string;
+    etag?: string;
+    /** @deprecated Use metadata.originalContentHash instead */
+    fileHash?: string;
+    /** @deprecated Use metadata.checksum instead */
+    checksumSHA256?: string;
+    /** @deprecated Use metadata.thumbnailUrl instead */
+    thumbnail?: {
+        file: File;
+        key?: string;
+    };
+};
+type UploadFileWithProgress = UploadFile & {
+    progress: number;
+};
+
+interface PipelineStep {
+    name: string;
+    process(file: UploadFile, context: PipelineContext): Promise<UploadFile>;
+    shouldProcess?(file: UploadFile): boolean;
+}
+interface PipelineContext {
+    files: ReadonlyMap<string, UploadFile>;
+    options: Record<string, unknown>;
+    emit(event: string, data?: unknown): void;
+    t: (key: string, vars?: Record<string, unknown>) => string;
+    worker?: {
+        execute<T>(task: {
+            type: string;
+            data: ArrayBuffer;
+            params?: Record<string, unknown>;
+        }): Promise<T>;
+    } | undefined;
+}
+
+export { FileSource as F, type PipelineStep as P, type UploadFileMetadata as U, type UploadFile as a, type UploadFileWithProgress as b, UploadStatus as c, type PipelineContext as d };

package/dist/contracts-strategies-378a16b7.d.cts

@@ -0,0 +1,168 @@
+type PresignedUrlResponse = {
+    key: string;
+    publicUrl?: string;
+    downloadUrl?: string;
+    uploadUrl: string;
+    uploadHeaders?: Record<string, string>;
+    expiresIn: number;
+};
+type MultipartInitResponse = {
+    key: string;
+    uploadId: string;
+    partSize: number;
+    expiresIn: number;
+    /** Opaque server-issued token bound to {key, uploadId, size, expiry}. */
+    token?: string;
+};
+type MultipartSignPartResponse = {
+    uploadUrl: string;
+    uploadHeaders?: Record<string, string>;
+    expiresIn: number;
+};
+type MultipartPart = {
+    partNumber: number;
+    eTag: string;
+    /** Bytes stored for this part. Populated on resume/list responses; the
+     *  complete call ignores it. */
+    size?: number;
+};
+type MultipartListPartsResponse = {
+    parts: MultipartPart[];
+};
+type MultipartResumeResponse = {
+    key: string;
+    /** Fresh server-issued token replacing the presented (possibly expired)
+     *  one — same key/uploadId/owner/size-envelope binding, new expiry. */
+    token: string;
+    /** Parts the storage provider already holds; every entry carries `size`. */
+    parts: MultipartPart[];
+};
+type MultipartCompleteResponse = {
+    key: string;
+    publicUrl?: string;
+    downloadUrl?: string;
+    etag?: string;
+};
+type MultipartAbortResponse = {
+    ok: true;
+};
+type MaxFileSizeObject = {
+    size: number;
+    unit: 'B' | 'KB' | 'MB' | 'GB' | 'TB' | 'PB' | 'EB' | 'ZB' | 'YB';
+};
+type ResumableUploadOptions = {
+    protocol: 'multipart';
+    thresholdBytes?: number;
+    chunkSizeBytes?: number;
+    persist?: boolean;
+    /** Delays (ms) before each successive retry of a transiently failed
+     *  or stalled part. Array length = retry budget; `[]` disables part
+     *  retries. Default `[0, 1000, 3000, 5000]`. */
+    retryDelays?: number[];
+    /** Watchdog (ms) for a single part attempt — a request that neither
+     *  succeeds nor fails within this window is aborted and retried
+     *  instead of hanging the upload. Default 180000. */
+    partTimeoutMs?: number;
+    /** Parts of ONE file in flight at once. Default 3. More parts in
+     *  flight buys throughput on a high-bandwidth link and costs memory
+     *  and sockets — each in-flight part holds its own chunk. Values
+     *  below 1 are treated as 1. */
+    maxConcurrentParts?: number;
+    /** Continue a crash-restored upload automatically instead of waiting
+     *  for the Resume click. Off by default: closing a tab is as often
+     *  "cancel" as "oops", so silently resuming is the integrator's
+     *  call, never the library's. */
+    autoResume?: boolean;
+} | {
+    protocol: 'tus';
+    endpoint: string;
+    chunkSizeBytes?: number;
+    /** @deprecated Use chunkSizeBytes instead. */
+    chunkSize?: number;
+    retryDelays?: number[];
+    storeFingerprintForResuming?: boolean;
+    removeFingerprintOnSuccess?: boolean;
+    headers?: Record<string, string>;
+    metadata?: Record<string, string>;
+    parallelUploads?: number;
+};
+type CrashRecoveryOptions = {
+    enabled?: boolean;
+    storeName?: string;
+    expiry?: number;
+};
+
+type FileMetadata = {
+    name: string;
+    size: number;
+    type: string;
+    metadata?: Record<string, unknown>;
+};
+type UploadCredentials = PresignedUrlResponse;
+type UploadResult = {
+    key: string;
+    publicUrl?: string | undefined;
+    downloadUrl?: string | undefined;
+    etag?: string | undefined;
+};
+type ProgressInfo = {
+    loaded: number;
+    total: number;
+    percentage: number;
+};
+type CloudProvider = 'googleDrive' | 'oneDrive' | 'dropbox' | 'box';
+interface CredentialStrategy {
+    getPresignedUrl(file: FileMetadata): Promise<PresignedUrlResponse>;
+    initMultipartUpload?(file: FileMetadata): Promise<MultipartInitResponse>;
+    signPart?(params: {
+        token: string;
+        partNumber: number;
+    }): Promise<MultipartSignPartResponse>;
+    completeMultipartUpload?(params: {
+        token: string;
+        parts: {
+            partNumber: number;
+            eTag: string;
+        }[];
+    }): Promise<MultipartCompleteResponse>;
+    abortMultipartUpload?(params: {
+        token: string;
+    }): Promise<void>;
+    /** Re-attach to an in-progress multipart upload: verify the presented
+     *  token server-side, list the parts storage already holds, and issue a
+     *  fresh token. Powers cross-reload resume. */
+    resumeMultipartUpload?(params: {
+        token: string;
+    }): Promise<MultipartResumeResponse>;
+}
+interface UploadStrategy {
+    upload(file: File | Blob, credentials: UploadCredentials, options: {
+        onProgress: (loaded: number, total: number) => void;
+        signal: AbortSignal;
+    }): Promise<UploadResult>;
+}
+interface RuntimeAdapter {
+    computeHash(data: ArrayBuffer): Promise<string>;
+    createImageBitmap?: ((blob: Blob) => Promise<ImageBitmap>) | undefined;
+    createWorker?: (() => Worker | null) | undefined;
+    upload(url: string, body: Blob | ArrayBuffer, options: {
+        method: string;
+        headers: Record<string, string>;
+        onProgress: (loaded: number, total: number) => void;
+        signal: AbortSignal;
+    }): Promise<{
+        status: number;
+        headers: Record<string, string>;
+        body: string;
+    }>;
+    readAsArrayBuffer(file: File | Blob): Promise<ArrayBuffer>;
+    createObjectURL?: ((blob: Blob) => string) | undefined;
+    revokeObjectURL?: ((url: string) => void) | undefined;
+    storage?: {
+        get(key: string): Promise<unknown>;
+        set(key: string, value: unknown): Promise<void>;
+        delete(key: string): Promise<void>;
+    } | undefined;
+}
+
+export type { CrashRecoveryOptions as C, FileMetadata as F, MaxFileSizeObject as M, PresignedUrlResponse as P, ResumableUploadOptions as R, UploadCredentials as U, MultipartInitResponse as a, MultipartSignPartResponse as b, MultipartPart as c, MultipartListPartsResponse as d, MultipartResumeResponse as e, MultipartCompleteResponse as f, MultipartAbortResponse as g, UploadResult as h, ProgressInfo as i, CloudProvider as j, CredentialStrategy as k, UploadStrategy as l, RuntimeAdapter as m };

package/dist/contracts-strategies-378a16b7.d.ts

@@ -0,0 +1,168 @@
+type PresignedUrlResponse = {
+    key: string;
+    publicUrl?: string;
+    downloadUrl?: string;
+    uploadUrl: string;
+    uploadHeaders?: Record<string, string>;
+    expiresIn: number;
+};
+type MultipartInitResponse = {
+    key: string;
+    uploadId: string;
+    partSize: number;
+    expiresIn: number;
+    /** Opaque server-issued token bound to {key, uploadId, size, expiry}. */
+    token?: string;
+};
+type MultipartSignPartResponse = {
+    uploadUrl: string;
+    uploadHeaders?: Record<string, string>;
+    expiresIn: number;
+};
+type MultipartPart = {
+    partNumber: number;
+    eTag: string;
+    /** Bytes stored for this part. Populated on resume/list responses; the
+     *  complete call ignores it. */
+    size?: number;
+};
+type MultipartListPartsResponse = {
+    parts: MultipartPart[];
+};
+type MultipartResumeResponse = {
+    key: string;
+    /** Fresh server-issued token replacing the presented (possibly expired)
+     *  one — same key/uploadId/owner/size-envelope binding, new expiry. */
+    token: string;
+    /** Parts the storage provider already holds; every entry carries `size`. */
+    parts: MultipartPart[];
+};
+type MultipartCompleteResponse = {
+    key: string;
+    publicUrl?: string;
+    downloadUrl?: string;
+    etag?: string;
+};
+type MultipartAbortResponse = {
+    ok: true;
+};
+type MaxFileSizeObject = {
+    size: number;
+    unit: 'B' | 'KB' | 'MB' | 'GB' | 'TB' | 'PB' | 'EB' | 'ZB' | 'YB';
+};
+type ResumableUploadOptions = {
+    protocol: 'multipart';
+    thresholdBytes?: number;
+    chunkSizeBytes?: number;
+    persist?: boolean;
+    /** Delays (ms) before each successive retry of a transiently failed
+     *  or stalled part. Array length = retry budget; `[]` disables part
+     *  retries. Default `[0, 1000, 3000, 5000]`. */
+    retryDelays?: number[];
+    /** Watchdog (ms) for a single part attempt — a request that neither
+     *  succeeds nor fails within this window is aborted and retried
+     *  instead of hanging the upload. Default 180000. */
+    partTimeoutMs?: number;
+    /** Parts of ONE file in flight at once. Default 3. More parts in
+     *  flight buys throughput on a high-bandwidth link and costs memory
+     *  and sockets — each in-flight part holds its own chunk. Values
+     *  below 1 are treated as 1. */
+    maxConcurrentParts?: number;
+    /** Continue a crash-restored upload automatically instead of waiting
+     *  for the Resume click. Off by default: closing a tab is as often
+     *  "cancel" as "oops", so silently resuming is the integrator's
+     *  call, never the library's. */
+    autoResume?: boolean;
+} | {
+    protocol: 'tus';
+    endpoint: string;
+    chunkSizeBytes?: number;
+    /** @deprecated Use chunkSizeBytes instead. */
+    chunkSize?: number;
+    retryDelays?: number[];
+    storeFingerprintForResuming?: boolean;
+    removeFingerprintOnSuccess?: boolean;
+    headers?: Record<string, string>;
+    metadata?: Record<string, string>;
+    parallelUploads?: number;
+};
+type CrashRecoveryOptions = {
+    enabled?: boolean;
+    storeName?: string;
+    expiry?: number;
+};
+
+type FileMetadata = {
+    name: string;
+    size: number;
+    type: string;
+    metadata?: Record<string, unknown>;
+};
+type UploadCredentials = PresignedUrlResponse;
+type UploadResult = {
+    key: string;
+    publicUrl?: string | undefined;
+    downloadUrl?: string | undefined;
+    etag?: string | undefined;
+};
+type ProgressInfo = {
+    loaded: number;
+    total: number;
+    percentage: number;
+};
+type CloudProvider = 'googleDrive' | 'oneDrive' | 'dropbox' | 'box';
+interface CredentialStrategy {
+    getPresignedUrl(file: FileMetadata): Promise<PresignedUrlResponse>;
+    initMultipartUpload?(file: FileMetadata): Promise<MultipartInitResponse>;
+    signPart?(params: {
+        token: string;
+        partNumber: number;
+    }): Promise<MultipartSignPartResponse>;
+    completeMultipartUpload?(params: {
+        token: string;
+        parts: {
+            partNumber: number;
+            eTag: string;
+        }[];
+    }): Promise<MultipartCompleteResponse>;
+    abortMultipartUpload?(params: {
+        token: string;
+    }): Promise<void>;
+    /** Re-attach to an in-progress multipart upload: verify the presented
+     *  token server-side, list the parts storage already holds, and issue a
+     *  fresh token. Powers cross-reload resume. */
+    resumeMultipartUpload?(params: {
+        token: string;
+    }): Promise<MultipartResumeResponse>;
+}
+interface UploadStrategy {
+    upload(file: File | Blob, credentials: UploadCredentials, options: {
+        onProgress: (loaded: number, total: number) => void;
+        signal: AbortSignal;
+    }): Promise<UploadResult>;
+}
+interface RuntimeAdapter {
+    computeHash(data: ArrayBuffer): Promise<string>;
+    createImageBitmap?: ((blob: Blob) => Promise<ImageBitmap>) | undefined;
+    createWorker?: (() => Worker | null) | undefined;
+    upload(url: string, body: Blob | ArrayBuffer, options: {
+        method: string;
+        headers: Record<string, string>;
+        onProgress: (loaded: number, total: number) => void;
+        signal: AbortSignal;
+    }): Promise<{
+        status: number;
+        headers: Record<string, string>;
+        body: string;
+    }>;
+    readAsArrayBuffer(file: File | Blob): Promise<ArrayBuffer>;
+    createObjectURL?: ((blob: Blob) => string) | undefined;
+    revokeObjectURL?: ((url: string) => void) | undefined;
+    storage?: {
+        get(key: string): Promise<unknown>;
+        set(key: string, value: unknown): Promise<void>;
+        delete(key: string): Promise<void>;
+    } | undefined;
+}
+
+export type { CrashRecoveryOptions as C, FileMetadata as F, MaxFileSizeObject as M, PresignedUrlResponse as P, ResumableUploadOptions as R, UploadCredentials as U, MultipartInitResponse as a, MultipartSignPartResponse as b, MultipartPart as c, MultipartListPartsResponse as d, MultipartResumeResponse as e, MultipartCompleteResponse as f, MultipartAbortResponse as g, UploadResult as h, ProgressInfo as i, CloudProvider as j, CredentialStrategy as k, UploadStrategy as l, RuntimeAdapter as m };