@uploadista/client-core 0.0.3

package/dist/upload/flow-upload.js

@@ -0,0 +1,240 @@
+import { UploadistaError } from "../error";
+import { shouldRetry } from "./chunk-upload";
+import { inStatusCategory } from "./upload-utils";
+/**
+ * Start a flow-based upload by initializing the streaming input node
+ */
+export async function startFlowUpload({ source, flowConfig, uploadistaApi, logger, platformService, openWebSocket, closeWebSocket, ...callbacks }) {
+    const { flowId, storageId } = flowConfig;
+    // Get the flow to find the streaming input node
+    const { flow } = await uploadistaApi.getFlow(flowId);
+    // Find the streaming-input-node in the flow
+    const inputNode = flow.nodes.find((node) => node.type === "input");
+    if (!inputNode) {
+        const error = new UploadistaError({
+            name: "FLOW_INCOMPATIBLE",
+            message: `Flow ${flowId} does not have a streaming input node. The flow must contain a node with type "input" to support flow uploads.`,
+        });
+        callbacks.onError?.(error);
+        throw error;
+    }
+    const inputNodeId = inputNode.id;
+    // Step 1: Initialize the flow with init operation
+    const metadata = {
+        originalName: source.name ?? "unknown",
+        mimeType: source.type ?? "application/octet-stream",
+        size: source.size ?? 0,
+        ...flowConfig.metadata,
+    };
+    logger.log(`Starting flow upload for flow ${flowId}, node ${inputNodeId}`);
+    const { status, job } = await uploadistaApi.runFlow(flowId, storageId, {
+        [inputNodeId]: {
+            operation: "init",
+            storageId,
+            metadata,
+        },
+    });
+    const jobId = job.id;
+    if (!inStatusCategory(status, 200) || !jobId) {
+        const error = new UploadistaError({
+            name: "FLOW_INIT_FAILED",
+            message: "Failed to initialize flow upload",
+        });
+        callbacks.onError?.(error);
+        throw error;
+    }
+    callbacks.onJobStart?.(jobId);
+    logger.log(`Flow job ${jobId} created, opening WebSocket`);
+    // Open WebSocket to listen for flow events
+    // Events are buffered in the Durable Object until connection is established
+    openWebSocket(jobId);
+    logger.log(`Waiting for upload ID from node`);
+    // Step 2: Wait for the streaming-input-node to pause and return the upload file
+    // Poll job status until paused (with timeout)
+    const maxAttempts = 60; // 30 seconds total
+    const pollInterval = 500; // 0.5 second
+    let attempts = 0;
+    let jobStatus = await uploadistaApi.getJobStatus(jobId);
+    while (jobStatus.status !== "paused" && attempts < maxAttempts) {
+        await new Promise((resolve) => platformService.setTimeout(resolve, pollInterval));
+        jobStatus = await uploadistaApi.getJobStatus(jobId);
+        attempts++;
+    }
+    if (jobStatus.status !== "paused") {
+        const error = new UploadistaError({
+            name: "FLOW_TIMEOUT",
+            message: `Flow did not pause after init (status: ${jobStatus.status})`,
+        });
+        callbacks.onError?.(error);
+        throw error;
+    }
+    // Get the upload file from streaming input node task result
+    const streamingInputTask = jobStatus.tasks.find((task) => task.nodeId === inputNodeId);
+    const uploadFile = streamingInputTask?.result;
+    if (!uploadFile?.id) {
+        const error = new UploadistaError({
+            name: "FLOW_NO_UPLOAD_ID",
+            message: "Flow did not return upload ID after init",
+        });
+        callbacks.onError?.(error);
+        throw error;
+    }
+    logger.log(`Upload ID received: ${uploadFile.id}`);
+    callbacks.onStart?.({
+        uploadId: uploadFile.id,
+        size: source.size ?? null,
+    });
+    return { jobId, uploadFile, inputNodeId };
+}
+/**
+ * Upload chunks directly to the upload API (not through continueFlow)
+ * This is more efficient and reuses the existing upload infrastructure
+ */
+export async function performFlowUpload({ jobId, uploadFile, inputNodeId, offset, source, retryAttempt = 0, abortController, retryDelays, smartChunker, uploadistaApi, logger, smartChunking, metrics, platformService, onRetry, ...callbacks }) {
+    let offsetBeforeRetry = offset;
+    let currentOffset = offset;
+    try {
+        // Get optimal chunk size
+        const remainingBytes = source.size ? source.size - offset : undefined;
+        const chunkSizeDecision = smartChunker.getNextChunkSize(remainingBytes);
+        const chunkSize = chunkSizeDecision.size;
+        const endByte = Math.min(offset + chunkSize, source.size ?? 0);
+        const sliceResult = await source.slice(offset, endByte);
+        if (!sliceResult || !sliceResult.value) {
+            throw new UploadistaError({
+                name: "NETWORK_ERROR",
+                message: "Failed to read chunk from file",
+            });
+        }
+        const chunkData = sliceResult.value;
+        // Upload chunk directly to upload API (bypassing flow)
+        const startTime = Date.now();
+        const res = await uploadistaApi.uploadChunk(uploadFile.id, chunkData, {
+            abortController,
+        });
+        const duration = Date.now() - startTime;
+        if (!res.upload) {
+            throw new UploadistaError({
+                name: "UPLOAD_CHUNK_FAILED",
+                message: "Upload chunk response missing upload data",
+            });
+        }
+        currentOffset = res.upload.offset;
+        callbacks.onProgress?.(uploadFile.id, currentOffset, source.size ?? 0);
+        callbacks.onChunkComplete?.(currentOffset - offset, offset, source.size ?? 0);
+        // Record detailed chunk metrics
+        if (smartChunking?.enabled !== false) {
+            const chunkIndex = Math.floor(offset / chunkSize);
+            metrics.recordChunk({
+                chunkIndex,
+                size: chunkSize,
+                duration,
+                speed: chunkSize / (duration / 1000),
+                success: true,
+                retryCount: retryAttempt,
+                networkCondition: smartChunker.getLastDecision()?.networkCondition?.type,
+                chunkingStrategy: smartChunker.getLastDecision()?.strategy,
+            });
+            // Update smart chunker with connection metrics
+            const connectionMetrics = uploadistaApi.getConnectionMetrics();
+            smartChunker.updateConnectionMetrics(connectionMetrics);
+        }
+        // Check if upload is complete after uploading the chunk
+        if (currentOffset >= (source.size ?? 0)) {
+            if (source)
+                source.close();
+            // Complete metrics session
+            if (smartChunking?.enabled !== false) {
+                const sessionMetrics = metrics.endSession();
+                if (sessionMetrics) {
+                    logger.log(`Flow upload completed: ${sessionMetrics.totalSize} bytes in ${sessionMetrics.totalDuration}ms, avg speed: ${Math.round(sessionMetrics.averageSpeed / 1024)}KB/s`);
+                }
+            }
+            // Upload is complete - finalize the flow
+            logger.log(`Finalizing flow upload for job ${jobId}`);
+            try {
+                await uploadistaApi.continueFlow(jobId, inputNodeId, {
+                    operation: "finalize",
+                    uploadId: uploadFile.id,
+                }, { contentType: "application/json" });
+            }
+            catch (err) {
+                // Finalization errors should not trigger chunk retry logic
+                const error = new UploadistaError({
+                    name: "FLOW_FINALIZE_FAILED",
+                    message: `Failed to finalize flow upload for job ${jobId}`,
+                    cause: err,
+                });
+                callbacks.onError?.(error);
+                throw error;
+            }
+            return;
+        }
+        // Continue uploading next chunk
+        await performFlowUpload({
+            jobId,
+            uploadFile,
+            inputNodeId,
+            offset: currentOffset,
+            source,
+            platformService,
+            retryDelays,
+            smartChunker,
+            uploadistaApi,
+            logger,
+            smartChunking,
+            metrics,
+            onRetry,
+            abortController,
+            ...callbacks,
+        });
+    }
+    catch (err) {
+        // Retry logic similar to single-upload
+        if (retryDelays != null) {
+            const shouldResetDelays = offset != null && currentOffset > offsetBeforeRetry;
+            if (shouldResetDelays) {
+                retryAttempt = 0;
+            }
+            const castedErr = !(err instanceof UploadistaError)
+                ? new UploadistaError({
+                    name: "NETWORK_ERROR",
+                    message: "Network error during flow upload",
+                    cause: err,
+                })
+                : err;
+            if (shouldRetry(platformService, castedErr, retryAttempt, retryDelays, callbacks.onShouldRetry)) {
+                const delay = retryDelays[retryAttempt];
+                offsetBeforeRetry = offset;
+                const timeout = platformService.setTimeout(async () => {
+                    await performFlowUpload({
+                        jobId,
+                        uploadFile,
+                        inputNodeId,
+                        offset,
+                        source,
+                        retryAttempt: retryAttempt + 1,
+                        retryDelays,
+                        smartChunker,
+                        uploadistaApi,
+                        logger,
+                        smartChunking,
+                        metrics,
+                        platformService,
+                        onRetry,
+                        abortController,
+                        ...callbacks,
+                    });
+                }, delay);
+                onRetry?.(timeout);
+            }
+            else {
+                throw new UploadistaError({
+                    name: "UPLOAD_CHUNK_FAILED",
+                    message: `Failed to upload chunk for job ${jobId} at offset ${offset}`,
+                    cause: err,
+                });
+            }
+        }
+    }
+}

package/dist/upload/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./upload-metrics";
+export * from "./upload-utils";
+//# sourceMappingURL=index.d.ts.map

package/dist/upload/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/upload/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC"}

package/dist/upload/index.js

@@ -0,0 +1,2 @@
+export * from "./upload-metrics";
+export * from "./upload-utils";

package/dist/upload/parallel-upload.d.ts

@@ -0,0 +1,65 @@
+import type { UploadistaApi } from "../client/uploadista-api";
+import type { Logger } from "../logger";
+import type { AbortControllerFactory, AbortControllerLike } from "../services/abort-controller-service";
+import type { ChecksumService } from "../services/checksum-service";
+import type { FileSource } from "../services/file-reader-service";
+import type { IdGenerationService } from "../services/id-generation-service";
+import type { PlatformService, Timeout } from "../services/platform-service";
+import type { WebSocketLike } from "../services/websocket-service";
+import type { SmartChunker, SmartChunkerConfig } from "../smart-chunker";
+import type { ClientStorage } from "../storage/client-storage";
+import { type Callbacks } from "./single-upload";
+import type { UploadMetrics } from "./upload-metrics";
+export type ParallelUploadSegment = {
+    uploadId: string;
+    uploadIdStorageKey: string | undefined;
+    segmentIndex: number;
+    startByte: number;
+    endByte: number;
+    offset: number;
+    abortController: AbortControllerLike;
+    retryTimeout: Timeout | null;
+};
+export type ParallelUploadState = {
+    segments: ParallelUploadSegment[];
+    totalProgress: number;
+    completed: boolean;
+    failed: boolean;
+    error?: Error;
+};
+export type ParallelUploadResult = {
+    parallelState: ParallelUploadState;
+    abort: () => Promise<void>;
+};
+/**
+ * Initiate the uploading procedure for a parallelized upload, where one file is split into
+ * multiple request which are run in parallel.
+ */
+export declare function startParallelUpload({ source, storageId, fingerprint, uploadLengthDeferred, parallelUploads, parallelChunkSize, retryDelays, smartChunker, uploadistaApi, logger, checksumService, smartChunking, metrics, clientStorage, generateId, storeFingerprintForResuming, openWebSocket, closeWebSocket, terminate, abortControllerFactory, platformService, ...callbacks }: {
+    source: FileSource;
+    storageId: string;
+    fingerprint: string;
+    uploadLengthDeferred: boolean | undefined;
+    parallelUploads: number;
+    parallelChunkSize?: number;
+    retryDelays?: number[];
+    smartChunker: SmartChunker;
+    uploadistaApi: UploadistaApi;
+    checksumService: ChecksumService;
+    logger: Logger;
+    smartChunking?: SmartChunkerConfig;
+    metrics: UploadMetrics;
+    clientStorage: ClientStorage;
+    generateId: IdGenerationService;
+    storeFingerprintForResuming: boolean;
+    openWebSocket: (uploadId: string) => WebSocketLike;
+    closeWebSocket: (uploadId: string) => void;
+    terminate: (uploadId: string) => Promise<void>;
+    abortControllerFactory: AbortControllerFactory;
+    platformService: PlatformService;
+} & Callbacks): Promise<ParallelUploadResult | undefined>;
+/**
+ * Abort a parallel upload by cleaning up all segments
+ */
+export declare function abortParallelUpload(state: ParallelUploadState, logger: Logger, terminate: (uploadId: string) => Promise<void>, closeWebSocket: (uploadId: string) => void, platformService: PlatformService): Promise<void>;
+//# sourceMappingURL=parallel-upload.d.ts.map

package/dist/upload/parallel-upload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallel-upload.d.ts","sourceRoot":"","sources":["../../src/upload/parallel-upload.ts"],"names":[],"mappings":"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"}

package/dist/upload/parallel-upload.js

@@ -0,0 +1,231 @@
+import { UploadistaError } from "../error";
+import { createUpload, performUpload } from "./single-upload";
+import { calculateSegments } from "./upload-utils";
+/**
+ * Initiate the uploading procedure for a parallelized upload, where one file is split into
+ * multiple request which are run in parallel.
+ */
+export async function startParallelUpload({ source, storageId, fingerprint, uploadLengthDeferred, parallelUploads, parallelChunkSize, retryDelays, smartChunker, uploadistaApi, logger, checksumService, smartChunking, metrics, clientStorage, generateId, storeFingerprintForResuming, openWebSocket, closeWebSocket, terminate, abortControllerFactory, platformService, ...callbacks }) {
+    if (!source.size || source.size === 0) {
+        callbacks.onError?.(new UploadistaError({
+            name: "UPLOAD_SIZE_NOT_SPECIFIED",
+            message: "Parallel upload requires a known file size",
+        }));
+        return;
+    }
+    // Calculate segments for parallel upload
+    const segments = calculateSegments(source.size, parallelUploads, parallelChunkSize);
+    logger.log(`Starting parallel upload with ${segments.length} segments`);
+    // Initialize parallel upload state
+    const parallelState = {
+        segments: [],
+        totalProgress: 0,
+        completed: false,
+        failed: false,
+    };
+    // Progress tracking for aggregation
+    const segmentProgress = new Map();
+    const segmentTotals = new Map();
+    const updateTotalProgress = () => {
+        const totalBytes = Array.from(segmentTotals.values()).reduce((sum, size) => sum + size, 0);
+        const progressBytes = Array.from(segmentProgress.values()).reduce((sum, progress) => sum + progress, 0);
+        parallelState.totalProgress =
+            totalBytes > 0 ? progressBytes / totalBytes : 0;
+        // Aggregate progress callback
+        if (callbacks.onProgress && totalBytes > 0) {
+            callbacks.onProgress(`parallel-upload`, progressBytes, totalBytes);
+        }
+    };
+    try {
+        // Create upload sessions for each segment
+        const segmentUploads = await Promise.all(segments.map(async (segment) => {
+            // Create a segmented source for this chunk
+            const segmentSource = {
+                ...source,
+                size: segment.endByte - segment.startByte,
+                async slice(start, end) {
+                    // Adjust slice to segment boundaries
+                    const actualStart = segment.startByte + (start ?? 0);
+                    const actualEnd = Math.min(segment.startByte + (end ?? segment.endByte - segment.startByte), segment.endByte);
+                    return await source.slice(actualStart, actualEnd);
+                },
+            };
+            const createResult = await createUpload({
+                fingerprint: `${fingerprint}-segment-${segment.segmentIndex}`,
+                storageId,
+                source: segmentSource,
+                uploadLengthDeferred,
+                platformService,
+                metadata: {
+                    parallelUpload: "true",
+                    segmentIndex: segment.segmentIndex.toString(),
+                    totalSegments: segments.length.toString(),
+                    parentFingerprint: fingerprint,
+                },
+                checksumService,
+                uploadistaApi,
+                logger,
+                clientStorage,
+                generateId,
+                storeFingerprintForResuming,
+                openWebSocket,
+                closeWebSocket,
+                onSuccess: () => { },
+                onError: (error) => logger.log(`Segment ${segment.segmentIndex} creation error: ${error}`),
+                onStart: (info) => {
+                    segmentTotals.set(segment.segmentIndex, info.size ?? 0);
+                    updateTotalProgress();
+                },
+            });
+            if (!createResult) {
+                throw new UploadistaError({
+                    name: "PARALLEL_SEGMENT_CREATION_FAILED",
+                    message: `Failed to create upload segment ${segment.segmentIndex}`,
+                });
+            }
+            const parallelSegment = {
+                uploadId: createResult.uploadId,
+                uploadIdStorageKey: createResult.uploadIdStorageKey,
+                segmentIndex: segment.segmentIndex,
+                startByte: segment.startByte,
+                endByte: segment.endByte,
+                offset: createResult.offset,
+                abortController: abortControllerFactory.create(),
+                retryTimeout: null,
+            };
+            return {
+                segment: parallelSegment,
+                source: segmentSource,
+            };
+        }));
+        // Store segments in state
+        parallelState.segments = segmentUploads.map((upload) => upload.segment);
+        // Notify start with combined upload info
+        callbacks.onStart?.({
+            uploadId: `parallel-${parallelState.segments.map((s) => s.uploadId).join(",")}`,
+            size: source.size,
+        });
+        // Start parallel upload for each segment
+        const uploadPromises = segmentUploads.map(async ({ segment, source: segmentSource }) => {
+            try {
+                await performUpload({
+                    uploadId: segment.uploadId,
+                    offset: segment.offset,
+                    source: segmentSource,
+                    uploadLengthDeferred,
+                    abortController: segment.abortController,
+                    retryDelays,
+                    smartChunker,
+                    uploadistaApi,
+                    platformService,
+                    logger,
+                    smartChunking,
+                    metrics,
+                    onProgress: (_, bytes, total) => {
+                        segmentProgress.set(segment.segmentIndex, bytes);
+                        if (total)
+                            segmentTotals.set(segment.segmentIndex, total);
+                        updateTotalProgress();
+                    },
+                    onChunkComplete: (chunkSize, bytesAccepted, bytesTotal) => {
+                        if (callbacks.onChunkComplete) {
+                            callbacks.onChunkComplete(chunkSize, bytesAccepted, bytesTotal);
+                        }
+                    },
+                    onSuccess: (_uploadFile) => {
+                        logger.log(`Segment ${segment.segmentIndex} completed successfully`);
+                        // Mark this segment as completed
+                        segmentProgress.set(segment.segmentIndex, segmentTotals.get(segment.segmentIndex) ?? 0);
+                        updateTotalProgress();
+                    },
+                    onShouldRetry: (error, retryAttempt) => {
+                        logger.log(`Segment ${segment.segmentIndex} retry attempt ${retryAttempt}: ${error}`);
+                        return retryAttempt < (retryDelays?.length ?? 0);
+                    },
+                    onRetry: (timeout) => {
+                        segment.retryTimeout = timeout;
+                    },
+                    onError: (error) => {
+                        logger.log(`Segment ${segment.segmentIndex} failed: ${error}`);
+                        throw error;
+                    },
+                });
+            }
+            catch (error) {
+                logger.log(`Segment ${segment.segmentIndex} upload failed: ${error}`);
+                throw new UploadistaError({
+                    name: "PARALLEL_SEGMENT_UPLOAD_FAILED",
+                    message: `Segment ${segment.segmentIndex} upload failed`,
+                    cause: error,
+                });
+            }
+        });
+        // Wait for all segments to complete
+        await Promise.all(uploadPromises);
+        // Mark as completed
+        parallelState.completed = true;
+        logger.log("All parallel upload segments completed successfully");
+        // Call success callback with aggregated result
+        if (callbacks.onSuccess) {
+            const aggregatedResult = {
+                id: `parallel-${parallelState.segments.map((s) => s.uploadId).join(",")}`,
+                offset: source.size,
+                size: source.size,
+                storage: {
+                    id: storageId,
+                    type: "parallel-upload",
+                },
+                metadata: {
+                    parallelUpload: "true",
+                    totalSegments: segments.length.toString(),
+                    fingerprint,
+                },
+            };
+            callbacks.onSuccess(aggregatedResult);
+        }
+        // Close all sources
+        for (const upload of segmentUploads) {
+            upload.source.close?.();
+        }
+        return {
+            parallelState,
+            abort: async () => {
+                await abortParallelUpload(parallelState, logger, terminate, closeWebSocket, platformService);
+            },
+        };
+    }
+    catch (error) {
+        parallelState.failed = true;
+        parallelState.error = error;
+        // Clean up any created segments
+        await abortParallelUpload(parallelState, logger, terminate, closeWebSocket, platformService);
+        callbacks.onError?.(error);
+        throw error;
+    }
+}
+/**
+ * Abort a parallel upload by cleaning up all segments
+ */
+export async function abortParallelUpload(state, logger, terminate, closeWebSocket, platformService) {
+    logger.log("Aborting parallel upload...");
+    // Abort all segment controllers
+    for (const segment of state.segments) {
+        segment.abortController.abort();
+        if (segment.retryTimeout) {
+            platformService.clearTimeout(segment.retryTimeout);
+            segment.retryTimeout = null;
+        }
+        // Attempt to terminate the upload on the server
+        try {
+            await terminate(segment.uploadId);
+        }
+        catch (error) {
+            logger.log(`Failed to terminate segment ${segment.segmentIndex}: ${error}`);
+        }
+        // Close websockets
+        closeWebSocket(segment.uploadId);
+    }
+    state.completed = false;
+    state.failed = true;
+    logger.log("Parallel upload aborted");
+}

package/dist/upload/single-upload.d.ts

@@ -0,0 +1,118 @@
+import type { UploadFile } from "@uploadista/core/types";
+import type { UploadistaApi } from "../client/uploadista-api";
+import { UploadistaError } from "../error";
+import type { Logger } from "../logger";
+import type { AbortControllerLike } from "../services/abort-controller-service";
+import type { ChecksumService } from "../services/checksum-service";
+import type { FileSource } from "../services/file-reader-service";
+import type { IdGenerationService } from "../services/id-generation-service";
+import type { PlatformService, Timeout } from "../services/platform-service";
+import type { WebSocketLike } from "../services/websocket-service";
+import type { SmartChunker, SmartChunkerConfig } from "../smart-chunker";
+import type { ClientStorage } from "../storage/client-storage";
+import { type OnProgress, type OnShouldRetry } from "./chunk-upload";
+import type { UploadMetrics } from "./upload-metrics";
+export type Callbacks = {
+    onProgress?: OnProgress;
+    onChunkComplete?: (chunkSize: number, bytesAccepted: number, bytesTotal: number | null) => void;
+    onSuccess?: (payload: UploadFile) => void;
+    onError?: (error: Error | UploadistaError) => void;
+    onStart?: (file: {
+        uploadId: string;
+        size: number | null;
+    }) => void;
+    onJobStart?: (jobId: string) => void;
+    onShouldRetry?: OnShouldRetry;
+};
+export type SingleUploadResult = {
+    uploadIdStorageKey: string | undefined;
+    uploadId: string;
+    offset: number;
+};
+/**
+ * Start uploading the file using PATCH requests. The file will be divided
+ * into chunks as specified in the chunkSize option. During the upload
+ * the onProgress event handler may be invoked multiple times.
+ */
+export declare function performUpload({ uploadId, offset, source, uploadLengthDeferred, retryAttempt, abortController, retryDelays, smartChunker, uploadistaApi, logger, smartChunking, metrics, platformService, onRetry, ...callbacks }: {
+    uploadId: string;
+    offset: number;
+    retryAttempt?: number;
+    source: FileSource;
+    abortController: AbortControllerLike;
+    uploadLengthDeferred: boolean | undefined;
+    retryDelays: number[] | undefined;
+    smartChunker: SmartChunker;
+    uploadistaApi: UploadistaApi;
+    logger: Logger;
+    smartChunking?: SmartChunkerConfig;
+    metrics: UploadMetrics;
+    platformService: PlatformService;
+    onRetry?: (timeout: Timeout) => void;
+} & Callbacks): Promise<void>;
+/**
+ * Create a new upload using the creation extension by sending a POST
+ * request to the endpoint. After successful creation the file will be
+ * uploaded
+ */
+export declare function createUpload({ fingerprint, storageId, source, uploadLengthDeferred, metadata, uploadistaApi, logger, checksumService, clientStorage, generateId, storeFingerprintForResuming, openWebSocket, closeWebSocket, computeChecksum, checksumAlgorithm, platformService, ...callbacks }: {
+    fingerprint: string;
+    storageId: string;
+    source: FileSource;
+    uploadLengthDeferred: boolean | undefined;
+    metadata: Record<string, string>;
+    uploadistaApi: UploadistaApi;
+    logger: Logger;
+    clientStorage: ClientStorage;
+    generateId: IdGenerationService;
+    storeFingerprintForResuming: boolean;
+    openWebSocket: (uploadId: string) => WebSocketLike;
+    closeWebSocket: (uploadId: string) => void;
+    checksumService: ChecksumService;
+    computeChecksum?: boolean;
+    checksumAlgorithm?: string;
+    platformService: PlatformService;
+} & Callbacks): Promise<SingleUploadResult | undefined>;
+/**
+ * Try to resume an existing upload. First a HEAD request will be sent
+ * to retrieve the offset. If the request fails a new upload will be
+ * created. In the case of a successful response the file will be uploaded.
+ */
+export declare function resumeUpload({ uploadId, storageId, uploadIdStorageKey, fingerprint, source, uploadLengthDeferred, uploadistaApi, logger, platformService, checksumService, clientStorage, generateId, storeFingerprintForResuming, openWebSocket, ...callbacks }: {
+    uploadId: string;
+    storageId: string;
+    uploadIdStorageKey: string;
+    fingerprint: string;
+    platformService: PlatformService;
+    source: FileSource;
+    uploadLengthDeferred: boolean | undefined;
+    uploadistaApi: UploadistaApi;
+    checksumService: ChecksumService;
+    logger: Logger;
+    clientStorage: ClientStorage;
+    generateId: IdGenerationService;
+    storeFingerprintForResuming: boolean;
+    openWebSocket: (uploadId: string) => WebSocketLike;
+} & Callbacks): Promise<SingleUploadResult | undefined>;
+/**
+ * Initiate the uploading procedure for a non-parallel upload. Here the entire file is
+ * uploaded in a sequential matter.
+ */
+export declare function startSingleUpload({ source, uploadId, uploadIdStorageKey, storageId, fingerprint, platformService, uploadLengthDeferred, uploadistaApi, checksumService, logger, clientStorage, generateId, storeFingerprintForResuming, openWebSocket, closeWebSocket, ...callbacks }: {
+    source: FileSource;
+    uploadId: string | null;
+    uploadIdStorageKey: string | null;
+    storageId: string;
+    fingerprint: string;
+    platformService: PlatformService;
+    uploadLengthDeferred: boolean | undefined;
+    uploadistaApi: UploadistaApi;
+    checksumService: ChecksumService;
+    logger: Logger;
+    clientStorage: ClientStorage;
+    generateId: IdGenerationService;
+    storeFingerprintForResuming: boolean;
+    openWebSocket: (uploadId: string) => WebSocketLike;
+    closeWebSocket: (uploadId: string) => void;
+} & Callbacks): Promise<SingleUploadResult | undefined>;
+//# sourceMappingURL=single-upload.d.ts.map