@uploadista/vue 0.0.20-beta.9 → 0.1.0-beta.5

package/dist/{index-DiRR_Ua6.d.mts → index-RY4FPqAk.d.mts}

@@ -1,305 +1,213 @@
 import * as vue1 from "vue";
 import { App, InjectionKey, Ref } from "vue";
-import { FlowEvent, FlowEventFlowCancel, FlowEventFlowEnd, FlowEventFlowError, FlowEventFlowPause, FlowEventFlowStart, FlowEventJobEnd, FlowEventJobStart, FlowEventNodeEnd, FlowEventNodeError, FlowEventNodePause, FlowEventNodeResume, FlowEventNodeStart } from "@uploadista/core/flow";
-import { UploadEvent, UploadFile } from "@uploadista/core/types";
 import * as _uploadista_client_browser0 from "@uploadista/client-browser";
 import { BrowserUploadInput, ChunkMetrics, ChunkMetrics as ChunkMetrics$1, FlowUploadOptions, MultiFlowUploadOptions, PerformanceInsights, PerformanceInsights as PerformanceInsights$1, UploadOptions, UploadSessionMetrics, UploadSessionMetrics as UploadSessionMetrics$1, UploadistaClientOptions, UploadistaEvent, createUploadistaClient } from "@uploadista/client-browser";
+import { FlowEvent, FlowEventFlowCancel, FlowEventFlowEnd, FlowEventFlowError, FlowEventFlowPause, FlowEventFlowStart, FlowEventJobEnd, FlowEventJobStart, FlowEventNodeEnd, FlowEventNodeError, FlowEventNodePause, FlowEventNodeResume, FlowEventNodeStart } from "@uploadista/core/flow";
+import { UploadEvent, UploadFile } from "@uploadista/core/types";
 import * as _uploadista_client_core0 from "@uploadista/client-core";
 import { FlowUploadState, FlowUploadStatus as FlowUploadStatus$1, InputExecutionState, UploadMetrics, UploadOptions as UploadOptions$1, UploadState, UploadStatus } from "@uploadista/client-core";
 import * as _uploadista_core0 from "@uploadista/core";
 
-//#region src/composables/eventUtils.d.ts
+//#region src/composables/useFlow.d.ts
 /**
- * Type guard to check if an event is a flow event
+ * Input metadata discovered from the flow
  */
-declare function isFlowEvent(event: UploadistaEvent): event is FlowEvent;
+interface FlowInputMetadata {
+  /** Input node ID */
+  nodeId: string;
+  /** Human-readable node name */
+  nodeName: string;
+  /** Node description explaining what input is needed */
+  nodeDescription: string;
+  /** Input type ID from inputTypeRegistry - describes how clients interact with this node */
+  inputTypeId?: string;
+  /** Whether this input is required */
+  required: boolean;
+}
 /**
- * Type guard to check if an event is an upload event
+ * Return value from the useFlow composable with upload control methods and state.
+ *
+ * @property state - Complete flow upload state with progress and outputs
+ * @property inputMetadata - Metadata about discovered input nodes (null until discovered)
+ * @property inputStates - Per-input execution state for multi-input flows
+ * @property inputs - Current input values set via setInput()
+ * @property setInput - Set an input value for a specific node (for progressive provision)
+ * @property execute - Execute the flow with current inputs (auto-detects types)
+ * @property upload - Convenience method for single-file upload (same as execute with one file input)
+ * @property abort - Cancel the current upload and flow execution
+ * @property pause - Pause the current upload
+ * @property reset - Reset state to idle (clears all data)
+ * @property isUploading - True when upload or processing is active
+ * @property isUploadingFile - True only during file upload phase
+ * @property isProcessing - True only during flow processing phase
+ * @property isDiscoveringInputs - True while discovering flow inputs
  */
-declare function isUploadEvent(event: UploadistaEvent): event is UploadEvent;
-//#endregion
-//#region src/composables/useUploadistaEvents.d.ts
+interface UseFlowReturn {
+  /**
+   * Current upload state
+   */
+  state: Readonly<Ref<FlowUploadState>>;
+  /**
+   * Discovered input nodes metadata (null until discovery completes)
+   */
+  inputMetadata: Readonly<Ref<FlowInputMetadata[] | null>>;
+  /**
+   * Per-input execution state for multi-input flows
+   */
+  inputStates: Readonly<Ref<ReadonlyMap<string, InputExecutionState>>>;
+  /**
+   * Current inputs set via setInput()
+   */
+  inputs: Readonly<Ref<Record<string, unknown>>>;
+  /**
+   * Set an input value for a specific node.
+   * For progressive input provision before calling execute().
+   *
+   * @param nodeId - The input node ID
+   * @param value - The input value (File, URL string, or structured data)
+   */
+  setInput: (nodeId: string, value: unknown) => void;
+  /**
+   * Execute the flow with current inputs.
+   * Automatically detects input types and routes appropriately.
+   * For single input, uses standard upload path.
+   * For multiple inputs, requires multiInputUploadFn.
+   */
+  execute: () => Promise<void>;
+  /**
+   * Upload a single file through the flow (convenience method).
+   * Equivalent to setInput(firstNodeId, file) + execute().
+   *
+   * @param file - File or Blob to upload
+   */
+  upload: (file: File | Blob) => Promise<void>;
+  /**
+   * Abort the current upload
+   */
+  abort: () => void;
+  /**
+   * Pause the current upload
+   */
+  pause: () => void;
+  /**
+   * Reset the upload state and clear all inputs
+   */
+  reset: () => void;
+  /**
+   * Whether an upload or flow execution is in progress (uploading OR processing)
+   */
+  isUploading: Readonly<Ref<boolean>>;
+  /**
+   * Whether the file is currently being uploaded (chunks being sent)
+   */
+  isUploadingFile: Readonly<Ref<boolean>>;
+  /**
+   * Whether the flow is currently processing (after upload completes)
+   */
+  isProcessing: Readonly<Ref<boolean>>;
+  /**
+   * Whether the hook is discovering flow inputs
+   */
+  isDiscoveringInputs: Readonly<Ref<boolean>>;
+}
 /**
- * Simple composable that subscribes to all Uploadista events (both flow and upload events).
+ * Vue composable for executing flows with single or multiple inputs.
+ * Automatically discovers input nodes and detects input types (File, URL, structured data).
+ * Supports progressive input provision via setInput() and execute().
  *
- * This is a low-level composable that provides access to all events. For more structured
- * event handling, consider using `useFlowEvents` or `useUploadEvents` instead.
+ * This is the unified flow composable that replaces useFlowUpload for advanced use cases.
+ * It provides:
+ * - Auto-discovery of flow input nodes
+ * - Automatic input type detection (file -> upload, string -> URL, object -> data)
+ * - Progressive input provision via setInput()
+ * - Multi-input support with parallel coordination
+ * - Per-input state tracking
  *
- * Must be used within UploadistaProvider.
+ * Must be used within FlowManagerProvider (which must be within UploadistaProvider).
+ * Flow events are automatically routed by the provider to the appropriate manager.
  *
- * @param callback - Function called for every event emitted by the Uploadista client
+ * @param options - Flow upload configuration including flow ID and event handlers
+ * @returns Flow upload state and control methods
  *
  * @example
  * ```vue
  * <script setup lang="ts">
- * import { useUploadistaEvents, isFlowEvent, isUploadEvent } from '@uploadista/vue';
+ * import { useFlow } from '@uploadista/vue';
  *
- * useUploadistaEvents((event) => {
- *   if (isFlowEvent(event)) {
- *     console.log('Flow event:', event.eventType);
- *   } else if (isUploadEvent(event)) {
- *     console.log('Upload event:', event.type);
- *   }
+ * // Single file upload (simple case)
+ * const flow = useFlow({
+ *   flowConfig: {
+ *     flowId: "image-optimization",
+ *     storageId: "s3-images",
+ *   },
+ *   onSuccess: (outputs) => {
+ *     console.log("Flow outputs:", outputs);
+ *   },
  * });
+ *
+ * const handleFileChange = (event: Event) => {
+ *   const file = (event.target as HTMLInputElement).files?.[0];
+ *   if (file) flow.upload(file);
+ * };
  * </script>
  *
  * <template>
- *   <div>Listening to all events...</div>
+ *   <div>
+ *     <input type="file" @change="handleFileChange" />
+ *     <div v-if="flow.isUploading.value">Progress: {{ flow.state.value.progress }}%</div>
+ *   </div>
  * </template>
  * ```
- */
-declare function useUploadistaEvents(callback: (event: UploadistaEvent) => void): void;
-//#endregion
-//#region src/composables/useFlowEvents.d.ts
-/**
- * Options for handling flow execution events.
- *
- * All callbacks are optional - only provide handlers for events you care about.
- */
-interface UseFlowEventsOptions {
-  /** Called when a job starts execution */
-  onJobStart?: (event: FlowEventJobStart) => void;
-  /** Called when a job completes (success or failure) */
-  onJobEnd?: (event: FlowEventJobEnd) => void;
-  /** Called when a flow begins execution */
-  onFlowStart?: (event: FlowEventFlowStart) => void;
-  /** Called when a flow completes successfully */
-  onFlowEnd?: (event: FlowEventFlowEnd) => void;
-  /** Called when a flow encounters an error */
-  onFlowError?: (event: FlowEventFlowError) => void;
-  /** Called when a flow is paused by user request */
-  onFlowPause?: (event: FlowEventFlowPause) => void;
-  /** Called when a flow is cancelled by user request */
-  onFlowCancel?: (event: FlowEventFlowCancel) => void;
-  /** Called when a node starts processing */
-  onNodeStart?: (event: FlowEventNodeStart) => void;
-  /** Called when a node completes successfully */
-  onNodeEnd?: (event: FlowEventNodeEnd) => void;
-  /** Called when a node pauses (waiting for additional data) */
-  onNodePause?: (event: FlowEventNodePause) => void;
-  /** Called when a paused node resumes execution */
-  onNodeResume?: (event: FlowEventNodeResume) => void;
-  /** Called when a node encounters an error */
-  onNodeError?: (event: FlowEventNodeError) => void;
-}
-/**
- * Structured composable for handling flow execution events with type-safe callbacks.
- *
- * This composable provides a clean API for listening to specific flow events without
- * needing to manually filter events or use type guards.
- *
- * Must be used within UploadistaProvider.
- *
- * @param options - Object with optional callbacks for each flow event type
  *
  * @example
  * ```vue
  * <script setup lang="ts">
- * import { useFlowEvents } from '@uploadista/vue';
+ * import { useFlow } from '@uploadista/vue';
  *
- * useFlowEvents({
- *   onFlowStart: (event) => {
- *     console.log('Flow started:', event.flowId);
- *   },
- *   onNodeStart: (event) => {
- *     console.log('Node started:', event.nodeName);
- *   },
- *   onNodeEnd: (event) => {
- *     console.log('Node completed:', event.nodeName, event.result);
- *   },
- *   onFlowEnd: (event) => {
- *     console.log('Flow completed with outputs:', event.outputs);
- *   },
- *   onFlowError: (event) => {
- *     console.error('Flow failed:', event.error);
+ * // Multi-input with progressive provision
+ * const flow = useFlow({
+ *   flowConfig: {
+ *     flowId: "multi-source-processing",
+ *     storageId: "default",
  *   },
  * });
+ *
+ * const handleInputChange = (nodeId: string, event: Event) => {
+ *   const target = event.target as HTMLInputElement;
+ *   if (target.type === 'file') {
+ *     const file = target.files?.[0];
+ *     if (file) flow.setInput(nodeId, file);
+ *   } else {
+ *     flow.setInput(nodeId, target.value);
+ *   }
+ * };
  * </script>
  *
  * <template>
- *   <div>Monitoring flow execution...</div>
+ *   <div v-if="flow.inputMetadata.value">
+ *     <div v-for="input in flow.inputMetadata.value" :key="input.nodeId">
+ *       <label>{{ input.nodeName }}</label>
+ *       <input
+ *         v-if="input.inputTypeId === 'streaming-input-v1'"
+ *         type="file"
+ *         @change="(e) => handleInputChange(input.nodeId, e)"
+ *       />
+ *       <input
+ *         v-else
+ *         type="url"
+ *         @change="(e) => handleInputChange(input.nodeId, e)"
+ *       />
+ *     </div>
+ *     <button @click="flow.execute" :disabled="flow.isUploading.value">
+ *       Execute Flow
+ *     </button>
+ *   </div>
  * </template>
  * ```
+ *
+ * @see {@link useFlowUpload} for a simpler file-only upload composable
  */
-declare function useFlowEvents(options: UseFlowEventsOptions): void;
-//#endregion
-//#region src/composables/useUploadEvents.d.ts
-/**
- * Upload progress event data
- */
-interface UploadProgressEventData {
-  id: string;
-  progress: number;
-  total: number;
-  flow?: {
-    flowId: string;
-    nodeId: string;
-    jobId: string;
-  };
-}
-/**
- * Upload started/complete event data (contains full UploadFile)
- */
-interface UploadFileEventData {
-  [key: string]: unknown;
-  flow?: {
-    flowId: string;
-    nodeId: string;
-    jobId: string;
-  };
-}
-/**
- * Upload failed event data
- */
-interface UploadFailedEventData {
-  id: string;
-  error: string;
-  flow?: {
-    flowId: string;
-    nodeId: string;
-    jobId: string;
-  };
-}
-/**
- * Upload validation success event data
- */
-interface UploadValidationSuccessEventData {
-  id: string;
-  validationType: "checksum" | "mimetype";
-  algorithm?: string;
-  flow?: {
-    flowId: string;
-    nodeId: string;
-    jobId: string;
-  };
-}
-/**
- * Upload validation failed event data
- */
-interface UploadValidationFailedEventData {
-  id: string;
-  reason: string;
-  expected: string;
-  actual: string;
-  flow?: {
-    flowId: string;
-    nodeId: string;
-    jobId: string;
-  };
-}
-/**
- * Upload validation warning event data
- */
-interface UploadValidationWarningEventData {
-  id: string;
-  message: string;
-  flow?: {
-    flowId: string;
-    nodeId: string;
-    jobId: string;
-  };
-}
-/**
- * Options for handling upload events.
- *
- * All callbacks are optional - only provide handlers for events you care about.
- */
-interface UseUploadEventsOptions {
-  /** Called when an upload starts */
-  onUploadStarted?: (data: UploadFileEventData) => void;
-  /** Called with upload progress updates */
-  onUploadProgress?: (data: UploadProgressEventData) => void;
-  /** Called when an upload completes successfully */
-  onUploadComplete?: (data: UploadFileEventData) => void;
-  /** Called when an upload fails */
-  onUploadFailed?: (data: UploadFailedEventData) => void;
-  /** Called when upload validation succeeds */
-  onUploadValidationSuccess?: (data: UploadValidationSuccessEventData) => void;
-  /** Called when upload validation fails */
-  onUploadValidationFailed?: (data: UploadValidationFailedEventData) => void;
-  /** Called when upload validation produces a warning */
-  onUploadValidationWarning?: (data: UploadValidationWarningEventData) => void;
-}
-/**
- * Structured composable for handling upload events with type-safe callbacks.
- *
- * This composable provides a clean API for listening to specific upload events without
- * needing to manually filter events or use type guards.
- *
- * Must be used within UploadistaProvider.
- *
- * @param options - Object with optional callbacks for each upload event type
- *
- * @example
- * ```vue
- * <script setup lang="ts">
- * import { useUploadEvents } from '@uploadista/vue';
- *
- * useUploadEvents({
- *   onUploadStarted: (data) => {
- *     console.log('Upload started:', data.id);
- *   },
- *   onUploadProgress: (data) => {
- *     const percent = (data.progress / data.total) * 100;
- *     console.log(`Upload progress: ${percent}%`);
- *   },
- *   onUploadComplete: (data) => {
- *     console.log('Upload completed:', data);
- *   },
- *   onUploadFailed: (data) => {
- *     console.error('Upload failed:', data.error);
- *   },
- * });
- * </script>
- *
- * <template>
- *   <div>Monitoring uploads...</div>
- * </template>
- * ```
- */
-declare function useUploadEvents(options: UseUploadEventsOptions): void;
-//#endregion
-//#region src/composables/plugin.d.ts
-interface UploadistaPluginOptions extends UploadistaClientOptions {
-  /**
-   * Global event handler for all upload and flow events from this client
-   */
-  onEvent?: UploadistaClientOptions["onEvent"];
-}
-declare const UPLOADISTA_CLIENT_KEY: InjectionKey<ReturnType<typeof createUploadistaClient>>;
-declare const UPLOADISTA_EVENT_SUBSCRIBERS_KEY: InjectionKey<Ref<Set<(event: UploadistaEvent) => void>>>;
-/**
- * Vue plugin for providing Uploadista client instance globally.
- * Uses Vue's provide/inject pattern to make the client available
- * throughout the component tree.
- *
- * @param options - Uploadista client configuration options
- * @returns Vue plugin object
- *
- * @example
- * ```typescript
- * import { createApp } from 'vue';
- * import { createUploadistaPlugin } from '@uploadista/vue';
- * import App from './App.vue';
- *
- * const app = createApp(App);
- *
- * app.use(createUploadistaPlugin({
- *   baseUrl: 'https://api.example.com',
- *   storageId: 'my-storage',
- *   chunkSize: 1024 * 1024, // 1MB
- *   storeFingerprintForResuming: true,
- *   onEvent: (event) => {
- *     console.log('Upload event:', event);
- *   }
- * }));
- *
- * app.mount('#app');
- * ```
- */
-declare function createUploadistaPlugin(options: UploadistaPluginOptions): {
-  install(app: App): void;
-};
+declare function useFlow(options: FlowUploadOptions): UseFlowReturn;
 //#endregion
 //#region src/composables/useDragDrop.d.ts
 interface DragDropOptions {
@@ -450,206 +358,297 @@ declare function useDragDrop(options?: DragDropOptions): {
   reset: () => void;
 };
 //#endregion
-//#region src/composables/useFlow.d.ts
+//#region src/composables/eventUtils.d.ts
 /**
- * Input metadata discovered from the flow
+ * Type guard to check if an event is a flow event
  */
-interface FlowInputMetadata {
-  /** Input node ID */
-  nodeId: string;
-  /** Human-readable node name */
-  nodeName: string;
-  /** Node description explaining what input is needed */
-  nodeDescription: string;
-  /** Input type ID from inputTypeRegistry - describes how clients interact with this node */
-  inputTypeId?: string;
-  /** Whether this input is required */
-  required: boolean;
-}
+declare function isFlowEvent(event: unknown): event is FlowEvent;
 /**
- * Return value from the useFlow composable with upload control methods and state.
+ * Type guard to check if an event is an upload event
+ */
+declare function isUploadEvent(event: unknown): event is UploadEvent;
+//#endregion
+//#region src/composables/useFlowEvents.d.ts
+/**
+ * Options for handling flow execution events.
  *
- * @property state - Complete flow upload state with progress and outputs
- * @property inputMetadata - Metadata about discovered input nodes (null until discovered)
- * @property inputStates - Per-input execution state for multi-input flows
- * @property inputs - Current input values set via setInput()
- * @property setInput - Set an input value for a specific node (for progressive provision)
- * @property execute - Execute the flow with current inputs (auto-detects types)
- * @property upload - Convenience method for single-file upload (same as execute with one file input)
- * @property abort - Cancel the current upload and flow execution
- * @property pause - Pause the current upload
- * @property reset - Reset state to idle (clears all data)
- * @property isUploading - True when upload or processing is active
- * @property isUploadingFile - True only during file upload phase
- * @property isProcessing - True only during flow processing phase
- * @property isDiscoveringInputs - True while discovering flow inputs
+ * All callbacks are optional - only provide handlers for events you care about.
  */
-interface UseFlowReturn {
-  /**
-   * Current upload state
-   */
-  state: Readonly<Ref<FlowUploadState>>;
-  /**
-   * Discovered input nodes metadata (null until discovery completes)
-   */
-  inputMetadata: Readonly<Ref<FlowInputMetadata[] | null>>;
-  /**
-   * Per-input execution state for multi-input flows
-   */
-  inputStates: Readonly<Ref<ReadonlyMap<string, InputExecutionState>>>;
-  /**
-   * Current inputs set via setInput()
-   */
-  inputs: Readonly<Ref<Record<string, unknown>>>;
-  /**
-   * Set an input value for a specific node.
-   * For progressive input provision before calling execute().
-   *
-   * @param nodeId - The input node ID
-   * @param value - The input value (File, URL string, or structured data)
-   */
-  setInput: (nodeId: string, value: unknown) => void;
-  /**
-   * Execute the flow with current inputs.
-   * Automatically detects input types and routes appropriately.
-   * For single input, uses standard upload path.
-   * For multiple inputs, requires multiInputUploadFn.
-   */
-  execute: () => Promise<void>;
-  /**
-   * Upload a single file through the flow (convenience method).
-   * Equivalent to setInput(firstNodeId, file) + execute().
-   *
-   * @param file - File or Blob to upload
-   */
-  upload: (file: File | Blob) => Promise<void>;
-  /**
-   * Abort the current upload
-   */
-  abort: () => void;
-  /**
-   * Pause the current upload
-   */
-  pause: () => void;
-  /**
-   * Reset the upload state and clear all inputs
-   */
-  reset: () => void;
-  /**
-   * Whether an upload or flow execution is in progress (uploading OR processing)
-   */
-  isUploading: Readonly<Ref<boolean>>;
-  /**
-   * Whether the file is currently being uploaded (chunks being sent)
-   */
-  isUploadingFile: Readonly<Ref<boolean>>;
-  /**
-   * Whether the flow is currently processing (after upload completes)
-   */
-  isProcessing: Readonly<Ref<boolean>>;
-  /**
-   * Whether the hook is discovering flow inputs
-   */
-  isDiscoveringInputs: Readonly<Ref<boolean>>;
+interface UseFlowEventsOptions {
+  /** Called when a job starts execution */
+  onJobStart?: (event: FlowEventJobStart) => void;
+  /** Called when a job completes (success or failure) */
+  onJobEnd?: (event: FlowEventJobEnd) => void;
+  /** Called when a flow begins execution */
+  onFlowStart?: (event: FlowEventFlowStart) => void;
+  /** Called when a flow completes successfully */
+  onFlowEnd?: (event: FlowEventFlowEnd) => void;
+  /** Called when a flow encounters an error */
+  onFlowError?: (event: FlowEventFlowError) => void;
+  /** Called when a flow is paused by user request */
+  onFlowPause?: (event: FlowEventFlowPause) => void;
+  /** Called when a flow is cancelled by user request */
+  onFlowCancel?: (event: FlowEventFlowCancel) => void;
+  /** Called when a node starts processing */
+  onNodeStart?: (event: FlowEventNodeStart) => void;
+  /** Called when a node completes successfully */
+  onNodeEnd?: (event: FlowEventNodeEnd) => void;
+  /** Called when a node pauses (waiting for additional data) */
+  onNodePause?: (event: FlowEventNodePause) => void;
+  /** Called when a paused node resumes execution */
+  onNodeResume?: (event: FlowEventNodeResume) => void;
+  /** Called when a node encounters an error */
+  onNodeError?: (event: FlowEventNodeError) => void;
 }
 /**
- * Vue composable for executing flows with single or multiple inputs.
- * Automatically discovers input nodes and detects input types (File, URL, structured data).
- * Supports progressive input provision via setInput() and execute().
+ * Structured composable for handling flow execution events with type-safe callbacks.
  *
- * This is the unified flow composable that replaces useFlowUpload for advanced use cases.
- * It provides:
- * - Auto-discovery of flow input nodes
- * - Automatic input type detection (file -> upload, string -> URL, object -> data)
- * - Progressive input provision via setInput()
- * - Multi-input support with parallel coordination
- * - Per-input state tracking
+ * This composable provides a clean API for listening to specific flow events without
+ * needing to manually filter events or use type guards.
  *
- * Must be used within FlowManagerProvider (which must be within UploadistaProvider).
- * Flow events are automatically routed by the provider to the appropriate manager.
+ * Must be used within UploadistaProvider.
  *
- * @param options - Flow upload configuration including flow ID and event handlers
- * @returns Flow upload state and control methods
+ * @param options - Object with optional callbacks for each flow event type
  *
  * @example
  * ```vue
  * <script setup lang="ts">
- * import { useFlow } from '@uploadista/vue';
+ * import { useFlowEvents } from '@uploadista/vue';
  *
- * // Single file upload (simple case)
- * const flow = useFlow({
- *   flowConfig: {
- *     flowId: "image-optimization",
- *     storageId: "s3-images",
+ * useFlowEvents({
+ *   onFlowStart: (event) => {
+ *     console.log('Flow started:', event.flowId);
  *   },
- *   onSuccess: (outputs) => {
- *     console.log("Flow outputs:", outputs);
+ *   onNodeStart: (event) => {
+ *     console.log('Node started:', event.nodeName);
+ *   },
+ *   onNodeEnd: (event) => {
+ *     console.log('Node completed:', event.nodeName, event.result);
+ *   },
+ *   onFlowEnd: (event) => {
+ *     console.log('Flow completed with outputs:', event.outputs);
+ *   },
+ *   onFlowError: (event) => {
+ *     console.error('Flow failed:', event.error);
  *   },
  * });
- *
- * const handleFileChange = (event: Event) => {
- *   const file = (event.target as HTMLInputElement).files?.[0];
- *   if (file) flow.upload(file);
- * };
  * </script>
  *
  * <template>
- *   <div>
- *     <input type="file" @change="handleFileChange" />
- *     <div v-if="flow.isUploading.value">Progress: {{ flow.state.value.progress }}%</div>
- *   </div>
+ *   <div>Monitoring flow execution...</div>
  * </template>
  * ```
+ */
+declare function useFlowEvents(options: UseFlowEventsOptions): void;
+//#endregion
+//#region src/composables/useUploadEvents.d.ts
+/**
+ * Upload progress event data
+ */
+interface UploadProgressEventData {
+  id: string;
+  progress: number;
+  total: number;
+  flow?: {
+    flowId: string;
+    nodeId: string;
+    jobId: string;
+  };
+}
+/**
+ * Upload started/complete event data (contains full UploadFile)
+ */
+interface UploadFileEventData {
+  [key: string]: unknown;
+  flow?: {
+    flowId: string;
+    nodeId: string;
+    jobId: string;
+  };
+}
+/**
+ * Upload failed event data
+ */
+interface UploadFailedEventData {
+  id: string;
+  error: string;
+  flow?: {
+    flowId: string;
+    nodeId: string;
+    jobId: string;
+  };
+}
+/**
+ * Upload validation success event data
+ */
+interface UploadValidationSuccessEventData {
+  id: string;
+  validationType: "checksum" | "mimetype";
+  algorithm?: string;
+  flow?: {
+    flowId: string;
+    nodeId: string;
+    jobId: string;
+  };
+}
+/**
+ * Upload validation failed event data
+ */
+interface UploadValidationFailedEventData {
+  id: string;
+  reason: string;
+  expected: string;
+  actual: string;
+  flow?: {
+    flowId: string;
+    nodeId: string;
+    jobId: string;
+  };
+}
+/**
+ * Upload validation warning event data
+ */
+interface UploadValidationWarningEventData {
+  id: string;
+  message: string;
+  flow?: {
+    flowId: string;
+    nodeId: string;
+    jobId: string;
+  };
+}
+/**
+ * Options for handling upload events.
+ *
+ * All callbacks are optional - only provide handlers for events you care about.
+ */
+interface UseUploadEventsOptions {
+  /** Called when an upload starts */
+  onUploadStarted?: (data: UploadFileEventData) => void;
+  /** Called with upload progress updates */
+  onUploadProgress?: (data: UploadProgressEventData) => void;
+  /** Called when an upload completes successfully */
+  onUploadComplete?: (data: UploadFileEventData) => void;
+  /** Called when an upload fails */
+  onUploadFailed?: (data: UploadFailedEventData) => void;
+  /** Called when upload validation succeeds */
+  onUploadValidationSuccess?: (data: UploadValidationSuccessEventData) => void;
+  /** Called when upload validation fails */
+  onUploadValidationFailed?: (data: UploadValidationFailedEventData) => void;
+  /** Called when upload validation produces a warning */
+  onUploadValidationWarning?: (data: UploadValidationWarningEventData) => void;
+}
+/**
+ * Structured composable for handling upload events with type-safe callbacks.
+ *
+ * This composable provides a clean API for listening to specific upload events without
+ * needing to manually filter events or use type guards.
+ *
+ * Must be used within UploadistaProvider.
+ *
+ * @param options - Object with optional callbacks for each upload event type
  *
  * @example
  * ```vue
  * <script setup lang="ts">
- * import { useFlow } from '@uploadista/vue';
+ * import { useUploadEvents } from '@uploadista/vue';
  *
- * // Multi-input with progressive provision
- * const flow = useFlow({
- *   flowConfig: {
- *     flowId: "multi-source-processing",
- *     storageId: "default",
+ * useUploadEvents({
+ *   onUploadStarted: (data) => {
+ *     console.log('Upload started:', data.id);
+ *   },
+ *   onUploadProgress: (data) => {
+ *     const percent = (data.progress / data.total) * 100;
+ *     console.log(`Upload progress: ${percent}%`);
+ *   },
+ *   onUploadComplete: (data) => {
+ *     console.log('Upload completed:', data);
+ *   },
+ *   onUploadFailed: (data) => {
+ *     console.error('Upload failed:', data.error);
  *   },
  * });
+ * </script>
  *
- * const handleInputChange = (nodeId: string, event: Event) => {
- *   const target = event.target as HTMLInputElement;
- *   if (target.type === 'file') {
- *     const file = target.files?.[0];
- *     if (file) flow.setInput(nodeId, file);
- *   } else {
- *     flow.setInput(nodeId, target.value);
+ * <template>
+ *   <div>Monitoring uploads...</div>
+ * </template>
+ * ```
+ */
+declare function useUploadEvents(options: UseUploadEventsOptions): void;
+//#endregion
+//#region src/composables/useUploadistaEvents.d.ts
+/**
+ * Simple composable that subscribes to all Uploadista events (both flow and upload events).
+ *
+ * This is a low-level composable that provides access to all events. For more structured
+ * event handling, consider using `useFlowEvents` or `useUploadEvents` instead.
+ *
+ * Must be used within UploadistaProvider.
+ *
+ * @param callback - Function called for every event emitted by the Uploadista client
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * import { useUploadistaEvents, isFlowEvent, isUploadEvent } from '@uploadista/vue';
+ *
+ * useUploadistaEvents((event) => {
+ *   if (isFlowEvent(event)) {
+ *     console.log('Flow event:', event.eventType);
+ *   } else if (isUploadEvent(event)) {
+ *     console.log('Upload event:', event.type);
  *   }
- * };
+ * });
  * </script>
  *
  * <template>
- *   <div v-if="flow.inputMetadata.value">
- *     <div v-for="input in flow.inputMetadata.value" :key="input.nodeId">
- *       <label>{{ input.nodeName }}</label>
- *       <input
- *         v-if="input.inputTypeId === 'streaming-input-v1'"
- *         type="file"
- *         @change="(e) => handleInputChange(input.nodeId, e)"
- *       />
- *       <input
- *         v-else
- *         type="url"
- *         @change="(e) => handleInputChange(input.nodeId, e)"
- *       />
- *     </div>
- *     <button @click="flow.execute" :disabled="flow.isUploading.value">
- *       Execute Flow
- *     </button>
- *   </div>
+ *   <div>Listening to all events...</div>
  * </template>
  * ```
+ */
+declare function useUploadistaEvents(callback: (event: UploadistaEvent) => void): void;
+//#endregion
+//#region src/composables/plugin.d.ts
+interface UploadistaPluginOptions extends UploadistaClientOptions {
+  /**
+   * Global event handler for all upload and flow events from this client
+   */
+  onEvent?: UploadistaClientOptions["onEvent"];
+}
+declare const UPLOADISTA_CLIENT_KEY: InjectionKey<ReturnType<typeof createUploadistaClient>>;
+/**
+ * Vue plugin for providing Uploadista client instance globally.
+ * Uses Vue's provide/inject pattern to make the client available
+ * throughout the component tree.
  *
- * @see {@link useFlowUpload} for a simpler file-only upload composable
+ * @param options - Uploadista client configuration options
+ * @returns Vue plugin object
+ *
+ * @example
+ * ```typescript
+ * import { createApp } from 'vue';
+ * import { createUploadistaPlugin } from '@uploadista/vue';
+ * import App from './App.vue';
+ *
+ * const app = createApp(App);
+ *
+ * app.use(createUploadistaPlugin({
+ *   baseUrl: 'https://api.example.com',
+ *   storageId: 'my-storage',
+ *   chunkSize: 1024 * 1024, // 1MB
+ *   storeFingerprintForResuming: true,
+ *   onEvent: (event) => {
+ *     console.log('Upload event:', event);
+ *   }
+ * }));
+ *
+ * app.mount('#app');
+ * ```
  */
-declare function useFlow(options: FlowUploadOptions): UseFlowReturn;
+declare function createUploadistaPlugin(options: UploadistaPluginOptions): {
+  install(app: App): void;
+};
 //#endregion
 //#region src/composables/useMultiFlowUpload.d.ts
 /**
@@ -752,7 +751,7 @@ declare function useMultiFlowUpload(options: MultiFlowUploadOptions<BrowserUploa
         } | undefined;
         readonly size?: number | undefined | undefined;
         readonly metadata?: {
-          readonly [x: string]: string | number | boolean;
+          readonly [x: string]: any;
         } | undefined;
         readonly creationDate?: string | undefined | undefined;
         readonly url?: string | undefined | undefined;
@@ -821,7 +820,7 @@ declare function useMultiFlowUpload(options: MultiFlowUploadOptions<BrowserUploa
         } | undefined;
         readonly size?: number | undefined | undefined;
         readonly metadata?: {
-          readonly [x: string]: string | number | boolean;
+          readonly [x: string]: any;
         } | undefined;
         readonly creationDate?: string | undefined | undefined;
         readonly url?: string | undefined | undefined;
@@ -918,7 +917,7 @@ declare function useUpload(options?: UploadOptions$1): {
         jobId: string;
       } | undefined;
       size?: number | undefined | undefined;
-      metadata?: Record<string, string | number | boolean> | undefined;
+      metadata?: Record<string, _uploadista_core0.JsonValue> | undefined;
       creationDate?: string | undefined | undefined;
       url?: string | undefined | undefined;
       sizeIsDeferred?: boolean | undefined | undefined;
@@ -957,7 +956,7 @@ declare function useUpload(options?: UploadOptions$1): {
         jobId: string;
       } | undefined;
       size?: number | undefined | undefined;
-      metadata?: Record<string, string | number | boolean> | undefined;
+      metadata?: Record<string, _uploadista_core0.JsonValue> | undefined;
       creationDate?: string | undefined | undefined;
       url?: string | undefined | undefined;
       sizeIsDeferred?: boolean | undefined | undefined;
@@ -1191,7 +1190,7 @@ declare function useMultiUpload(options?: MultiUploadOptions): {
         } | undefined;
         readonly size?: number | undefined | undefined;
         readonly metadata?: {
-          readonly [x: string]: string | number | boolean;
+          readonly [x: string]: any;
         } | undefined;
         readonly creationDate?: string | undefined | undefined;
         readonly url?: string | undefined | undefined;
@@ -1255,7 +1254,7 @@ declare function useMultiUpload(options?: MultiUploadOptions): {
         } | undefined;
         readonly size?: number | undefined | undefined;
         readonly metadata?: {
-          readonly [x: string]: string | number | boolean;
+          readonly [x: string]: any;
         } | undefined;
         readonly creationDate?: string | undefined | undefined;
         readonly url?: string | undefined | undefined;
@@ -1329,7 +1328,7 @@ declare function useMultiUpload(options?: MultiUploadOptions): {
           jobId: string;
         } | undefined;
         size?: number | undefined | undefined;
-        metadata?: Record<string, string | number | boolean> | undefined;
+        metadata?: Record<string, _uploadista_core0.JsonValue> | undefined;
         creationDate?: string | undefined | undefined;
         url?: string | undefined | undefined;
         sizeIsDeferred?: boolean | undefined | undefined;
@@ -1898,5 +1897,5 @@ declare function useUploadMetrics(options?: UseUploadMetricsOptions): {
   };
 };
 //#endregion
-export { createUploadistaPlugin as A, useFlowEvents as B, useFlow as C, UPLOADISTA_CLIENT_KEY as D, useDragDrop as E, UploadValidationSuccessEventData as F, isFlowEvent as H, UploadValidationWarningEventData as I, UseUploadEventsOptions as L, UploadFileEventData as M, UploadProgressEventData as N, UPLOADISTA_EVENT_SUBSCRIBERS_KEY as O, UploadValidationFailedEventData as P, useUploadEvents as R, UseFlowReturn as S, DragDropState as T, isUploadEvent as U, useUploadistaEvents as V, useMultiFlowUpload as _, useUploadistaClient as a, FlowUploadStatus$1 as b, UploadItem as c, PerformanceInsights$1 as d, UploadInput as f, useUpload as g, UploadStatus as h, UseUploadistaClientReturn as i, UploadFailedEventData as j, UploadistaPluginOptions as k, useMultiUpload as l, UploadState as m, UseUploadMetricsOptions as n, MultiUploadOptions as o, UploadSessionMetrics$1 as p, useUploadMetrics as r, MultiUploadState as s, FileUploadMetrics as t, ChunkMetrics$1 as u, FlowInputMetadata as v, DragDropOptions as w, InputExecutionState as x, FlowUploadState as y, UseFlowEventsOptions as z };
-//# sourceMappingURL=index-DiRR_Ua6.d.mts.map
+export { UseFlowEventsOptions as A, InputExecutionState as B, UploadFileEventData as C, UploadValidationWarningEventData as D, UploadValidationSuccessEventData as E, DragDropState as F, useFlow as H, useDragDrop as I, FlowInputMetadata as L, isFlowEvent as M, isUploadEvent as N, UseUploadEventsOptions as O, DragDropOptions as P, FlowUploadState as R, UploadFailedEventData as S, UploadValidationFailedEventData as T, UseFlowReturn as V, useMultiFlowUpload as _, useUploadistaClient as a, createUploadistaPlugin as b, UploadItem as c, PerformanceInsights$1 as d, UploadInput as f, useUpload as g, UploadStatus as h, UseUploadistaClientReturn as i, useFlowEvents as j, useUploadEvents as k, useMultiUpload as l, UploadState as m, UseUploadMetricsOptions as n, MultiUploadOptions as o, UploadSessionMetrics$1 as p, useUploadMetrics as r, MultiUploadState as s, FileUploadMetrics as t, ChunkMetrics$1 as u, UPLOADISTA_CLIENT_KEY as v, UploadProgressEventData as w, useUploadistaEvents as x, UploadistaPluginOptions as y, FlowUploadStatus$1 as z };
+//# sourceMappingURL=index-RY4FPqAk.d.mts.map