@uploadista/client-core 0.0.20-beta.6 → 0.0.20-beta.8

package/dist/index.d.mts

@@ -1,7 +1,7 @@
 import { UploadStrategyNegotiator } from "@uploadista/core/upload";
 import { DataStoreCapabilities, InputFile, UploadEvent, UploadFile } from "@uploadista/core/types";
-import z from "zod";
 import { FlowData, FlowEvent, FlowJob, TypedOutput } from "@uploadista/core/flow";
+import z from "zod";
 import * as _uploadista_core0 from "@uploadista/core";
 import { UploadFile as UploadFile$1 } from "@uploadista/core";
 
@@ -2769,38 +2769,185 @@ declare function createUploadistaClient<UploadInput$1>({
  */
 type UploadistaClient = ReturnType<typeof createUploadistaClient>;
 //#endregion
-//#region src/storage/in-memory-storage-service.d.ts
+//#region src/managers/event-subscription-manager.d.ts
 /**
- * In-memory fallback storage service for Expo
- * Used when AsyncStorage is not available or for testing
+ * Generic event type that the subscription manager can handle
  */
-declare function createInMemoryStorageService(): StorageService;
-//#endregion
-//#region src/types/flow-result.d.ts
-type FlowResult<TOutput = UploadFile> = {
-  type: "success";
-  value: TOutput;
-} | {
-  type: "error";
-  error: Error;
-} | {
-  type: "cancelled";
-};
-//#endregion
-//#region src/types/flow-upload-item.d.ts
+interface GenericEvent {
+  type: string;
+  data?: unknown;
+}
 /**
- * Flow upload item for multi-flow-upload tracking
+ * Event handler callback function
  */
-interface FlowUploadItem<UploadInput$1> {
-  id: string;
-  file: UploadInput$1;
-  status: "pending" | "uploading" | "success" | "error" | "aborted";
-  progress: number;
-  bytesUploaded: number;
-  totalBytes: number;
-  error: Error | null;
-  result: UploadFile$1 | null;
-  jobId: string | null;
+type SubscriptionEventHandler<T = GenericEvent> = (event: T) => void;
+/**
+ * Unsubscribe function returned from subscriptions
+ */
+type UnsubscribeFunction = () => void;
+/**
+ * Event source that provides subscription capabilities
+ */
+interface EventSource<T = GenericEvent> {
+  /**
+   * Subscribe to events from this source
+   * @returns Unsubscribe function to clean up the subscription
+   */
+  subscribe(handler: SubscriptionEventHandler<T>): UnsubscribeFunction;
+}
+/**
+ * Options for event filtering
+ */
+interface EventFilterOptions {
+  /**
+   * Filter events by type (exact match)
+   */
+  eventType?: string;
+  /**
+   * Filter events by upload/job ID
+   * If provided, only events with matching ID will be passed to the handler
+   */
+  uploadId?: string | null;
+  /**
+   * Custom filter function for advanced filtering
+   * Return true to pass the event to the handler
+   */
+  customFilter?: (event: GenericEvent) => boolean;
+}
+/**
+ * Platform-agnostic event subscription manager that handles event filtering,
+ * subscription tracking, and automatic cleanup.
+ *
+ * This manager simplifies event handling by:
+ * - Filtering events by type and/or ID
+ * - Tracking all active subscriptions
+ * - Providing cleanup methods to unsubscribe from all events
+ * - Supporting custom filter functions for advanced scenarios
+ *
+ * @example Basic event subscription
+ * ```typescript
+ * const manager = new EventSubscriptionManager(eventSource);
+ *
+ * manager.subscribe(
+ *   (event) => console.log('Upload progress:', event),
+ *   { eventType: 'UPLOAD_PROGRESS', uploadId: 'abc123' }
+ * );
+ *
+ * // Clean up all subscriptions when done
+ * manager.cleanup();
+ * ```
+ *
+ * @example Multiple filtered subscriptions
+ * ```typescript
+ * const manager = new EventSubscriptionManager(eventSource);
+ *
+ * // Subscribe to progress events for specific upload
+ * manager.subscribe(
+ *   onProgress,
+ *   { eventType: 'UPLOAD_PROGRESS', uploadId: currentUploadId }
+ * );
+ *
+ * // Subscribe to error events for any upload
+ * manager.subscribe(
+ *   onError,
+ *   { eventType: 'UPLOAD_ERROR' }
+ * );
+ *
+ * // Subscribe to all events with custom filtering
+ * manager.subscribe(
+ *   onEvent,
+ *   { customFilter: (e) => e.data?.priority === 'high' }
+ * );
+ * ```
+ */
+declare class EventSubscriptionManager<T extends GenericEvent = GenericEvent> {
+  private readonly eventSource;
+  private subscriptions;
+  /**
+   * Create a new EventSubscriptionManager
+   *
+   * @param eventSource - Source to subscribe to for events
+   */
+  constructor(eventSource: EventSource<T>);
+  /**
+   * Subscribe to events with optional filtering
+   *
+   * @param handler - Callback function to invoke when matching events occur
+   * @param filter - Optional filter options to narrow down which events trigger the handler
+   * @returns Unsubscribe function to remove this specific subscription
+   *
+   * @example Subscribe to specific event type
+   * ```typescript
+   * const unsubscribe = manager.subscribe(
+   *   (event) => console.log('Progress:', event),
+   *   { eventType: 'UPLOAD_PROGRESS' }
+   * );
+   *
+   * // Later, unsubscribe
+   * unsubscribe();
+   * ```
+   */
+  subscribe(handler: SubscriptionEventHandler<T>, filter?: EventFilterOptions): UnsubscribeFunction;
+  /**
+   * Check if an event matches the filter criteria
+   *
+   * @param event - Event to check
+   * @param filter - Filter options to apply
+   * @returns True if the event passes all filters
+   */
+  private shouldHandleEvent;
+  /**
+   * Get the number of active subscriptions
+   *
+   * @returns Number of tracked subscriptions
+   */
+  getSubscriptionCount(): number;
+  /**
+   * Check if there are any active subscriptions
+   *
+   * @returns True if at least one subscription is active
+   */
+  hasSubscriptions(): boolean;
+  /**
+   * Unsubscribe from all tracked subscriptions and clear the subscription list
+   *
+   * This is typically called when disposing of a component or cleaning up resources.
+   *
+   * @example Cleanup in framework hooks
+   * ```typescript
+   * // React
+   * useEffect(() => {
+   *   const manager = new EventSubscriptionManager(eventSource);
+   *   manager.subscribe(handler, filter);
+   *
+   *   return () => manager.cleanup();
+   * }, []);
+   *
+   * // Vue
+   * onUnmounted(() => {
+   *   manager.cleanup();
+   * });
+   * ```
+   */
+  cleanup(): void;
+  /**
+   * Update the upload ID filter for all subscriptions that have an uploadId filter
+   *
+   * This is useful when the current upload changes and you want to update
+   * all subscriptions to listen for the new upload's events.
+   *
+   * @param newUploadId - New upload ID to filter events by
+   *
+   * @example Update upload ID when starting new upload
+   * ```typescript
+   * const manager = new EventSubscriptionManager(eventSource);
+   * manager.subscribe(onProgress, { eventType: 'UPLOAD_PROGRESS', uploadId: null });
+   *
+   * // When upload starts
+   * manager.updateUploadIdFilter(uploadId);
+   * ```
+   */
+  updateUploadIdFilter(newUploadId: string | null): void;
 }
 //#endregion
 //#region src/types/flow-upload-options.d.ts
@@ -2877,643 +3024,472 @@ interface FlowUploadOptions {
   onShouldRetry?: (error: Error, retryAttempt: number) => boolean;
 }
 //#endregion
-//#region src/types/flow-inputs.d.ts
+//#region src/managers/flow-manager.d.ts
 /**
- * Type definitions for flexible flow input specifications.
- *
- * This module defines types for passing input data to flows with multiple input nodes.
- * The FlowInputs type maps node IDs to their respective input data, enabling support
- * for flows with single or multiple input points.
- *
- * @module types/flow-inputs
- *
- * @example
- * ```typescript
- * import type { FlowInputs } from "@uploadista/client-core";
- *
- * // Single input flow
- * const inputs: FlowInputs = {
- *   "file-input": {
- *     operation: "url",
- *     url: "https://example.com/image.jpg"
- *   }
- * };
- *
- * // Multi-input flow
- * const multiInputs: FlowInputs = {
- *   "file-input": {
- *     operation: "init",
- *     storageId: "s3",
- *     metadata: { originalName: "image.jpg" }
- *   },
- *   "metadata-input": {
- *     title: "My Image",
- *     tags: ["photo", "landscape"]
- *   }
- * };
- * ```
+ * Flow upload status representing the current state of a flow upload lifecycle.
+ * Flow uploads progress through: idle → uploading → processing → success/error/aborted
  */
+type FlowUploadStatus = "idle" | "uploading" | "processing" | "success" | "error" | "aborted";
 /**
- * Flow input specification mapping node IDs to their input data.
- *
- * This type represents a map of input node IDs to their respective input data.
- * Each key is a node ID, and each value is the data to pass to that node.
- * The data structure depends on the node's registered input type.
- *
- * @remarks
- * Input data is validated against each node's registered type schema before
- * flow execution begins. Invalid data will result in validation errors.
- *
- * @example
- * ```typescript
- * // For streaming input node (init operation)
- * const fileUploadInputs: FlowInputs = {
- *   "input-node-1": {
- *     operation: "init",
- *     storageId: "my-storage",
- *     metadata: {
- *       originalName: "photo.jpg",
- *       mimeType: "image/jpeg",
- *       size: 1024000
- *     }
- *   }
- * };
- *
- * // For streaming input node (URL operation)
- * const urlInputs: FlowInputs = {
- *   "input-node-1": {
- *     operation: "url",
- *     url: "https://example.com/photo.jpg",
- *     storageId: "my-storage",
- *     metadata: {
- *       source: "external"
- *     }
- *   }
- * };
- * ```
- */
-type FlowInputs = Record<string, unknown>;
-/**
- * Helper type for single-input flows.
- *
- * Many flows have exactly one input node. This helper type makes it easier
- * to work with single-input scenarios without needing to know the node ID upfront.
- *
- * @example
- * ```typescript
- * const singleInput: SingleFlowInput = {
- *   operation: "url",
- *   url: "https://example.com/image.jpg"
- * };
- *
- * // The client can auto-discover the input node ID and convert this to FlowInputs
- * ```
- */
-type SingleFlowInput = unknown;
-/**
- * Result of input node discovery.
- *
- * Contains information about discovered input nodes in a flow, including
- * their IDs, types, and whether the flow has a single or multiple inputs.
- *
- * @property inputNodes - Array of input node information
- * @property single - True if flow has exactly one input node
+ * Complete state information for a flow upload operation.
+ * Tracks both the upload phase (file transfer) and processing phase (flow execution).
  */
-interface InputNodeDiscovery {
-  inputNodes: Array<{
-    id: string;
-    type: string;
-    name?: string;
-  }>;
-  single: boolean;
-}
-//#endregion
-//#region src/types/multi-flow-upload-options.d.ts
-interface MultiFlowUploadOptions<UploadInput$1> {
-  /**
-   * Flow configuration
-   */
-  flowConfig: FlowUploadConfig;
-  /**
-   * Maximum number of concurrent uploads (default: 3)
-   */
-  maxConcurrent?: number;
-  /**
-   * Called when an individual upload progresses
-   */
-  onItemProgress?: (item: FlowUploadItem<UploadInput$1>) => void;
-  /**
-   * Called when an individual upload succeeds
-   */
-  onItemSuccess?: (item: FlowUploadItem<UploadInput$1>) => void;
-  /**
-   * Called when an individual upload fails
-   */
-  onItemError?: (item: FlowUploadItem<UploadInput$1>, error: Error) => void;
-  /**
-   * Called when all uploads complete
-   */
-  onComplete?: (items: FlowUploadItem<UploadInput$1>[]) => void;
+interface FlowUploadState {
+  /** Current upload status */
+  status: FlowUploadStatus;
+  /** Upload progress percentage (0-100) */
+  progress: number;
+  /** Number of bytes uploaded */
+  bytesUploaded: number;
+  /** Total bytes to upload, null if unknown */
+  totalBytes: number | null;
+  /** Error if upload or processing failed */
+  error: Error | null;
+  /** Unique identifier for the flow execution job */
+  jobId: string | null;
+  /** Whether the flow processing has started */
+  flowStarted: boolean;
+  /** Name of the currently executing flow node */
+  currentNodeName: string | null;
+  /** Type of the currently executing flow node */
+  currentNodeType: string | null;
   /**
-   * Custom retry logic
+   * Complete typed outputs from all output nodes in the flow.
+   * Each output includes nodeId, optional nodeType, data, and timestamp.
+   * Available when status is "success".
    */
-  onShouldRetry?: (error: Error, retryAttempt: number) => boolean;
+  flowOutputs: TypedOutput[] | null;
 }
-//#endregion
-//#region src/types/multi-flow-upload-state.d.ts
-interface MultiFlowUploadState<UploadInput$1> {
-  items: FlowUploadItem<UploadInput$1>[];
-  totalProgress: number;
-  activeUploads: number;
-  completedUploads: number;
-  failedUploads: number;
+/**
+ * State for a single input in a multi-input flow.
+ */
+interface InputExecutionState {
+  /** Input node ID */
+  nodeId: string;
+  /** Input type (file, url, data) */
+  type: "file" | "url" | "data";
+  /** Current status of this input */
+  status: "pending" | "uploading" | "complete" | "error";
+  /** Progress percentage for file uploads (0-100) */
+  progress: number;
+  /** Bytes uploaded for file uploads */
+  bytesUploaded: number;
+  /** Total bytes for file uploads */
+  totalBytes: number | null;
+  /** Error if this input failed */
+  error: Error | null;
+  /** Abort controller for this specific input */
+  abortController: FlowUploadAbortController | null;
 }
-//#endregion
-//#region src/types/upload-options.d.ts
-interface UploadOptions {
-  /**
-   * Upload metadata to attach to the file
-   */
-  metadata?: Record<string, string>;
-  /**
-   * Whether to defer the upload size calculation
-   */
-  uploadLengthDeferred?: boolean;
+/**
+ * Callbacks that FlowManager invokes during the flow upload lifecycle
+ */
+interface FlowManagerCallbacks {
   /**
-   * Manual upload size override
+   * Called when the flow upload state changes
    */
-  uploadSize?: number;
+  onStateChange: (state: FlowUploadState) => void;
   /**
    * Called when upload progress updates
-   *
-   * @param uploadId - The unique identifier for this upload
-   * @param bytesUploaded - Number of bytes uploaded so far
-   * @param totalBytes - Total bytes to upload, null if unknown/deferred
+   * @param progress - Progress percentage (0-100)
+   * @param bytesUploaded - Number of bytes uploaded
+   * @param totalBytes - Total bytes to upload, null if unknown
    */
   onProgress?: (uploadId: string, bytesUploaded: number, totalBytes: number | null) => void;
   /**
    * Called when a chunk completes
-   *
-   * @param chunkSize - Size of the completed chunk in bytes
-   * @param bytesAccepted - Total bytes accepted by server so far
-   * @param bytesTotal - Total bytes to upload, null if unknown/deferred
+   * @param chunkSize - Size of the completed chunk
+   * @param bytesAccepted - Total bytes accepted so far
+   * @param bytesTotal - Total bytes to upload, null if unknown
    */
   onChunkComplete?: (chunkSize: number, bytesAccepted: number, bytesTotal: number | null) => void;
   /**
-   * Called when upload succeeds
+   * Called when the flow completes successfully (receives full flow outputs)
+   * Each output includes nodeId, optional nodeType (e.g., "storage-output-v1"), data, and timestamp.
    *
-   * @param result - The uploaded file result
+   * @param outputs - Array of typed outputs from all output nodes
+   *
+   * @example
+   * ```typescript
+   * onFlowComplete: (outputs) => {
+   *   for (const output of outputs) {
+   *     console.log(`${output.nodeId} (${output.nodeType}):`, output.data);
+   *   }
+   * }
+   * ```
    */
-  onSuccess?: (result: UploadFile$1) => void;
+  onFlowComplete?: (outputs: TypedOutput[]) => void;
   /**
-   * Called when upload fails
+   * Called when upload succeeds (receives typed outputs from all output nodes)
+   * Each output includes nodeId, optional nodeType (e.g., "storage-output-v1"), data, and timestamp.
    *
-   * @param error - The error that caused the failure
+   * @param outputs - Array of typed outputs from all output nodes
+   *
+   * @example
+   * ```typescript
+   * onSuccess: (outputs) => {
+   *   for (const output of outputs) {
+   *     console.log(`${output.nodeId} completed:`, output.data);
+   *   }
+   * }
+   * ```
    */
-  onError?: (error: Error) => void;
+  onSuccess?: (outputs: TypedOutput[]) => void;
   /**
-   * Called when upload is aborted
+   * Called when upload or flow processing fails with an error
+   * @param error - The error that occurred
    */
-  onAbort?: () => void;
+  onError?: (error: Error) => void;
   /**
-   * Custom retry logic
-   *
-   * @param error - The error that triggered the retry check
-   * @param retryAttempt - The current retry attempt number (0-indexed)
-   * @returns true to retry, false to fail
+   * Called when upload or flow is aborted
    */
-  onShouldRetry?: (error: Error, retryAttempt: number) => boolean;
+  onAbort?: () => void;
 }
-//#endregion
-//#region src/types/upload-metrics.d.ts
 /**
- * Comprehensive upload metrics interface
- *
- * Provides access to all performance metrics, insights, and network
- * statistics for upload monitoring and optimization.
- *
- * This interface is implemented by all framework packages (React, Vue, React Native)
- * to ensure consistent metrics API across platforms.
- *
- * @example React usage
- * ```tsx
- * const upload = useUpload();
- * const insights = upload.metrics.getInsights();
- * const metrics = upload.metrics.exportMetrics();
- * ```
- *
- * @example Vue usage
- * ```vue
- * <script setup>
- * const upload = useUpload();
- * const insights = upload.metrics.getInsights();
- * </script>
- * ```
+ * Generic flow execution input type - can be any value that the flow execution client accepts.
+ * Common types include File, Blob, string (for URLs), or structured data objects.
  *
- * @example React Native usage
- * ```tsx
- * const upload = useUpload();
- * const networkMetrics = upload.metrics.getNetworkMetrics();
- * ```
+ * @remarks
+ * The flexibility of this type enables different flow execution patterns:
+ * - File/Blob: Traditional chunked file upload with init/finalize operations
+ * - string (URL): Direct file fetch from external URL
+ * - object: Structured data for non-file input nodes (future)
  */
-interface UploadMetrics {
-  /**
-   * Get performance insights from the upload client
-   *
-   * Provides high-level analysis with recommendations for
-   * optimizing upload performance.
-   *
-   * @returns Performance insights including efficiency scores and recommendations
-   *
-   * @example
-   * ```typescript
-   * const insights = metrics.getInsights();
-   * console.log(`Efficiency: ${insights.overallEfficiency}%`);
-   * console.log(`Recommendations:`, insights.recommendations);
-   * ```
-   */
-  getInsights: () => PerformanceInsights;
-  /**
-   * Export detailed metrics from the upload client
-   *
-   * Returns comprehensive metrics including session data,
-   * per-chunk statistics, and performance insights.
-   *
-   * Useful for analytics, debugging, and performance monitoring.
-   *
-   * @returns Object containing session metrics, chunk metrics, and insights
-   *
-   * @example
-   * ```typescript
-   * const metrics = metrics.exportMetrics();
-   * console.log(`Uploaded ${metrics.session.totalBytesUploaded} bytes`);
-   * console.log(`Average speed: ${metrics.session.averageSpeed} B/s`);
-   * console.log(`Chunks: ${metrics.chunks.length}`);
-   * ```
-   */
-  exportMetrics: () => {
-    /** Session-level aggregated metrics */
-    session: Partial<UploadSessionMetrics>;
-    /** Per-chunk detailed metrics */
-    chunks: ChunkMetrics[];
-    /** Performance insights and recommendations */
-    insights: PerformanceInsights;
-  };
+type FlowUploadInput = unknown;
+/**
+ * Flow configuration for upload
+ */
+interface FlowConfig {
+  flowId: string;
+  storageId: string;
+  outputNodeId?: string;
+  metadata?: Record<string, string>;
+}
+/**
+ * Abort and pause controller interface for canceling/pausing flow uploads
+ */
+interface FlowUploadAbortController {
+  abort: () => void | Promise<void>;
+  pause: () => void | Promise<void>;
+}
+/**
+ * Internal upload options used by the flow upload function.
+ * The upload phase always returns UploadFile, regardless of the final TOutput type.
+ */
+interface InternalFlowUploadOptions {
+  onJobStart?: (jobId: string) => void;
+  onProgress?: (uploadId: string, bytesUploaded: number, totalBytes: number | null) => void;
+  onChunkComplete?: (chunkSize: number, bytesAccepted: number, bytesTotal: number | null) => void;
+  onSuccess?: (result: UploadFile) => void;
+  onError?: (error: Error) => void;
+  onAbort?: () => void;
+  onShouldRetry?: (error: Error, retryAttempt: number) => boolean;
+}
+/**
+ * Flow upload function that performs the actual upload with flow processing.
+ * Returns a promise that resolves to an abort controller with pause capability.
+ *
+ * Note: The upload phase onSuccess always receives UploadFile. The final TOutput
+ * result comes from the flow execution and is handled via FlowEnd events.
+ */
+type FlowUploadFunction<TInput = FlowUploadInput> = (input: TInput, flowConfig: FlowConfig, options: InternalFlowUploadOptions) => Promise<FlowUploadAbortController>;
+/**
+ * Callbacks for tracking individual input progress in multi-input flows
+ */
+interface MultiInputCallbacks {
   /**
-   * Get current network metrics
-   *
-   * Provides real-time network statistics including speed,
-   * errors, and network condition assessment.
-   *
-   * @returns Current network performance metrics
-   *
-   * @example
-   * ```typescript
-   * const network = metrics.getNetworkMetrics();
-   * console.log(`Speed: ${network.currentSpeed} B/s`);
-   * console.log(`Quality: ${network.condition.quality}`);
-   * ```
+   * Called when an input's progress updates
+   * @param nodeId - The input node ID
+   * @param progress - Progress percentage (0-100)
+   * @param bytesUploaded - Bytes uploaded for this input
+   * @param totalBytes - Total bytes for this input
    */
-  getNetworkMetrics: () => NetworkMetrics;
+  onInputProgress?: (nodeId: string, progress: number, bytesUploaded: number, totalBytes: number | null) => void;
   /**
-   * Get current network condition
-   *
-   * Provides assessment of current network quality with
-   * recommendations for adaptive upload strategies.
-   *
-   * @returns Network condition assessment
-   *
-   * @example
-   * ```typescript
-   * const condition = metrics.getNetworkCondition();
-   * if (condition.quality === 'poor') {
-   *   console.log('Consider reducing chunk size');
-   * }
-   * ```
+   * Called when an input completes successfully
+   * @param nodeId - The input node ID
    */
-  getNetworkCondition: () => NetworkCondition;
+  onInputComplete?: (nodeId: string) => void;
   /**
-   * Reset all metrics
-   *
-   * Clears all accumulated metrics and resets counters.
-   * Useful when starting a new upload session.
-   *
-   * @example
-   * ```typescript
-   * // Reset metrics before starting new upload
-   * metrics.resetMetrics();
-   * upload(newFile);
-   * ```
+   * Called when an input fails
+   * @param nodeId - The input node ID
+   * @param error - The error that occurred
    */
-  resetMetrics: () => void;
+  onInputError?: (nodeId: string, error: Error) => void;
 }
-//#endregion
-//#region src/types/upload-result.d.ts
 /**
- * Discriminated union representing the result of an upload operation.
- *
- * Provides a type-safe way to handle the three possible outcomes of an upload:
- * success, error, or cancellation. This pattern enables exhaustive checking
- * of all cases at compile time.
+ * Multi-input flow upload function that coordinates multiple inputs in a single flow.
+ * Platform packages should implement this to enable parallel multi-input upload support.
  *
- * @template TOutput - The type of the successful result value. Defaults to UploadFile
+ * @param inputs - Record of nodeId to input data (File, URL string, or structured data)
+ * @param flowConfig - Flow configuration
+ * @param options - Upload callbacks and configuration
+ * @param multiInputCallbacks - Per-input progress tracking callbacks
+ * @returns Promise resolving to abort controller for the entire flow execution
  *
- * @example Handling upload results
+ * @example
  * ```typescript
- * function handleUploadResult(result: UploadResult) {
- *   switch (result.type) {
- *     case 'success':
- *       console.log('Upload complete:', result.value.id);
- *       break;
- *     case 'error':
- *       console.error('Upload failed:', result.error.message);
- *       break;
- *     case 'cancelled':
- *       console.log('Upload was cancelled by user');
- *       break;
- *   }
- * }
+ * const uploadFn: MultiInputFlowUploadFunction = async (inputs, flowConfig, options, callbacks) => {
+ *   // 1. Start flow and create job
+ *   const jobId = await startFlow(flowConfig.flowId, flowConfig.storageId);
+ *
+ *   // 2. Initialize all inputs in parallel using orchestrator functions
+ *   const initPromises = Object.entries(inputs).map(([nodeId, data]) =>
+ *     initializeFlowInput({ nodeId, jobId, source: data, ... })
+ *   );
+ *
+ *   // 3. Upload files in parallel
+ *   // 4. Finalize all inputs
+ *   // 5. Return abort controller
+ * };
  * ```
+ */
+type MultiInputFlowUploadFunction = (inputs: Record<string, unknown>, flowConfig: FlowConfig, options: InternalFlowUploadOptions, multiInputCallbacks?: MultiInputCallbacks) => Promise<FlowUploadAbortController>;
+/**
+ * Platform-agnostic flow execution manager that handles flow state machine,
+ * progress tracking, flow event handling, error handling, abort, pause, reset, and retry logic.
  *
- * @example With custom output type
+ * Supports multiple input types through generic TInput parameter:
+ * - File/Blob: Chunked file upload with progress tracking
+ * - string (URL): Direct file fetch from external source
+ * - object: Structured data for custom input nodes
+ *
+ * Framework packages (React, Vue, React Native) should wrap this manager
+ * with framework-specific hooks/composables.
+ *
+ * @template TInput - The type of input data accepted by the flow (File, Blob, string, object, etc.)
+ *
+ * @example
  * ```typescript
- * interface ProcessedImage {
- *   url: string;
- *   width: number;
- *   height: number;
- * }
+ * // File upload flow
+ * const fileFlowManager = new FlowManager<File>(...);
+ * await fileFlowManager.upload(myFile);
  *
- * const result: UploadResult<ProcessedImage> = await uploadAndProcess(file);
+ * // URL fetch flow
+ * const urlFlowManager = new FlowManager<string>(...);
+ * await urlFlowManager.upload("https://example.com/image.jpg");
  *
- * if (result.type === 'success') {
- *   console.log(`Image processed: ${result.value.width}x${result.value.height}`);
- * }
+ * // Structured data flow
+ * const dataFlowManager = new FlowManager<{ text: string }>(...);
+ * await dataFlowManager.upload({ text: "Process this" });
  * ```
  */
-type UploadResult<TOutput = UploadFile$1> = {
-  /** Indicates the upload completed successfully */
-  type: "success";
-  /** The successful result value (e.g., upload metadata or processed output) */
-  value: TOutput;
-} | {
-  /** Indicates the upload failed with an error */
-  type: "error";
-  /** The error that caused the upload to fail */
-  error: Error;
-} | {
-  /** Indicates the upload was cancelled by the user or application */
-  type: "cancelled";
-};
-//#endregion
-//#region src/managers/event-subscription-manager.d.ts
-/**
- * Generic event type that the subscription manager can handle
- */
-interface GenericEvent {
-  type: string;
-  data?: unknown;
-}
-/**
- * Event handler callback function
- */
-type SubscriptionEventHandler<T = GenericEvent> = (event: T) => void;
-/**
- * Unsubscribe function returned from subscriptions
- */
-type UnsubscribeFunction = () => void;
-/**
- * Event source that provides subscription capabilities
- */
-interface EventSource<T = GenericEvent> {
+declare class FlowManager<TInput = FlowUploadInput> {
+  private readonly flowUploadFn;
+  private readonly callbacks;
+  private readonly options;
+  private readonly multiInputUploadFn?;
+  private state;
+  private abortController;
+  private inputStates;
+  /** Tracks the nodeId when executing a single-input flow via executeFlow() */
+  private currentSingleInputNodeId;
+  /**
+   * Create a new FlowManager
+   *
+   * @param flowUploadFn - Flow upload function to use for uploads
+   * @param callbacks - Callbacks to invoke during flow upload lifecycle
+   * @param options - Flow upload configuration options
+   * @param multiInputUploadFn - Optional multi-input upload function for executeFlow()
+   */
+  constructor(flowUploadFn: FlowUploadFunction<TInput>, callbacks: FlowManagerCallbacks, options: FlowUploadOptions, multiInputUploadFn?: MultiInputFlowUploadFunction | undefined);
+  /**
+   * Get the current flow upload state
+   */
+  getState(): FlowUploadState;
+  /**
+   * Check if an upload or flow is currently active
+   */
+  isUploading(): boolean;
+  /**
+   * Check if file upload is in progress
+   */
+  isUploadingFile(): boolean;
   /**
-   * Subscribe to events from this source
-   * @returns Unsubscribe function to clean up the subscription
+   * Check if flow processing is in progress
    */
-  subscribe(handler: SubscriptionEventHandler<T>): UnsubscribeFunction;
-}
-/**
- * Options for event filtering
- */
-interface EventFilterOptions {
+  isProcessing(): boolean;
   /**
-   * Filter events by type (exact match)
+   * Get the current job ID
    */
-  eventType?: string;
+  getJobId(): string | null;
   /**
-   * Filter events by upload/job ID
-   * If provided, only events with matching ID will be passed to the handler
+   * Update the internal state and notify callbacks
    */
-  uploadId?: string | null;
+  private updateState;
   /**
-   * Custom filter function for advanced filtering
-   * Return true to pass the event to the handler
+   * Handle flow events from the event subscription
+   * This method should be called by the framework wrapper when it receives flow events
+   *
+   * @param event - Flow event to process
    */
-  customFilter?: (event: GenericEvent) => boolean;
-}
-/**
- * Platform-agnostic event subscription manager that handles event filtering,
- * subscription tracking, and automatic cleanup.
- *
- * This manager simplifies event handling by:
- * - Filtering events by type and/or ID
- * - Tracking all active subscriptions
- * - Providing cleanup methods to unsubscribe from all events
- * - Supporting custom filter functions for advanced scenarios
- *
- * @example Basic event subscription
- * ```typescript
- * const manager = new EventSubscriptionManager(eventSource);
- *
- * manager.subscribe(
- *   (event) => console.log('Upload progress:', event),
- *   { eventType: 'UPLOAD_PROGRESS', uploadId: 'abc123' }
- * );
- *
- * // Clean up all subscriptions when done
- * manager.cleanup();
- * ```
- *
- * @example Multiple filtered subscriptions
- * ```typescript
- * const manager = new EventSubscriptionManager(eventSource);
- *
- * // Subscribe to progress events for specific upload
- * manager.subscribe(
- *   onProgress,
- *   { eventType: 'UPLOAD_PROGRESS', uploadId: currentUploadId }
- * );
- *
- * // Subscribe to error events for any upload
- * manager.subscribe(
- *   onError,
- *   { eventType: 'UPLOAD_ERROR' }
- * );
- *
- * // Subscribe to all events with custom filtering
- * manager.subscribe(
- *   onEvent,
- *   { customFilter: (e) => e.data?.priority === 'high' }
- * );
- * ```
- */
-declare class EventSubscriptionManager<T extends GenericEvent = GenericEvent> {
-  private readonly eventSource;
-  private subscriptions;
+  handleFlowEvent(event: FlowEvent): void;
   /**
-   * Create a new EventSubscriptionManager
+   * Handle upload progress events from the event subscription
+   * This method should be called by the framework wrapper when it receives upload progress events
    *
-   * @param eventSource - Source to subscribe to for events
+   * @param uploadId - The unique identifier for this upload
+   * @param bytesUploaded - Number of bytes uploaded
+   * @param totalBytes - Total bytes to upload, null if unknown
    */
-  constructor(eventSource: EventSource<T>);
+  handleUploadProgress(uploadId: string, bytesUploaded: number, totalBytes: number | null): void;
   /**
-   * Subscribe to events with optional filtering
+   * Execute a flow with the provided input data.
    *
-   * @param handler - Callback function to invoke when matching events occur
-   * @param filter - Optional filter options to narrow down which events trigger the handler
-   * @returns Unsubscribe function to remove this specific subscription
+   * The input type and execution behavior depends on the generic TInput type:
+   * - File/Blob: Initiates chunked upload with progress tracking
+   * - string (URL): Directly passes URL to flow for fetching
+   * - object: Passes structured data to flow input nodes
    *
-   * @example Subscribe to specific event type
+   * @param input - Input data for the flow execution (type determined by TInput generic)
+   *
+   * @example
    * ```typescript
-   * const unsubscribe = manager.subscribe(
-   *   (event) => console.log('Progress:', event),
-   *   { eventType: 'UPLOAD_PROGRESS' }
-   * );
+   * // File upload
+   * await manager.upload(fileObject);
    *
-   * // Later, unsubscribe
-   * unsubscribe();
+   * // URL fetch
+   * await manager.upload("https://example.com/image.jpg");
    * ```
    */
-  subscribe(handler: SubscriptionEventHandler<T>, filter?: EventFilterOptions): UnsubscribeFunction;
+  upload(input: TInput): Promise<void>;
   /**
-   * Check if an event matches the filter criteria
-   *
-   * @param event - Event to check
-   * @param filter - Filter options to apply
-   * @returns True if the event passes all filters
+   * Abort the current flow upload
    */
-  private shouldHandleEvent;
+  abort(): void;
   /**
-   * Get the number of active subscriptions
-   *
-   * @returns Number of tracked subscriptions
+   * Pause the current flow upload
    */
-  getSubscriptionCount(): number;
+  pause(): void;
   /**
-   * Check if there are any active subscriptions
-   *
-   * @returns True if at least one subscription is active
+   * Reset the flow upload state to idle
    */
-  hasSubscriptions(): boolean;
+  reset(): void;
   /**
-   * Unsubscribe from all tracked subscriptions and clear the subscription list
-   *
-   * This is typically called when disposing of a component or cleaning up resources.
+   * Aggregate progress across multiple inputs.
+   * Uses simple average for Phase 1 (size-weighted can be added in Phase 2).
+   */
+  private aggregateProgress;
+  /**
+   * Execute a flow with multiple inputs (generic execution path).
    *
-   * @example Cleanup in framework hooks
-   * ```typescript
-   * // React
-   * useEffect(() => {
-   *   const manager = new EventSubscriptionManager(eventSource);
-   *   manager.subscribe(handler, filter);
+   * This method:
+   * 1. Builds FlowInputs with auto-detection
+   * 2. Validates inputs (optional, to be added in integration)
+   * 3. Executes flow with the inputs
+   * 4. Tracks multi-input state
    *
-   *   return () => manager.cleanup();
-   * }, []);
+   * @param inputs - Map of nodeId to raw input data
    *
-   * // Vue
-   * onUnmounted(() => {
-   *   manager.cleanup();
+   * @example
+   * ```typescript
+   * await manager.executeFlow({
+   *   "file-input": myFile,
+   *   "url-input": "https://example.com/image.jpg"
    * });
    * ```
    */
+  executeFlow(inputs: Record<string, unknown>): Promise<void>;
+  /**
+   * Get the input execution states (for multi-input flows).
+   * @returns Map of nodeId to input state
+   */
+  getInputStates(): ReadonlyMap<string, InputExecutionState>;
+  /**
+   * Clean up resources (call when disposing the manager)
+   */
   cleanup(): void;
+}
+//#endregion
+//#region src/types/upload-options.d.ts
+interface UploadOptions {
   /**
-   * Update the upload ID filter for all subscriptions that have an uploadId filter
+   * Upload metadata to attach to the file
+   */
+  metadata?: Record<string, string>;
+  /**
+   * Whether to defer the upload size calculation
+   */
+  uploadLengthDeferred?: boolean;
+  /**
+   * Manual upload size override
+   */
+  uploadSize?: number;
+  /**
+   * Called when upload progress updates
    *
-   * This is useful when the current upload changes and you want to update
-   * all subscriptions to listen for the new upload's events.
+   * @param uploadId - The unique identifier for this upload
+   * @param bytesUploaded - Number of bytes uploaded so far
+   * @param totalBytes - Total bytes to upload, null if unknown/deferred
+   */
+  onProgress?: (uploadId: string, bytesUploaded: number, totalBytes: number | null) => void;
+  /**
+   * Called when a chunk completes
    *
-   * @param newUploadId - New upload ID to filter events by
+   * @param chunkSize - Size of the completed chunk in bytes
+   * @param bytesAccepted - Total bytes accepted by server so far
+   * @param bytesTotal - Total bytes to upload, null if unknown/deferred
+   */
+  onChunkComplete?: (chunkSize: number, bytesAccepted: number, bytesTotal: number | null) => void;
+  /**
+   * Called when upload succeeds
    *
-   * @example Update upload ID when starting new upload
-   * ```typescript
-   * const manager = new EventSubscriptionManager(eventSource);
-   * manager.subscribe(onProgress, { eventType: 'UPLOAD_PROGRESS', uploadId: null });
+   * @param result - The uploaded file result
+   */
+  onSuccess?: (result: UploadFile$1) => void;
+  /**
+   * Called when upload fails
    *
-   * // When upload starts
-   * manager.updateUploadIdFilter(uploadId);
-   * ```
+   * @param error - The error that caused the failure
    */
-  updateUploadIdFilter(newUploadId: string | null): void;
-}
-//#endregion
-//#region src/managers/flow-manager.d.ts
-/**
- * Flow upload status representing the current state of a flow upload lifecycle.
- * Flow uploads progress through: idle → uploading → processing → success/error/aborted
- */
-type FlowUploadStatus = "idle" | "uploading" | "processing" | "success" | "error" | "aborted";
-/**
- * Complete state information for a flow upload operation.
- * Tracks both the upload phase (file transfer) and processing phase (flow execution).
- */
-interface FlowUploadState {
-  /** Current upload status */
-  status: FlowUploadStatus;
-  /** Upload progress percentage (0-100) */
-  progress: number;
-  /** Number of bytes uploaded */
-  bytesUploaded: number;
-  /** Total bytes to upload, null if unknown */
-  totalBytes: number | null;
-  /** Error if upload or processing failed */
-  error: Error | null;
-  /** Unique identifier for the flow execution job */
-  jobId: string | null;
-  /** Whether the flow processing has started */
-  flowStarted: boolean;
-  /** Name of the currently executing flow node */
-  currentNodeName: string | null;
-  /** Type of the currently executing flow node */
-  currentNodeType: string | null;
+  onError?: (error: Error) => void;
+  /**
+   * Called when upload is aborted
+   */
+  onAbort?: () => void;
   /**
-   * Complete typed outputs from all output nodes in the flow.
-   * Each output includes nodeId, optional nodeType, data, and timestamp.
-   * Available when status is "success".
+   * Custom retry logic
+   *
+   * @param error - The error that triggered the retry check
+   * @param retryAttempt - The current retry attempt number (0-indexed)
+   * @returns true to retry, false to fail
    */
-  flowOutputs: TypedOutput[] | null;
+  onShouldRetry?: (error: Error, retryAttempt: number) => boolean;
 }
+//#endregion
+//#region src/managers/upload-manager.d.ts
 /**
- * State for a single input in a multi-input flow.
+ * Upload status representing the current state of an upload
  */
-interface InputExecutionState {
-  /** Input node ID */
-  nodeId: string;
-  /** Input type (file, url, data) */
-  type: "file" | "url" | "data";
-  /** Current status of this input */
-  status: "pending" | "uploading" | "complete" | "error";
-  /** Progress percentage for file uploads (0-100) */
+type UploadStatus = "idle" | "uploading" | "success" | "error" | "aborted";
+/**
+ * Complete upload state
+ */
+interface UploadState {
+  /** Current status of the upload */
+  status: UploadStatus;
+  /** Upload progress percentage (0-100) */
   progress: number;
-  /** Bytes uploaded for file uploads */
+  /** Number of bytes uploaded */
   bytesUploaded: number;
-  /** Total bytes for file uploads */
+  /** Total bytes to upload, null if unknown/deferred */
   totalBytes: number | null;
-  /** Error if this input failed */
+  /** Error if upload failed */
   error: Error | null;
-  /** Abort controller for this specific input */
-  abortController: FlowUploadAbortController | null;
+  /** Result if upload succeeded */
+  result: UploadFile | null;
 }
 /**
- * Callbacks that FlowManager invokes during the flow upload lifecycle
+ * Callbacks that UploadManager invokes during the upload lifecycle
  */
-interface FlowManagerCallbacks {
+interface UploadManagerCallbacks {
   /**
-   * Called when the flow upload state changes
+   * Called when the upload state changes
    */
-  onStateChange: (state: FlowUploadState) => void;
+  onStateChange: (state: UploadState) => void;
   /**
    * Called when upload progress updates
-   * @param progress - Progress percentage (0-100)
+   * @param uploadId - The unique identifier for this upload
    * @param bytesUploaded - Number of bytes uploaded
    * @param totalBytes - Total bytes to upload, null if unknown
    */
@@ -3526,452 +3502,476 @@ interface FlowManagerCallbacks {
    */
   onChunkComplete?: (chunkSize: number, bytesAccepted: number, bytesTotal: number | null) => void;
   /**
-   * Called when the flow completes successfully (receives full flow outputs)
-   * Each output includes nodeId, optional nodeType (e.g., "storage-output-v1"), data, and timestamp.
-   *
-   * @param outputs - Array of typed outputs from all output nodes
-   *
-   * @example
-   * ```typescript
-   * onFlowComplete: (outputs) => {
-   *   for (const output of outputs) {
-   *     console.log(`${output.nodeId} (${output.nodeType}):`, output.data);
-   *   }
-   * }
-   * ```
-   */
-  onFlowComplete?: (outputs: TypedOutput[]) => void;
-  /**
-   * Called when upload succeeds (receives typed outputs from all output nodes)
-   * Each output includes nodeId, optional nodeType (e.g., "storage-output-v1"), data, and timestamp.
-   *
-   * @param outputs - Array of typed outputs from all output nodes
-   *
-   * @example
-   * ```typescript
-   * onSuccess: (outputs) => {
-   *   for (const output of outputs) {
-   *     console.log(`${output.nodeId} completed:`, output.data);
-   *   }
-   * }
-   * ```
+   * Called when upload completes successfully
+   * @param result - The uploaded file result
    */
-  onSuccess?: (outputs: TypedOutput[]) => void;
+  onSuccess?: (result: UploadFile) => void;
   /**
-   * Called when upload or flow processing fails with an error
+   * Called when upload fails with an error
    * @param error - The error that occurred
    */
   onError?: (error: Error) => void;
   /**
-   * Called when upload or flow is aborted
+   * Called when upload is aborted
    */
   onAbort?: () => void;
 }
 /**
- * Generic flow execution input type - can be any value that the flow execution client accepts.
- * Common types include File, Blob, string (for URLs), or structured data objects.
- *
- * @remarks
- * The flexibility of this type enables different flow execution patterns:
- * - File/Blob: Traditional chunked file upload with init/finalize operations
- * - string (URL): Direct file fetch from external URL
- * - object: Structured data for non-file input nodes (future)
- */
-type FlowUploadInput = unknown;
-/**
- * Flow configuration for upload
- */
-interface FlowConfig {
-  flowId: string;
-  storageId: string;
-  outputNodeId?: string;
-  metadata?: Record<string, string>;
-}
-/**
- * Abort and pause controller interface for canceling/pausing flow uploads
- */
-interface FlowUploadAbortController {
-  abort: () => void | Promise<void>;
-  pause: () => void | Promise<void>;
-}
-/**
- * Internal upload options used by the flow upload function.
- * The upload phase always returns UploadFile, regardless of the final TOutput type.
- */
-interface InternalFlowUploadOptions {
-  onJobStart?: (jobId: string) => void;
-  onProgress?: (uploadId: string, bytesUploaded: number, totalBytes: number | null) => void;
-  onChunkComplete?: (chunkSize: number, bytesAccepted: number, bytesTotal: number | null) => void;
-  onSuccess?: (result: UploadFile) => void;
-  onError?: (error: Error) => void;
-  onAbort?: () => void;
-  onShouldRetry?: (error: Error, retryAttempt: number) => boolean;
-}
-/**
- * Flow upload function that performs the actual upload with flow processing.
- * Returns a promise that resolves to an abort controller with pause capability.
- *
- * Note: The upload phase onSuccess always receives UploadFile. The final TOutput
- * result comes from the flow execution and is handled via FlowEnd events.
+ * Generic upload input type - can be any value that the upload client accepts
  */
-type FlowUploadFunction<TInput = FlowUploadInput> = (input: TInput, flowConfig: FlowConfig, options: InternalFlowUploadOptions) => Promise<FlowUploadAbortController>;
+type UploadInput = unknown;
 /**
- * Callbacks for tracking individual input progress in multi-input flows
+ * Abort controller interface for canceling uploads
  */
-interface MultiInputCallbacks {
-  /**
-   * Called when an input's progress updates
-   * @param nodeId - The input node ID
-   * @param progress - Progress percentage (0-100)
-   * @param bytesUploaded - Bytes uploaded for this input
-   * @param totalBytes - Total bytes for this input
-   */
-  onInputProgress?: (nodeId: string, progress: number, bytesUploaded: number, totalBytes: number | null) => void;
-  /**
-   * Called when an input completes successfully
-   * @param nodeId - The input node ID
-   */
-  onInputComplete?: (nodeId: string) => void;
-  /**
-   * Called when an input fails
-   * @param nodeId - The input node ID
-   * @param error - The error that occurred
-   */
-  onInputError?: (nodeId: string, error: Error) => void;
+interface UploadAbortController {
+  abort: () => void;
 }
 /**
- * Multi-input flow upload function that coordinates multiple inputs in a single flow.
- * Platform packages should implement this to enable parallel multi-input upload support.
- *
- * @param inputs - Record of nodeId to input data (File, URL string, or structured data)
- * @param flowConfig - Flow configuration
- * @param options - Upload callbacks and configuration
- * @param multiInputCallbacks - Per-input progress tracking callbacks
- * @returns Promise resolving to abort controller for the entire flow execution
- *
- * @example
- * ```typescript
- * const uploadFn: MultiInputFlowUploadFunction = async (inputs, flowConfig, options, callbacks) => {
- *   // 1. Start flow and create job
- *   const jobId = await startFlow(flowConfig.flowId, flowConfig.storageId);
- *
- *   // 2. Initialize all inputs in parallel using orchestrator functions
- *   const initPromises = Object.entries(inputs).map(([nodeId, data]) =>
- *     initializeFlowInput({ nodeId, jobId, source: data, ... })
- *   );
- *
- *   // 3. Upload files in parallel
- *   // 4. Finalize all inputs
- *   // 5. Return abort controller
- * };
- * ```
+ * Upload function that performs the actual upload.
+ * Returns a promise that resolves to an abort controller.
  */
-type MultiInputFlowUploadFunction = (inputs: Record<string, unknown>, flowConfig: FlowConfig, options: InternalFlowUploadOptions, multiInputCallbacks?: MultiInputCallbacks) => Promise<FlowUploadAbortController>;
+type UploadFunction<TInput = UploadInput, TOptions extends UploadOptions = UploadOptions> = (input: TInput, options: TOptions) => Promise<UploadAbortController>;
 /**
- * Platform-agnostic flow execution manager that handles flow state machine,
- * progress tracking, flow event handling, error handling, abort, pause, reset, and retry logic.
- *
- * Supports multiple input types through generic TInput parameter:
- * - File/Blob: Chunked file upload with progress tracking
- * - string (URL): Direct file fetch from external source
- * - object: Structured data for custom input nodes
+ * Platform-agnostic upload manager that handles upload state machine,
+ * progress tracking, error handling, abort, reset, and retry logic.
  *
  * Framework packages (React, Vue, React Native) should wrap this manager
  * with framework-specific hooks/composables.
  *
- * @template TInput - The type of input data accepted by the flow (File, Blob, string, object, etc.)
- *
  * @example
  * ```typescript
- * // File upload flow
- * const fileFlowManager = new FlowManager<File>(...);
- * await fileFlowManager.upload(myFile);
- *
- * // URL fetch flow
- * const urlFlowManager = new FlowManager<string>(...);
- * await urlFlowManager.upload("https://example.com/image.jpg");
+ * const uploadFn = (input, options) => client.upload(input, options);
+ * const manager = new UploadManager(uploadFn, {
+ *   onStateChange: (state) => setState(state),
+ *   onProgress: (progress) => console.log(`${progress}%`),
+ *   onSuccess: (result) => console.log('Upload complete:', result),
+ *   onError: (error) => console.error('Upload failed:', error),
+ * });
  *
- * // Structured data flow
- * const dataFlowManager = new FlowManager<{ text: string }>(...);
- * await dataFlowManager.upload({ text: "Process this" });
+ * await manager.upload(file);
  * ```
  */
-declare class FlowManager<TInput = FlowUploadInput> {
-  private readonly flowUploadFn;
+declare class UploadManager<TInput = UploadInput, TOptions extends UploadOptions = UploadOptions> {
+  private readonly uploadFn;
   private readonly callbacks;
-  private readonly options;
-  private readonly multiInputUploadFn?;
+  private readonly options?;
   private state;
   private abortController;
-  private inputStates;
-  /** Tracks the nodeId when executing a single-input flow via executeFlow() */
-  private currentSingleInputNodeId;
+  private lastInput;
+  private uploadId;
   /**
-   * Create a new FlowManager
+   * Create a new UploadManager
    *
-   * @param flowUploadFn - Flow upload function to use for uploads
-   * @param callbacks - Callbacks to invoke during flow upload lifecycle
-   * @param options - Flow upload configuration options
-   * @param multiInputUploadFn - Optional multi-input upload function for executeFlow()
-   */
-  constructor(flowUploadFn: FlowUploadFunction<TInput>, callbacks: FlowManagerCallbacks, options: FlowUploadOptions, multiInputUploadFn?: MultiInputFlowUploadFunction | undefined);
-  /**
-   * Get the current flow upload state
-   */
-  getState(): FlowUploadState;
-  /**
-   * Check if an upload or flow is currently active
-   */
-  isUploading(): boolean;
-  /**
-   * Check if file upload is in progress
-   */
-  isUploadingFile(): boolean;
-  /**
-   * Check if flow processing is in progress
+   * @param uploadFn - Upload function to use for uploads
+   * @param callbacks - Callbacks to invoke during upload lifecycle
+   * @param options - Upload configuration options
    */
-  isProcessing(): boolean;
+  constructor(uploadFn: UploadFunction<TInput, TOptions>, callbacks: UploadManagerCallbacks, options?: TOptions | undefined);
   /**
-   * Get the current job ID
+   * Get the current upload state
    */
-  getJobId(): string | null;
+  getState(): UploadState;
   /**
-   * Update the internal state and notify callbacks
+   * Check if an upload is currently active
    */
-  private updateState;
+  isUploading(): boolean;
   /**
-   * Handle flow events from the event subscription
-   * This method should be called by the framework wrapper when it receives flow events
-   *
-   * @param event - Flow event to process
+   * Check if the upload can be retried
    */
-  handleFlowEvent(event: FlowEvent): void;
+  canRetry(): boolean;
   /**
-   * Handle upload progress events from the event subscription
-   * This method should be called by the framework wrapper when it receives upload progress events
-   *
-   * @param uploadId - The unique identifier for this upload
-   * @param bytesUploaded - Number of bytes uploaded
-   * @param totalBytes - Total bytes to upload, null if unknown
+   * Update the internal state and notify callbacks
    */
-  handleUploadProgress(uploadId: string, bytesUploaded: number, totalBytes: number | null): void;
+  private updateState;
   /**
-   * Execute a flow with the provided input data.
-   *
-   * The input type and execution behavior depends on the generic TInput type:
-   * - File/Blob: Initiates chunked upload with progress tracking
-   * - string (URL): Directly passes URL to flow for fetching
-   * - object: Passes structured data to flow input nodes
-   *
-   * @param input - Input data for the flow execution (type determined by TInput generic)
-   *
-   * @example
-   * ```typescript
-   * // File upload
-   * await manager.upload(fileObject);
+   * Start uploading a file or input
    *
-   * // URL fetch
-   * await manager.upload("https://example.com/image.jpg");
-   * ```
+   * @param input - File or input to upload (type depends on platform)
    */
   upload(input: TInput): Promise<void>;
   /**
-   * Abort the current flow upload
+   * Abort the current upload
    */
   abort(): void;
   /**
-   * Pause the current flow upload
-   */
-  pause(): void;
-  /**
-   * Reset the flow upload state to idle
+   * Reset the upload state to idle
    */
   reset(): void;
   /**
-   * Aggregate progress across multiple inputs.
-   * Uses simple average for Phase 1 (size-weighted can be added in Phase 2).
-   */
-  private aggregateProgress;
-  /**
-   * Execute a flow with multiple inputs (generic execution path).
-   *
-   * This method:
-   * 1. Builds FlowInputs with auto-detection
-   * 2. Validates inputs (optional, to be added in integration)
-   * 3. Executes flow with the inputs
-   * 4. Tracks multi-input state
-   *
-   * @param inputs - Map of nodeId to raw input data
-   *
-   * @example
-   * ```typescript
-   * await manager.executeFlow({
-   *   "file-input": myFile,
-   *   "url-input": "https://example.com/image.jpg"
-   * });
-   * ```
-   */
-  executeFlow(inputs: Record<string, unknown>): Promise<void>;
-  /**
-   * Get the input execution states (for multi-input flows).
-   * @returns Map of nodeId to input state
+   * Retry the last failed or aborted upload
    */
-  getInputStates(): ReadonlyMap<string, InputExecutionState>;
+  retry(): void;
   /**
    * Clean up resources (call when disposing the manager)
    */
   cleanup(): void;
 }
 //#endregion
-//#region src/managers/upload-manager.d.ts
+//#region src/storage/in-memory-storage-service.d.ts
 /**
- * Upload status representing the current state of an upload
+ * In-memory fallback storage service for Expo
+ * Used when AsyncStorage is not available or for testing
  */
-type UploadStatus = "idle" | "uploading" | "success" | "error" | "aborted";
+declare function createInMemoryStorageService(): StorageService;
+//#endregion
+//#region src/types/flow-inputs.d.ts
 /**
- * Complete upload state
+ * Type definitions for flexible flow input specifications.
+ *
+ * This module defines types for passing input data to flows with multiple input nodes.
+ * The FlowInputs type maps node IDs to their respective input data, enabling support
+ * for flows with single or multiple input points.
+ *
+ * @module types/flow-inputs
+ *
+ * @example
+ * ```typescript
+ * import type { FlowInputs } from "@uploadista/client-core";
+ *
+ * // Single input flow
+ * const inputs: FlowInputs = {
+ *   "file-input": {
+ *     operation: "url",
+ *     url: "https://example.com/image.jpg"
+ *   }
+ * };
+ *
+ * // Multi-input flow
+ * const multiInputs: FlowInputs = {
+ *   "file-input": {
+ *     operation: "init",
+ *     storageId: "s3",
+ *     metadata: { originalName: "image.jpg" }
+ *   },
+ *   "metadata-input": {
+ *     title: "My Image",
+ *     tags: ["photo", "landscape"]
+ *   }
+ * };
+ * ```
  */
-interface UploadState {
-  /** Current status of the upload */
-  status: UploadStatus;
-  /** Upload progress percentage (0-100) */
+/**
+ * Flow input specification mapping node IDs to their input data.
+ *
+ * This type represents a map of input node IDs to their respective input data.
+ * Each key is a node ID, and each value is the data to pass to that node.
+ * The data structure depends on the node's registered input type.
+ *
+ * @remarks
+ * Input data is validated against each node's registered type schema before
+ * flow execution begins. Invalid data will result in validation errors.
+ *
+ * @example
+ * ```typescript
+ * // For streaming input node (init operation)
+ * const fileUploadInputs: FlowInputs = {
+ *   "input-node-1": {
+ *     operation: "init",
+ *     storageId: "my-storage",
+ *     metadata: {
+ *       originalName: "photo.jpg",
+ *       mimeType: "image/jpeg",
+ *       size: 1024000
+ *     }
+ *   }
+ * };
+ *
+ * // For streaming input node (URL operation)
+ * const urlInputs: FlowInputs = {
+ *   "input-node-1": {
+ *     operation: "url",
+ *     url: "https://example.com/photo.jpg",
+ *     storageId: "my-storage",
+ *     metadata: {
+ *       source: "external"
+ *     }
+ *   }
+ * };
+ * ```
+ */
+type FlowInputs = Record<string, unknown>;
+/**
+ * Helper type for single-input flows.
+ *
+ * Many flows have exactly one input node. This helper type makes it easier
+ * to work with single-input scenarios without needing to know the node ID upfront.
+ *
+ * @example
+ * ```typescript
+ * const singleInput: SingleFlowInput = {
+ *   operation: "url",
+ *   url: "https://example.com/image.jpg"
+ * };
+ *
+ * // The client can auto-discover the input node ID and convert this to FlowInputs
+ * ```
+ */
+type SingleFlowInput = unknown;
+/**
+ * Result of input node discovery.
+ *
+ * Contains information about discovered input nodes in a flow, including
+ * their IDs, types, and whether the flow has a single or multiple inputs.
+ *
+ * @property inputNodes - Array of input node information
+ * @property single - True if flow has exactly one input node
+ */
+interface InputNodeDiscovery {
+  inputNodes: Array<{
+    id: string;
+    type: string;
+    name?: string;
+  }>;
+  single: boolean;
+}
+//#endregion
+//#region src/types/flow-result.d.ts
+type FlowResult<TOutput = UploadFile> = {
+  type: "success";
+  value: TOutput;
+} | {
+  type: "error";
+  error: Error;
+} | {
+  type: "cancelled";
+};
+//#endregion
+//#region src/types/flow-upload-item.d.ts
+/**
+ * Flow upload item for multi-flow-upload tracking
+ */
+interface FlowUploadItem<UploadInput$1> {
+  id: string;
+  file: UploadInput$1;
+  status: "pending" | "uploading" | "success" | "error" | "aborted";
   progress: number;
-  /** Number of bytes uploaded */
   bytesUploaded: number;
-  /** Total bytes to upload, null if unknown/deferred */
-  totalBytes: number | null;
-  /** Error if upload failed */
+  totalBytes: number;
   error: Error | null;
-  /** Result if upload succeeded */
-  result: UploadFile | null;
+  result: UploadFile$1 | null;
+  jobId: string | null;
 }
-/**
- * Callbacks that UploadManager invokes during the upload lifecycle
- */
-interface UploadManagerCallbacks {
+//#endregion
+//#region src/types/multi-flow-upload-options.d.ts
+interface MultiFlowUploadOptions<UploadInput$1> {
   /**
-   * Called when the upload state changes
+   * Flow configuration
    */
-  onStateChange: (state: UploadState) => void;
+  flowConfig: FlowUploadConfig;
   /**
-   * Called when upload progress updates
-   * @param uploadId - The unique identifier for this upload
-   * @param bytesUploaded - Number of bytes uploaded
-   * @param totalBytes - Total bytes to upload, null if unknown
+   * Maximum number of concurrent uploads (default: 3)
    */
-  onProgress?: (uploadId: string, bytesUploaded: number, totalBytes: number | null) => void;
+  maxConcurrent?: number;
   /**
-   * Called when a chunk completes
-   * @param chunkSize - Size of the completed chunk
-   * @param bytesAccepted - Total bytes accepted so far
-   * @param bytesTotal - Total bytes to upload, null if unknown
+   * Called when an individual upload progresses
+   */
+  onItemProgress?: (item: FlowUploadItem<UploadInput$1>) => void;
+  /**
+   * Called when an individual upload succeeds
    */
-  onChunkComplete?: (chunkSize: number, bytesAccepted: number, bytesTotal: number | null) => void;
+  onItemSuccess?: (item: FlowUploadItem<UploadInput$1>) => void;
   /**
-   * Called when upload completes successfully
-   * @param result - The uploaded file result
+   * Called when an individual upload fails
    */
-  onSuccess?: (result: UploadFile) => void;
+  onItemError?: (item: FlowUploadItem<UploadInput$1>, error: Error) => void;
   /**
-   * Called when upload fails with an error
-   * @param error - The error that occurred
+   * Called when all uploads complete
    */
-  onError?: (error: Error) => void;
+  onComplete?: (items: FlowUploadItem<UploadInput$1>[]) => void;
   /**
-   * Called when upload is aborted
+   * Custom retry logic
    */
-  onAbort?: () => void;
+  onShouldRetry?: (error: Error, retryAttempt: number) => boolean;
 }
-/**
- * Generic upload input type - can be any value that the upload client accepts
- */
-type UploadInput = unknown;
-/**
- * Abort controller interface for canceling uploads
- */
-interface UploadAbortController {
-  abort: () => void;
+//#endregion
+//#region src/types/multi-flow-upload-state.d.ts
+interface MultiFlowUploadState<UploadInput$1> {
+  items: FlowUploadItem<UploadInput$1>[];
+  totalProgress: number;
+  activeUploads: number;
+  completedUploads: number;
+  failedUploads: number;
 }
+//#endregion
+//#region src/types/upload-metrics.d.ts
 /**
- * Upload function that performs the actual upload.
- * Returns a promise that resolves to an abort controller.
- */
-type UploadFunction<TInput = UploadInput, TOptions extends UploadOptions = UploadOptions> = (input: TInput, options: TOptions) => Promise<UploadAbortController>;
-/**
- * Platform-agnostic upload manager that handles upload state machine,
- * progress tracking, error handling, abort, reset, and retry logic.
+ * Comprehensive upload metrics interface
  *
- * Framework packages (React, Vue, React Native) should wrap this manager
- * with framework-specific hooks/composables.
+ * Provides access to all performance metrics, insights, and network
+ * statistics for upload monitoring and optimization.
  *
- * @example
- * ```typescript
- * const uploadFn = (input, options) => client.upload(input, options);
- * const manager = new UploadManager(uploadFn, {
- *   onStateChange: (state) => setState(state),
- *   onProgress: (progress) => console.log(`${progress}%`),
- *   onSuccess: (result) => console.log('Upload complete:', result),
- *   onError: (error) => console.error('Upload failed:', error),
- * });
+ * This interface is implemented by all framework packages (React, Vue, React Native)
+ * to ensure consistent metrics API across platforms.
  *
- * await manager.upload(file);
+ * @example React usage
+ * ```tsx
+ * const upload = useUpload();
+ * const insights = upload.metrics.getInsights();
+ * const metrics = upload.metrics.exportMetrics();
+ * ```
+ *
+ * @example Vue usage
+ * ```vue
+ * <script setup>
+ * const upload = useUpload();
+ * const insights = upload.metrics.getInsights();
+ * </script>
+ * ```
+ *
+ * @example React Native usage
+ * ```tsx
+ * const upload = useUpload();
+ * const networkMetrics = upload.metrics.getNetworkMetrics();
  * ```
  */
-declare class UploadManager<TInput = UploadInput, TOptions extends UploadOptions = UploadOptions> {
-  private readonly uploadFn;
-  private readonly callbacks;
-  private readonly options?;
-  private state;
-  private abortController;
-  private lastInput;
-  private uploadId;
+interface UploadMetrics {
   /**
-   * Create a new UploadManager
+   * Get performance insights from the upload client
    *
-   * @param uploadFn - Upload function to use for uploads
-   * @param callbacks - Callbacks to invoke during upload lifecycle
-   * @param options - Upload configuration options
-   */
-  constructor(uploadFn: UploadFunction<TInput, TOptions>, callbacks: UploadManagerCallbacks, options?: TOptions | undefined);
-  /**
-   * Get the current upload state
-   */
-  getState(): UploadState;
-  /**
-   * Check if an upload is currently active
-   */
-  isUploading(): boolean;
-  /**
-   * Check if the upload can be retried
-   */
-  canRetry(): boolean;
-  /**
-   * Update the internal state and notify callbacks
-   */
-  private updateState;
-  /**
-   * Start uploading a file or input
+   * Provides high-level analysis with recommendations for
+   * optimizing upload performance.
    *
-   * @param input - File or input to upload (type depends on platform)
+   * @returns Performance insights including efficiency scores and recommendations
+   *
+   * @example
+   * ```typescript
+   * const insights = metrics.getInsights();
+   * console.log(`Efficiency: ${insights.overallEfficiency}%`);
+   * console.log(`Recommendations:`, insights.recommendations);
+   * ```
    */
-  upload(input: TInput): Promise<void>;
+  getInsights: () => PerformanceInsights;
   /**
-   * Abort the current upload
+   * Export detailed metrics from the upload client
+   *
+   * Returns comprehensive metrics including session data,
+   * per-chunk statistics, and performance insights.
+   *
+   * Useful for analytics, debugging, and performance monitoring.
+   *
+   * @returns Object containing session metrics, chunk metrics, and insights
+   *
+   * @example
+   * ```typescript
+   * const metrics = metrics.exportMetrics();
+   * console.log(`Uploaded ${metrics.session.totalBytesUploaded} bytes`);
+   * console.log(`Average speed: ${metrics.session.averageSpeed} B/s`);
+   * console.log(`Chunks: ${metrics.chunks.length}`);
+   * ```
    */
-  abort(): void;
+  exportMetrics: () => {
+    /** Session-level aggregated metrics */
+    session: Partial<UploadSessionMetrics>;
+    /** Per-chunk detailed metrics */
+    chunks: ChunkMetrics[];
+    /** Performance insights and recommendations */
+    insights: PerformanceInsights;
+  };
   /**
-   * Reset the upload state to idle
+   * Get current network metrics
+   *
+   * Provides real-time network statistics including speed,
+   * errors, and network condition assessment.
+   *
+   * @returns Current network performance metrics
+   *
+   * @example
+   * ```typescript
+   * const network = metrics.getNetworkMetrics();
+   * console.log(`Speed: ${network.currentSpeed} B/s`);
+   * console.log(`Quality: ${network.condition.quality}`);
+   * ```
    */
-  reset(): void;
+  getNetworkMetrics: () => NetworkMetrics;
   /**
-   * Retry the last failed or aborted upload
+   * Get current network condition
+   *
+   * Provides assessment of current network quality with
+   * recommendations for adaptive upload strategies.
+   *
+   * @returns Network condition assessment
+   *
+   * @example
+   * ```typescript
+   * const condition = metrics.getNetworkCondition();
+   * if (condition.quality === 'poor') {
+   *   console.log('Consider reducing chunk size');
+   * }
+   * ```
    */
-  retry(): void;
+  getNetworkCondition: () => NetworkCondition;
   /**
-   * Clean up resources (call when disposing the manager)
+   * Reset all metrics
+   *
+   * Clears all accumulated metrics and resets counters.
+   * Useful when starting a new upload session.
+   *
+   * @example
+   * ```typescript
+   * // Reset metrics before starting new upload
+   * metrics.resetMetrics();
+   * upload(newFile);
+   * ```
    */
-  cleanup(): void;
+  resetMetrics: () => void;
 }
 //#endregion
+//#region src/types/upload-result.d.ts
+/**
+ * Discriminated union representing the result of an upload operation.
+ *
+ * Provides a type-safe way to handle the three possible outcomes of an upload:
+ * success, error, or cancellation. This pattern enables exhaustive checking
+ * of all cases at compile time.
+ *
+ * @template TOutput - The type of the successful result value. Defaults to UploadFile
+ *
+ * @example Handling upload results
+ * ```typescript
+ * function handleUploadResult(result: UploadResult) {
+ *   switch (result.type) {
+ *     case 'success':
+ *       console.log('Upload complete:', result.value.id);
+ *       break;
+ *     case 'error':
+ *       console.error('Upload failed:', result.error.message);
+ *       break;
+ *     case 'cancelled':
+ *       console.log('Upload was cancelled by user');
+ *       break;
+ *   }
+ * }
+ * ```
+ *
+ * @example With custom output type
+ * ```typescript
+ * interface ProcessedImage {
+ *   url: string;
+ *   width: number;
+ *   height: number;
+ * }
+ *
+ * const result: UploadResult<ProcessedImage> = await uploadAndProcess(file);
+ *
+ * if (result.type === 'success') {
+ *   console.log(`Image processed: ${result.value.width}x${result.value.height}`);
+ * }
+ * ```
+ */
+type UploadResult<TOutput = UploadFile$1> = {
+  /** Indicates the upload completed successfully */
+  type: "success";
+  /** The successful result value (e.g., upload metadata or processed output) */
+  value: TOutput;
+} | {
+  /** Indicates the upload failed with an error */
+  type: "error";
+  /** The error that caused the upload to fail */
+  error: Error;
+} | {
+  /** Indicates the upload was cancelled by the user or application */
+  type: "cancelled";
+};
+//#endregion
 export { AbortControllerFactory, AbortControllerLike, AbortSignalLike, Base64Service, ChecksumService, ChunkBuffer, ChunkBufferConfig, ChunkMetrics, ClientStorage, ConnectionHealth, ConnectionMetrics, ConnectionPoolConfig, DetailedConnectionMetrics, type EventFilterOptions, type EventSource, EventSubscriptionManager, FileReaderService, FileSource, FingerprintService, type FlowConfig, FlowInputs, FlowManager, type FlowManagerCallbacks, FlowResponse, FlowResult, type FlowUploadAbortController, FlowUploadConfig, type FlowUploadFunction, type FlowUploadInput, FlowUploadItem, FlowUploadOptions, type FlowUploadState, type FlowUploadStatus, type GenericEvent, HeadersLike, Http2Info, HttpClient, HttpRequestOptions, HttpResponse, IdGenerationService, type InputExecutionState, InputNodeDiscovery, type InternalFlowUploadOptions, LogFunction, Logger, MultiFlowUploadOptions, MultiFlowUploadState, type MultiInputCallbacks, type MultiInputFlowUploadFunction, NetworkCondition, NetworkMetrics, NetworkMonitor, NetworkMonitorConfig, PerformanceInsights, PlatformService, PreviousUpload, RequestBody, ServiceContainer, SingleFlowInput, SliceResult, StorageService, type SubscriptionEventHandler, Timeout, type UnsubscribeFunction, type UploadAbortController, type UploadFunction, type UploadInput, UploadManager, type UploadManagerCallbacks, UploadMetrics, UploadOptions, UploadResponse, UploadResult, UploadSample, UploadSessionMetrics, type UploadState, type UploadStatus, UploadistaApi, UploadistaClient, UploadistaClientOptions, UploadistaDeleteUploadResponse, UploadistaError, UploadistaErrorName, UploadistaEvent, UploadistaUploadOptions, UploadistaUploadResponse, UploadistaWebSocketEventHandler, UploadistaWebSocketManager, UploadistaWebSocketMessage, WebSocketEventMap, WebSocketFactory, WebSocketLike, createClientStorage, createInMemoryStorageService, createLogger, createUploadistaApi, createUploadistaClient, defaultConnectionPoolingConfig, previousUploadSchema, wait };
 //# sourceMappingURL=index.d.mts.map