@uploadista/react-native-core 0.0.20-beta.6 → 0.0.20-beta.8

package/dist/index.d.mts

@@ -1,10 +1,10 @@
 import * as react0 from "react";
 import { ReactNode } from "react";
 import * as _uploadista_client_core3 from "@uploadista/client-core";
-import { Base64Service, ConnectionMetrics, ConnectionPoolConfig, ConnectionPoolConfig as ConnectionPoolConfig$1, DetailedConnectionMetrics, FileReaderService, FlowManager, FlowManagerCallbacks, FlowUploadOptions, FlowUploadState, FlowUploadStatus, HttpClient, IdGenerationService, InputExecutionState, ServiceContainer, ServiceContainer as ServiceContainer$1, StorageService, UploadState, UploadStatus, UploadistaClientOptions, UploadistaEvent } from "@uploadista/client-core";
+import { Base64Service, ConnectionMetrics, ConnectionPoolConfig, ConnectionPoolConfig as ConnectionPoolConfig$1, DetailedConnectionMetrics, FileReaderService, FlowManager, FlowManagerCallbacks, FlowUploadOptions, FlowUploadState, FlowUploadState as FlowUploadState$1, FlowUploadStatus, FlowUploadStatus as FlowUploadStatus$1, HttpClient, IdGenerationService, InputExecutionState, InputExecutionState as InputExecutionState$1, ServiceContainer, ServiceContainer as ServiceContainer$1, StorageService, UploadState, UploadStatus, UploadistaClientOptions, UploadistaEvent } from "@uploadista/client-core";
 import { TypedOutput } from "@uploadista/core/flow";
 import { UploadFile } from "@uploadista/core/types";
-import * as react_jsx_runtime3 from "react/jsx-runtime";
+import * as react_jsx_runtime12 from "react/jsx-runtime";
 import * as _uploadista_core0 from "@uploadista/core";
 
 //#region src/types/types.d.ts
@@ -283,7 +283,7 @@ declare function CameraUploadButton({
   onError,
   onCancel,
   showProgress
-}: CameraUploadButtonProps): react_jsx_runtime3.JSX.Element;
+}: CameraUploadButtonProps): react_jsx_runtime12.JSX.Element;
 //#endregion
 //#region src/components/FileUploadButton.d.ts
 interface FileUploadButtonProps {
@@ -314,7 +314,7 @@ declare function FileUploadButton({
   onError,
   onCancel,
   showProgress
-}: FileUploadButtonProps): react_jsx_runtime3.JSX.Element;
+}: FileUploadButtonProps): react_jsx_runtime12.JSX.Element;
 //#endregion
 //#region src/components/GalleryUploadButton.d.ts
 interface GalleryUploadButtonProps {
@@ -345,7 +345,7 @@ declare function GalleryUploadButton({
   onError,
   onCancel,
   showProgress
-}: GalleryUploadButtonProps): react_jsx_runtime3.JSX.Element;
+}: GalleryUploadButtonProps): react_jsx_runtime12.JSX.Element;
 //#endregion
 //#region src/components/UploadList.d.ts
 interface UploadListProps {
@@ -367,7 +367,7 @@ declare function UploadList({
   onRemove,
   onItemPress,
   showRemoveButton
-}: UploadListProps): react_jsx_runtime3.JSX.Element;
+}: UploadListProps): react_jsx_runtime12.JSX.Element;
 //#endregion
 //#region src/components/UploadProgress.d.ts
 interface UploadProgressProps {
@@ -382,7 +382,745 @@ interface UploadProgressProps {
 declare function UploadProgress({
   state,
   label
-}: UploadProgressProps): react_jsx_runtime3.JSX.Element;
+}: UploadProgressProps): react_jsx_runtime12.JSX.Element;
+//#endregion
+//#region src/hooks/use-flow.d.ts
+/**
+ * Input metadata discovered from the flow
+ */
+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;
+}
+/**
+ * Options for the useFlow hook
+ */
+interface UseFlowOptions {
+  /** Flow ID to execute */
+  flowId: string;
+  /** Storage ID for the upload */
+  storageId: string;
+  /** Output node ID for the flow */
+  outputNodeId?: string;
+  /** Metadata to pass to flow */
+  metadata?: Record<string, unknown>;
+  /** Called when upload succeeds (receives typed outputs from all output nodes) */
+  onSuccess?: (outputs: TypedOutput[]) => void;
+  /** Called when the flow completes successfully (receives full flow outputs) */
+  onFlowComplete?: (outputs: TypedOutput[]) => void;
+  /** Called when upload fails */
+  onError?: (error: Error) => void;
+  /** Called when upload progress updates */
+  onProgress?: (progress: number, bytesUploaded: number, totalBytes: number | null) => void;
+  /** Called when a chunk completes */
+  onChunkComplete?: (chunkSize: number, bytesAccepted: number, bytesTotal: number | null) => void;
+}
+/**
+ * Return value from the useFlow hook 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 reset - Reset state to idle (clears all data)
+ * @property retry - Retry the last failed upload
+ * @property isActive - 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
+ * @property canRetry - True if a retry is possible
+ */
+interface UseFlowReturn {
+  /**
+   * Current upload state
+   */
+  state: FlowUploadState;
+  /**
+   * Discovered input nodes metadata (null until discovery completes)
+   */
+  inputMetadata: FlowInputMetadata[] | null;
+  /**
+   * Per-input execution state for multi-input flows
+   */
+  inputStates: ReadonlyMap<string, InputExecutionState>;
+  /**
+   * Current inputs set via setInput()
+   */
+  inputs: 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 (FilePickResult, URL string, or structured data)
+   */
+  setInput: (nodeId: string, value: FilePickResult | string | 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 - FilePickResult from a picker
+   */
+  upload: (file: FilePickResult) => Promise<void>;
+  /**
+   * Abort the current upload
+   */
+  abort: () => void;
+  /**
+   * Reset the upload state and clear all inputs
+   */
+  reset: () => void;
+  /**
+   * Retry the last failed upload
+   */
+  retry: () => void;
+  /**
+   * Whether an upload or flow execution is in progress (uploading OR processing)
+   */
+  isActive: boolean;
+  /**
+   * Whether the file is currently being uploaded (chunks being sent)
+   */
+  isUploadingFile: boolean;
+  /**
+   * Whether the flow is currently processing (after upload completes)
+   */
+  isProcessing: boolean;
+  /**
+   * Whether the hook is discovering flow inputs
+   */
+  isDiscoveringInputs: boolean;
+  /**
+   * Whether a retry is possible (after error or abort with stored inputs)
+   */
+  canRetry: boolean;
+}
+/**
+ * React Native hook 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 the unified flow hook that replaces useFlowUpload for advanced use cases.
+ * It provides:
+ * - Auto-discovery of flow input nodes
+ * - Automatic input type detection (FilePickResult -> upload, string -> URL, object -> data)
+ * - Progressive input provision via setInput()
+ * - Multi-input support with parallel coordination
+ * - Per-input state tracking
+ *
+ * Must be used within FlowManagerProvider (which must be within UploadistaProvider).
+ * Flow events are automatically routed by the provider to the appropriate manager.
+ *
+ * @param options - Flow upload configuration including flow ID and event handlers
+ * @returns Flow upload state and control methods
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const flow = useFlow({
+ *     flowId: 'image-processing-flow',
+ *     storageId: 'my-storage',
+ *     onSuccess: (outputs) => console.log('Flow complete:', outputs),
+ *     onError: (error) => console.error('Flow failed:', error),
+ *   });
+ *
+ *   const handlePickFile = async () => {
+ *     const file = await fileSystemProvider.pickDocument();
+ *     if (file) {
+ *       await flow.upload(file);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <View>
+ *       <Button title="Pick File" onPress={handlePickFile} />
+ *       {flow.isActive && <Text>Progress: {flow.state.progress}%</Text>}
+ *       {flow.inputMetadata && (
+ *         <Text>Found {flow.inputMetadata.length} input nodes</Text>
+ *       )}
+ *       <Button title="Abort" onPress={flow.abort} disabled={!flow.isActive} />
+ *     </View>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Multi-input flow
+ * function MultiInputComponent() {
+ *   const flow = useFlow({
+ *     flowId: 'multi-source-flow',
+ *     storageId: 'my-storage',
+ *   });
+ *
+ *   const handlePickPrimary = async () => {
+ *     const file = await fileSystemProvider.pickDocument();
+ *     if (file.status === 'success') {
+ *       flow.setInput('primary-input', file);
+ *     }
+ *   };
+ *
+ *   const handleSetUrl = (url: string) => {
+ *     flow.setInput('url-input', url);
+ *   };
+ *
+ *   return (
+ *     <View>
+ *       <Button title="Pick Primary" onPress={handlePickPrimary} />
+ *       <TextInput onChangeText={handleSetUrl} placeholder="Enter URL" />
+ *       <Button title="Execute" onPress={flow.execute} />
+ *     </View>
+ *   );
+ * }
+ * ```
+ *
+ * @see {@link useFlowUpload} for a simpler file-only upload hook
+ */
+declare function useFlow(options: UseFlowOptions): UseFlowReturn;
+//#endregion
+//#region src/components/flow-primitives.d.ts
+/**
+ * Context value provided by the Flow component root.
+ * Contains all flow state and actions.
+ */
+interface FlowContextValue {
+  /** Current upload state */
+  state: FlowUploadState$1;
+  /** Discovered input nodes metadata (null until discovery completes) */
+  inputMetadata: FlowInputMetadata[] | null;
+  /** Current input values set via setInput() */
+  inputs: Record<string, unknown>;
+  /** Per-input execution state for multi-input flows */
+  inputStates: ReadonlyMap<string, InputExecutionState$1>;
+  /** Set an input value for a specific node */
+  setInput: (nodeId: string, value: unknown) => void;
+  /** Execute the flow with current inputs */
+  execute: () => Promise<void>;
+  /** Upload a single file through the flow */
+  upload: (file: FilePickResult) => Promise<void>;
+  /** Abort the current upload */
+  abort: () => void;
+  /** Reset the upload state and clear all inputs */
+  reset: () => void;
+  /** Whether an upload or flow execution is in progress */
+  isActive: boolean;
+  /** Whether the file is currently being uploaded */
+  isUploadingFile: boolean;
+  /** Whether the flow is currently processing */
+  isProcessing: boolean;
+  /** Whether the hook is discovering flow inputs */
+  isDiscoveringInputs: boolean;
+  /** Pick a file and set it for a specific input node */
+  pickFileForInput: (nodeId: string) => Promise<void>;
+  /** Pick a file and start upload immediately (single-file flows) */
+  pickAndUpload: () => Promise<void>;
+}
+/**
+ * Hook to access flow context from within a Flow component.
+ * @throws Error if used outside of a Flow component
+ */
+declare function useFlowContext(): FlowContextValue;
+/**
+ * Context value for a specific input node within a Flow.
+ */
+interface FlowInputContextValue {
+  /** Input node ID */
+  nodeId: string;
+  /** Input metadata from flow discovery */
+  metadata: FlowInputMetadata;
+  /** Current value for this input */
+  value: unknown;
+  /** Set the value for this input */
+  setValue: (value: unknown) => void;
+  /** Per-input execution state (if available) */
+  state: InputExecutionState$1 | undefined;
+  /** Pick a file for this input */
+  pickFile: () => Promise<void>;
+}
+/**
+ * Hook to access flow input context from within a Flow.Input component.
+ * @throws Error if used outside of a Flow.Input component
+ */
+declare function useFlowInputContext(): FlowInputContextValue;
+/**
+ * Render props for the Flow root component.
+ */
+interface FlowRenderProps extends FlowContextValue {
+  /** Alias for execute() */
+  submit: () => Promise<void>;
+  /** Alias for abort() */
+  cancel: () => void;
+}
+/**
+ * Props for the Flow root component.
+ */
+interface FlowProps {
+  /** Flow ID to execute */
+  flowId: string;
+  /** Storage ID for file uploads */
+  storageId: string;
+  /** Optional output node ID to wait for */
+  outputNodeId?: string;
+  /** Optional metadata to include with the flow execution */
+  metadata?: Record<string, string>;
+  /** Called when flow completes successfully */
+  onSuccess?: (outputs: TypedOutput[]) => void;
+  /** Called when flow fails */
+  onError?: (error: Error) => void;
+  /** Called on upload progress */
+  onProgress?: (progress: number, bytesUploaded: number, totalBytes: number | null) => void;
+  /** Called when flow completes with all outputs */
+  onFlowComplete?: (outputs: TypedOutput[]) => void;
+  /** Children to render (can be render function or ReactNode) */
+  children: ReactNode | ((props: FlowRenderProps) => ReactNode);
+}
+/**
+ * Root component for flow-based uploads on React Native.
+ * Provides context for all Flow sub-components.
+ *
+ * @example
+ * ```tsx
+ * <Flow flowId="image-optimizer" storageId="s3" onSuccess={handleSuccess}>
+ *   <Flow.Inputs>
+ *     {({ inputs, isLoading }) => (
+ *       inputs.map(input => (
+ *         <Flow.Input key={input.nodeId} nodeId={input.nodeId}>
+ *           {({ metadata, pickFile }) => (
+ *             <Button onPress={pickFile} title={metadata.nodeName} />
+ *           )}
+ *         </Flow.Input>
+ *       ))
+ *     )}
+ *   </Flow.Inputs>
+ *   <Flow.Submit>
+ *     <Text>Process</Text>
+ *   </Flow.Submit>
+ * </Flow>
+ * ```
+ */
+declare function FlowRoot({
+  flowId,
+  storageId,
+  outputNodeId,
+  metadata,
+  onSuccess,
+  onError,
+  onProgress,
+  onFlowComplete,
+  children
+}: FlowProps): react_jsx_runtime12.JSX.Element;
+/**
+ * Render props for Flow.Inputs component.
+ */
+interface FlowInputsRenderProps {
+  /** Discovered input metadata */
+  inputs: FlowInputMetadata[];
+  /** Whether inputs are still being discovered */
+  isLoading: boolean;
+}
+/**
+ * Props for Flow.Inputs component.
+ */
+interface FlowInputsProps {
+  /** Render function receiving discovered inputs */
+  children: (props: FlowInputsRenderProps) => ReactNode;
+}
+/**
+ * Auto-discovers flow input nodes and provides them via render props.
+ *
+ * @example
+ * ```tsx
+ * <Flow.Inputs>
+ *   {({ inputs, isLoading }) => (
+ *     isLoading ? <ActivityIndicator /> : (
+ *       inputs.map(input => (
+ *         <Flow.Input key={input.nodeId} nodeId={input.nodeId}>
+ *           ...
+ *         </Flow.Input>
+ *       ))
+ *     )
+ *   )}
+ * </Flow.Inputs>
+ * ```
+ */
+declare function FlowInputs({
+  children
+}: FlowInputsProps): react_jsx_runtime12.JSX.Element;
+/**
+ * Props for Flow.Input component.
+ */
+interface FlowInputProps {
+  /** Input node ID */
+  nodeId: string;
+  /** Children (can be render function or regular children) */
+  children: ReactNode | ((props: FlowInputContextValue) => ReactNode);
+}
+/**
+ * Scoped input context provider for a specific input node.
+ * Children can access input-specific state via useFlowInputContext().
+ *
+ * @example
+ * ```tsx
+ * <Flow.Input nodeId="video-input">
+ *   {({ metadata, value, pickFile }) => (
+ *     <View>
+ *       <Text>{metadata.nodeName}</Text>
+ *       <Button onPress={pickFile} title="Select File" />
+ *       {value && <Text>Selected: {value.data?.name}</Text>}
+ *     </View>
+ *   )}
+ * </Flow.Input>
+ * ```
+ */
+declare function FlowInput({
+  nodeId,
+  children
+}: FlowInputProps): react_jsx_runtime12.JSX.Element | null;
+/**
+ * Render props for Flow.Input.FilePicker component.
+ */
+interface FlowInputFilePickerRenderProps {
+  /** Current value for this input */
+  value: unknown;
+  /** Whether a file is selected */
+  hasFile: boolean;
+  /** File name (if value is FilePickResult) */
+  fileName: string | null;
+  /** File size in bytes (if value is FilePickResult) */
+  fileSize: number | null;
+  /** Per-input progress (if available) */
+  progress: number;
+  /** Per-input status (if available) */
+  status: string;
+  /** Open file picker */
+  pickFile: () => Promise<void>;
+  /** Clear the input value */
+  clear: () => void;
+}
+/**
+ * Props for Flow.Input.FilePicker component.
+ */
+interface FlowInputFilePickerProps {
+  /** Render function receiving file picker state */
+  children: (props: FlowInputFilePickerRenderProps) => ReactNode;
+}
+/**
+ * File picker for a specific input within a Flow.Input.
+ * Sets the input value but does NOT trigger upload until Flow.Submit is pressed.
+ */
+declare function FlowInputFilePicker({
+  children
+}: FlowInputFilePickerProps): react_jsx_runtime12.JSX.Element;
+/**
+ * Render props for Flow.Input.Preview component.
+ */
+interface FlowInputPreviewRenderProps {
+  /** Current value */
+  value: unknown;
+  /** Whether a file is selected */
+  hasFile: boolean;
+  /** Whether value is a URL string */
+  isUrl: boolean;
+  /** File name (if value is FilePickResult) */
+  fileName: string | null;
+  /** File size in bytes (if value is FilePickResult) */
+  fileSize: number | null;
+  /** File URI (if value is FilePickResult) */
+  fileUri: string | null;
+  /** Clear the input value */
+  clear: () => void;
+}
+/**
+ * Props for Flow.Input.Preview component.
+ */
+interface FlowInputPreviewProps {
+  /** Render function receiving preview state */
+  children: (props: FlowInputPreviewRenderProps) => ReactNode;
+}
+/**
+ * Preview component for showing the selected value within a Flow.Input.
+ */
+declare function FlowInputPreview({
+  children
+}: FlowInputPreviewProps): react_jsx_runtime12.JSX.Element;
+/**
+ * Render props for Flow.Progress component.
+ */
+interface FlowProgressRenderProps {
+  /** Progress percentage (0-100) */
+  progress: number;
+  /** Bytes uploaded so far */
+  bytesUploaded: number;
+  /** Total bytes to upload (null if unknown) */
+  totalBytes: number | null;
+  /** Current status */
+  status: FlowUploadStatus$1;
+}
+/**
+ * Props for Flow.Progress component.
+ */
+interface FlowProgressProps {
+  /** Render function receiving progress state */
+  children: (props: FlowProgressRenderProps) => ReactNode;
+}
+/**
+ * Progress display component within a Flow.
+ */
+declare function FlowProgress({
+  children
+}: FlowProgressProps): react_jsx_runtime12.JSX.Element;
+/**
+ * Render props for Flow.Status component.
+ */
+interface FlowStatusRenderProps {
+  /** Current status */
+  status: FlowUploadStatus$1;
+  /** Current node being processed (if any) */
+  currentNodeName: string | null;
+  /** Current node type (if any) */
+  currentNodeType: string | null;
+  /** Error (if status is error) */
+  error: Error | null;
+  /** Job ID (if started) */
+  jobId: string | null;
+  /** Whether flow has started */
+  flowStarted: boolean;
+  /** Flow outputs (if completed) */
+  flowOutputs: TypedOutput[] | null;
+}
+/**
+ * Props for Flow.Status component.
+ */
+interface FlowStatusProps {
+  /** Render function receiving status state */
+  children: (props: FlowStatusRenderProps) => ReactNode;
+}
+/**
+ * Status display component within a Flow.
+ */
+declare function FlowStatus({
+  children
+}: FlowStatusProps): react_jsx_runtime12.JSX.Element;
+/**
+ * Render props for Flow.Error component.
+ */
+interface FlowErrorRenderProps {
+  /** Error object (null if no error) */
+  error: Error | null;
+  /** Whether there is an error */
+  hasError: boolean;
+  /** Error message */
+  message: string | null;
+  /** Reset the flow */
+  reset: () => void;
+}
+/**
+ * Props for Flow.Error component.
+ */
+interface FlowErrorProps {
+  /** Render function receiving error state */
+  children: (props: FlowErrorRenderProps) => ReactNode;
+}
+/**
+ * Error display component within a Flow.
+ */
+declare function FlowError({
+  children
+}: FlowErrorProps): react_jsx_runtime12.JSX.Element;
+/**
+ * Render props for Flow.Submit component.
+ */
+interface FlowSubmitRenderProps {
+  /** Execute the flow */
+  submit: () => Promise<void>;
+  /** Whether the button should be disabled */
+  isDisabled: boolean;
+  /** Whether currently submitting */
+  isSubmitting: boolean;
+}
+/**
+ * Props for Flow.Submit component.
+ */
+interface FlowSubmitProps {
+  /** Render function receiving submit state */
+  children: ReactNode | ((props: FlowSubmitRenderProps) => ReactNode);
+  /** Additional disabled state */
+  disabled?: boolean;
+}
+/**
+ * Submit primitive that executes the flow with current inputs.
+ * Provides render props for building custom submit buttons.
+ * Automatically disabled when uploading.
+ */
+declare function FlowSubmit({
+  children,
+  disabled
+}: FlowSubmitProps): react_jsx_runtime12.JSX.Element;
+/**
+ * Render props for Flow.Cancel component.
+ */
+interface FlowCancelRenderProps {
+  /** Cancel the flow */
+  cancel: () => void;
+  /** Whether the button should be disabled */
+  isDisabled: boolean;
+}
+/**
+ * Props for Flow.Cancel component.
+ */
+interface FlowCancelProps {
+  /** Render function receiving cancel state */
+  children: ReactNode | ((props: FlowCancelRenderProps) => ReactNode);
+}
+/**
+ * Cancel primitive that aborts the current upload.
+ */
+declare function FlowCancel({
+  children
+}: FlowCancelProps): react_jsx_runtime12.JSX.Element;
+/**
+ * Render props for Flow.Reset component.
+ */
+interface FlowResetRenderProps {
+  /** Reset the flow */
+  reset: () => void;
+  /** Whether the button should be disabled */
+  isDisabled: boolean;
+}
+/**
+ * Props for Flow.Reset component.
+ */
+interface FlowResetProps {
+  /** Render function receiving reset state */
+  children: ReactNode | ((props: FlowResetRenderProps) => ReactNode);
+}
+/**
+ * Reset primitive that clears all inputs and resets to idle state.
+ */
+declare function FlowReset({
+  children
+}: FlowResetProps): react_jsx_runtime12.JSX.Element;
+/**
+ * Render props for Flow.QuickUpload component.
+ */
+interface FlowQuickUploadRenderProps {
+  /** Whether currently uploading */
+  isUploading: boolean;
+  /** Progress percentage (0-100) */
+  progress: number;
+  /** Current status */
+  status: FlowUploadStatus$1;
+  /** Pick a file and start upload immediately */
+  pickAndUpload: () => Promise<void>;
+  /** Abort the current upload */
+  abort: () => void;
+}
+/**
+ * Props for Flow.QuickUpload component.
+ */
+interface FlowQuickUploadProps {
+  /** Render function receiving quick upload state */
+  children: (props: FlowQuickUploadRenderProps) => ReactNode;
+}
+/**
+ * Quick upload component for single-file flows.
+ * Picks a file and starts upload immediately.
+ *
+ * @example
+ * ```tsx
+ * <Flow.QuickUpload>
+ *   {({ isUploading, progress, pickAndUpload, abort }) => (
+ *     <Button
+ *       onPress={isUploading ? abort : pickAndUpload}
+ *       title={isUploading ? `Uploading ${progress}%` : 'Upload File'}
+ *     />
+ *   )}
+ * </Flow.QuickUpload>
+ * ```
+ */
+declare function FlowQuickUpload({
+  children
+}: FlowQuickUploadProps): react_jsx_runtime12.JSX.Element;
+/**
+ * Flow compound component for flow-based file uploads on React Native.
+ *
+ * Provides a composable, headless API for building flow upload interfaces.
+ * All sub-components use render props for complete UI control.
+ *
+ * @example Quick Upload (Single File)
+ * ```tsx
+ * <Flow flowId="image-optimizer" storageId="s3" onSuccess={handleSuccess}>
+ *   <Flow.QuickUpload>
+ *     {({ isUploading, progress, pickAndUpload, abort }) => (
+ *       <View>
+ *         <Button
+ *           onPress={isUploading ? abort : pickAndUpload}
+ *           title={isUploading ? 'Cancel' : 'Upload Image'}
+ *         />
+ *         {isUploading && <Text>{progress}%</Text>}
+ *       </View>
+ *     )}
+ *   </Flow.QuickUpload>
+ * </Flow>
+ * ```
+ *
+ * @example Multi-Input Flow
+ * ```tsx
+ * <Flow flowId="video-processor" storageId="s3">
+ *   <Flow.Inputs>
+ *     {({ inputs, isLoading }) => (
+ *       isLoading ? <ActivityIndicator /> : inputs.map(input => (
+ *         <Flow.Input key={input.nodeId} nodeId={input.nodeId}>
+ *           {({ metadata, pickFile, value }) => (
+ *             <View>
+ *               <Text>{metadata.nodeName}</Text>
+ *               <Button onPress={pickFile} title="Select File" />
+ *               <Flow.Input.Preview>
+ *                 {({ hasFile, fileName }) => hasFile && <Text>{fileName}</Text>}
+ *               </Flow.Input.Preview>
+ *             </View>
+ *           )}
+ *         </Flow.Input>
+ *       ))
+ *     )}
+ *   </Flow.Inputs>
+ *   <CustomSubmitButton />
+ * </Flow>
+ * ```
+ */
+declare const Flow: typeof FlowRoot & {
+  Inputs: typeof FlowInputs;
+  Input: typeof FlowInput & {
+    FilePicker: typeof FlowInputFilePicker;
+    Preview: typeof FlowInputPreview;
+  };
+  Progress: typeof FlowProgress;
+  Status: typeof FlowStatus;
+  Error: typeof FlowError;
+  Submit: typeof FlowSubmit;
+  Cancel: typeof FlowCancel;
+  Reset: typeof FlowReset;
+  QuickUpload: typeof FlowQuickUpload;
+};
 //#endregion
 //#region src/contexts/flow-manager-context.d.ts
 /**
@@ -432,7 +1170,7 @@ interface FlowManagerProviderProps {
  */
 declare function FlowManagerProvider({
   children
-}: FlowManagerProviderProps): react_jsx_runtime3.JSX.Element;
+}: FlowManagerProviderProps): react_jsx_runtime12.JSX.Element;
 /**
  * Hook to access the FlowManager context.
  * Must be used within a FlowManagerProvider.
@@ -697,219 +1435,6 @@ declare function useFileUpload(options?: UseFileUploadOptions): {
   metrics: _uploadista_client_core3.UploadMetrics;
 };
 //#endregion
-//#region src/hooks/use-flow.d.ts
-/**
- * Input metadata discovered from the flow
- */
-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;
-}
-/**
- * Options for the useFlow hook
- */
-interface UseFlowOptions {
-  /** Flow ID to execute */
-  flowId: string;
-  /** Storage ID for the upload */
-  storageId: string;
-  /** Output node ID for the flow */
-  outputNodeId?: string;
-  /** Metadata to pass to flow */
-  metadata?: Record<string, unknown>;
-  /** Called when upload succeeds (receives typed outputs from all output nodes) */
-  onSuccess?: (outputs: TypedOutput[]) => void;
-  /** Called when the flow completes successfully (receives full flow outputs) */
-  onFlowComplete?: (outputs: TypedOutput[]) => void;
-  /** Called when upload fails */
-  onError?: (error: Error) => void;
-  /** Called when upload progress updates */
-  onProgress?: (progress: number, bytesUploaded: number, totalBytes: number | null) => void;
-  /** Called when a chunk completes */
-  onChunkComplete?: (chunkSize: number, bytesAccepted: number, bytesTotal: number | null) => void;
-}
-/**
- * Return value from the useFlow hook 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 reset - Reset state to idle (clears all data)
- * @property retry - Retry the last failed upload
- * @property isActive - 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
- * @property canRetry - True if a retry is possible
- */
-interface UseFlowReturn {
-  /**
-   * Current upload state
-   */
-  state: FlowUploadState;
-  /**
-   * Discovered input nodes metadata (null until discovery completes)
-   */
-  inputMetadata: FlowInputMetadata[] | null;
-  /**
-   * Per-input execution state for multi-input flows
-   */
-  inputStates: ReadonlyMap<string, InputExecutionState>;
-  /**
-   * Current inputs set via setInput()
-   */
-  inputs: 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 (FilePickResult, URL string, or structured data)
-   */
-  setInput: (nodeId: string, value: FilePickResult | string | 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 - FilePickResult from a picker
-   */
-  upload: (file: FilePickResult) => Promise<void>;
-  /**
-   * Abort the current upload
-   */
-  abort: () => void;
-  /**
-   * Reset the upload state and clear all inputs
-   */
-  reset: () => void;
-  /**
-   * Retry the last failed upload
-   */
-  retry: () => void;
-  /**
-   * Whether an upload or flow execution is in progress (uploading OR processing)
-   */
-  isActive: boolean;
-  /**
-   * Whether the file is currently being uploaded (chunks being sent)
-   */
-  isUploadingFile: boolean;
-  /**
-   * Whether the flow is currently processing (after upload completes)
-   */
-  isProcessing: boolean;
-  /**
-   * Whether the hook is discovering flow inputs
-   */
-  isDiscoveringInputs: boolean;
-  /**
-   * Whether a retry is possible (after error or abort with stored inputs)
-   */
-  canRetry: boolean;
-}
-/**
- * React Native hook 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 the unified flow hook that replaces useFlowUpload for advanced use cases.
- * It provides:
- * - Auto-discovery of flow input nodes
- * - Automatic input type detection (FilePickResult -> upload, string -> URL, object -> data)
- * - Progressive input provision via setInput()
- * - Multi-input support with parallel coordination
- * - Per-input state tracking
- *
- * Must be used within FlowManagerProvider (which must be within UploadistaProvider).
- * Flow events are automatically routed by the provider to the appropriate manager.
- *
- * @param options - Flow upload configuration including flow ID and event handlers
- * @returns Flow upload state and control methods
- *
- * @example
- * ```tsx
- * function MyComponent() {
- *   const flow = useFlow({
- *     flowId: 'image-processing-flow',
- *     storageId: 'my-storage',
- *     onSuccess: (outputs) => console.log('Flow complete:', outputs),
- *     onError: (error) => console.error('Flow failed:', error),
- *   });
- *
- *   const handlePickFile = async () => {
- *     const file = await fileSystemProvider.pickDocument();
- *     if (file) {
- *       await flow.upload(file);
- *     }
- *   };
- *
- *   return (
- *     <View>
- *       <Button title="Pick File" onPress={handlePickFile} />
- *       {flow.isActive && <Text>Progress: {flow.state.progress}%</Text>}
- *       {flow.inputMetadata && (
- *         <Text>Found {flow.inputMetadata.length} input nodes</Text>
- *       )}
- *       <Button title="Abort" onPress={flow.abort} disabled={!flow.isActive} />
- *     </View>
- *   );
- * }
- * ```
- *
- * @example
- * ```tsx
- * // Multi-input flow
- * function MultiInputComponent() {
- *   const flow = useFlow({
- *     flowId: 'multi-source-flow',
- *     storageId: 'my-storage',
- *   });
- *
- *   const handlePickPrimary = async () => {
- *     const file = await fileSystemProvider.pickDocument();
- *     if (file.status === 'success') {
- *       flow.setInput('primary-input', file);
- *     }
- *   };
- *
- *   const handleSetUrl = (url: string) => {
- *     flow.setInput('url-input', url);
- *   };
- *
- *   return (
- *     <View>
- *       <Button title="Pick Primary" onPress={handlePickPrimary} />
- *       <TextInput onChangeText={handleSetUrl} placeholder="Enter URL" />
- *       <Button title="Execute" onPress={flow.execute} />
- *     </View>
- *   );
- * }
- * ```
- *
- * @see {@link useFlowUpload} for a simpler file-only upload hook
- */
-declare function useFlow(options: UseFlowOptions): UseFlowReturn;
-//#endregion
 //#region src/hooks/use-multi-upload.d.ts
 interface UploadItemState {
   id: string;
@@ -1202,5 +1727,5 @@ declare function normalizeUri(uri: string): string;
  */
 declare function getMimeTypeFromUri(uri: string): string;
 //#endregion
-export { type Base64Service, type CameraOptions, CameraUploadButton, type CameraUploadButtonProps, type ConnectionMetrics, type ConnectionPoolConfig, type DetailedConnectionMetrics, type FileInfo, type FilePickResult, type FileReaderService, type FileSystemProvider, type FileSystemProviderConfig, FileUploadButton, type FileUploadButtonProps, type FlowInputMetadata, FlowManagerProvider, type FlowUploadState, type FlowUploadStatus, GalleryUploadButton, type GalleryUploadButtonProps, type HttpClient, type IdGenerationService, type InputExecutionState, type MultiUploadState, PermissionStatus, PermissionType, type PickerOptions, type ReactNativeUploadInput, type ServiceContainer, type StorageService, type UploadItemState, UploadList, type UploadListProps, type UploadMetrics, UploadProgress, type UploadProgressProps, type UploadState, type UploadStatus, UploadistaContext, type UploadistaContextType, type UseCameraUploadOptions, type UseFileUploadOptions, type UseFlowOptions, type UseFlowReturn, type UseGalleryUploadOptions, type UseMultiUploadOptions, formatFileSize, getDirectoryFromUri, getFileExtension, getFileNameFromUri, getFileNameWithoutExtension, getMimeTypeFromFileName, getMimeTypeFromUri, getPermissionStatus, hasPermissions, isContentUri, isDocumentFile, isFileSizeValid, isFileTypeAllowed, isFileUri, isImageFile, isVideoFile, normalizeUri, openAppSettings, pathToUri, requestCameraPermission, requestPermissions, requestPhotoLibraryPermission, requestStorageReadPermission, requestStorageWritePermission, uriToPath, useCameraUpload, useFileUpload, useFlow, useFlowManagerContext, useGalleryUpload, useMultiUpload, useUploadMetrics, useUploadistaContext };
+export { type Base64Service, type CameraOptions, CameraUploadButton, type CameraUploadButtonProps, type ConnectionMetrics, type ConnectionPoolConfig, type DetailedConnectionMetrics, type FileInfo, type FilePickResult, type FileReaderService, type FileSystemProvider, type FileSystemProviderConfig, FileUploadButton, type FileUploadButtonProps, Flow, type FlowCancelProps, type FlowCancelRenderProps, type FlowContextValue, type FlowErrorProps, type FlowErrorRenderProps, type FlowInputContextValue, type FlowInputFilePickerProps, type FlowInputFilePickerRenderProps, type FlowInputMetadata, type FlowInputPreviewProps, type FlowInputPreviewRenderProps, type FlowInputProps, type FlowInputsProps, type FlowInputsRenderProps, FlowManagerProvider, type FlowProgressProps, type FlowProgressRenderProps, type FlowProps, type FlowQuickUploadProps, type FlowQuickUploadRenderProps, type FlowRenderProps, type FlowResetProps, type FlowResetRenderProps, type FlowStatusProps, type FlowStatusRenderProps, type FlowSubmitProps, type FlowSubmitRenderProps, type FlowUploadState, type FlowUploadStatus, GalleryUploadButton, type GalleryUploadButtonProps, type HttpClient, type IdGenerationService, type InputExecutionState, type MultiUploadState, PermissionStatus, PermissionType, type PickerOptions, type ReactNativeUploadInput, type ServiceContainer, type StorageService, type UploadItemState, UploadList, type UploadListProps, type UploadMetrics, UploadProgress, type UploadProgressProps, type UploadState, type UploadStatus, UploadistaContext, type UploadistaContextType, type UseCameraUploadOptions, type UseFileUploadOptions, type UseFlowOptions, type UseFlowReturn, type UseGalleryUploadOptions, type UseMultiUploadOptions, formatFileSize, getDirectoryFromUri, getFileExtension, getFileNameFromUri, getFileNameWithoutExtension, getMimeTypeFromFileName, getMimeTypeFromUri, getPermissionStatus, hasPermissions, isContentUri, isDocumentFile, isFileSizeValid, isFileTypeAllowed, isFileUri, isImageFile, isVideoFile, normalizeUri, openAppSettings, pathToUri, requestCameraPermission, requestPermissions, requestPhotoLibraryPermission, requestStorageReadPermission, requestStorageWritePermission, uriToPath, useCameraUpload, useFileUpload, useFlow, useFlowContext, useFlowInputContext, useFlowManagerContext, useGalleryUpload, useMultiUpload, useUploadMetrics, useUploadistaContext };
 //# sourceMappingURL=index.d.mts.map