@uploadista/react 0.0.20-beta.1 → 0.0.20-beta.3

package/dist/{uploadista-provider-CM48PPSp.d.mts → uploadista-provider-C1l0iBc9.d.mts}

@@ -1,55 +1,519 @@
-import { S as FlowInputMetadata, b as UseDragDropReturn, d as UseUploadOptions, f as UseUploadReturn, g as UseFlowUploadReturn, i as MultiUploadOptions, n as UseUploadistaClientReturn, o as UploadItem, s as UseMultiUploadReturn, t as UseUploadistaClientOptions, v as DragDropOptions } from "./use-uploadista-client-m9nF-irM.mjs";
+import { S as UseDragDropReturn, b as DragDropOptions, d as UseUploadOptions, f as UseUploadReturn, i as MultiUploadOptions, m as FlowInputMetadata, n as UseUploadistaClientReturn, o as UploadItem, s as UseMultiUploadReturn, t as UseUploadistaClientOptions, x as DragDropState } from "./use-uploadista-client-DHbLSpIb.mjs";
 import React$1, { ReactNode } from "react";
+import { FlowUploadState, FlowUploadStatus, InputExecutionState } from "@uploadista/client-core";
+import { TypedOutput } from "@uploadista/core/flow";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
-import { BrowserUploadInput, FlowUploadConfig, FlowUploadItem, FlowUploadOptions, MultiFlowUploadOptions, UploadistaEvent } from "@uploadista/client-browser";
+import { BrowserUploadInput, FlowUploadConfig, FlowUploadItem, MultiFlowUploadOptions, UploadistaEvent as UploadistaEvent$1 } from "@uploadista/client-browser";
 
-//#region src/components/flow-input.d.ts
-interface FlowInputProps {
+//#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;
+  /** 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>;
+  /** 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: 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 */
+  isUploading: 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;
+}
+/**
+ * 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 */
-  input: FlowInputMetadata;
-  /** Accepted file types (e.g., "image/*", "video/*") */
+  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 | undefined;
+}
+/**
+ * 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;
+/**
+ * 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;
+  /** Called when flow completes successfully */
+  onSuccess?: (outputs: TypedOutput[]) => void;
+  /** Called when flow fails */
+  onError?: (error: Error) => void;
+  /** Called on upload progress */
+  onProgress?: (uploadId: string, bytesUploaded: number, totalBytes: number | null) => void;
+  /** Called when flow completes with all outputs */
+  onFlowComplete?: (outputs: TypedOutput[]) => void;
+  /** Called when upload is aborted */
+  onAbort?: () => void;
+  /** Children to render */
+  children: ReactNode;
+}
+/**
+ * Root component for flow-based uploads.
+ * Provides context for all Flow sub-components.
+ *
+ * @example
+ * ```tsx
+ * <Flow flowId="image-optimizer" storageId="s3" onSuccess={handleSuccess}>
+ *   <Flow.DropZone accept="image/*">
+ *     {({ isDragging, getRootProps, getInputProps }) => (
+ *       <div {...getRootProps()}>
+ *         <input {...getInputProps()} />
+ *         {isDragging ? "Drop here" : "Drag or click"}
+ *       </div>
+ *     )}
+ *   </Flow.DropZone>
+ * </Flow>
+ * ```
+ */
+declare function FlowRoot({
+  flowId,
+  storageId,
+  outputNodeId,
+  onSuccess,
+  onError,
+  onProgress,
+  onFlowComplete,
+  onAbort,
+  children
+}: FlowProps): react_jsx_runtime0.JSX.Element;
+/**
+ * Render props for Flow.DropZone component.
+ */
+interface FlowDropZoneRenderProps {
+  /** Whether files are being dragged over */
+  isDragging: boolean;
+  /** Whether drag is over the zone */
+  isOver: boolean;
+  /** Upload progress (0-100) */
+  progress: number;
+  /** Current flow status */
+  status: FlowUploadStatus;
+  /** Props to spread on the drop zone container */
+  getRootProps: () => UseDragDropReturn["dragHandlers"];
+  /** Props to spread on the hidden file input */
+  getInputProps: () => UseDragDropReturn["inputProps"];
+  /** Open file picker programmatically */
+  openFilePicker: () => void;
+  /** Current drag-drop state */
+  dragDropState: DragDropState;
+}
+/**
+ * Props for Flow.DropZone component.
+ */
+interface FlowDropZoneProps {
+  /** Accepted file types (e.g., "image/*", ".pdf") */
   accept?: string;
-  /** Whether the input should support URL input */
-  allowUrl?: boolean;
-  /** Current value (File or URL string) */
-  value?: File | string | null;
-  /** Callback when value changes */
-  onChange: (value: File | string) => void;
-  /** Whether the input is disabled */
-  disabled?: boolean;
-  /** Additional CSS classes */
-  className?: string;
+  /** Maximum file size in bytes */
+  maxFileSize?: number;
+  /** Render function receiving drop zone state */
+  children: (props: FlowDropZoneRenderProps) => ReactNode;
 }
 /**
- * Input component for flow execution with file drag-and-drop and URL support.
+ * Drop zone for single-file uploads within a Flow.
+ * Automatically calls flow.upload() when a file is dropped.
  *
- * Features:
- * - File drag-and-drop with visual feedback
- * - URL input for remote files
- * - Displays node name and description
- * - Shows selected file/URL with size
- * - Type validation and error display
+ * @example
+ * ```tsx
+ * <Flow.DropZone accept="image/*">
+ *   {({ isDragging, progress, getRootProps, getInputProps }) => (
+ *     <div {...getRootProps()}>
+ *       <input {...getInputProps()} />
+ *       {isDragging ? "Drop here" : `Progress: ${progress}%`}
+ *     </div>
+ *   )}
+ * </Flow.DropZone>
+ * ```
+ */
+declare function FlowDropZone({
+  accept,
+  maxFileSize,
+  children
+}: FlowDropZoneProps): react_jsx_runtime0.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
- * <FlowInput
- *   input={inputMetadata}
- *   accept="image/*"
- *   allowUrl={true}
- *   value={selectedValue}
- *   onChange={(value) => flow.setInput(inputMetadata.nodeId, value)}
- * />
+ * <Flow.Inputs>
+ *   {({ inputs, isLoading }) => (
+ *     isLoading ? <Spinner /> : (
+ *       inputs.map(input => (
+ *         <Flow.Input key={input.nodeId} nodeId={input.nodeId}>
+ *           ...
+ *         </Flow.Input>
+ *       ))
+ *     )
+ *   )}
+ * </Flow.Inputs>
+ * ```
+ */
+declare function FlowInputs({
+  children
+}: FlowInputsProps): react_jsx_runtime0.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, setValue }) => (
+ *     <div>
+ *       <label>{metadata.nodeName}</label>
+ *       <Flow.Input.DropZone>...</Flow.Input.DropZone>
+ *     </div>
+ *   )}
+ * </Flow.Input>
  * ```
  */
 declare function FlowInput({
-  input,
+  nodeId,
+  children
+}: FlowInputProps): react_jsx_runtime0.JSX.Element | null;
+/**
+ * Render props for Flow.Input.DropZone component.
+ */
+interface FlowInputDropZoneRenderProps {
+  /** Whether files are being dragged over */
+  isDragging: boolean;
+  /** Whether drag is over the zone */
+  isOver: boolean;
+  /** Current value for this input */
+  value: unknown;
+  /** Per-input progress (if available) */
+  progress: number;
+  /** Per-input status (if available) */
+  status: string;
+  /** Props to spread on the drop zone container */
+  getRootProps: () => UseDragDropReturn["dragHandlers"];
+  /** Props to spread on the hidden file input */
+  getInputProps: () => UseDragDropReturn["inputProps"];
+  /** Open file picker programmatically */
+  openFilePicker: () => void;
+  /** Current drag-drop state */
+  dragDropState: DragDropState;
+}
+/**
+ * Props for Flow.Input.DropZone component.
+ */
+interface FlowInputDropZoneProps {
+  /** Accepted file types (e.g., "image/*", ".pdf") */
+  accept?: string;
+  /** Maximum file size in bytes */
+  maxFileSize?: number;
+  /** Render function receiving drop zone state */
+  children: (props: FlowInputDropZoneRenderProps) => ReactNode;
+}
+/**
+ * Drop zone for a specific input within a Flow.Input.
+ * Sets the input value but does NOT trigger upload until Flow.Submit is clicked.
+ */
+declare function FlowInputDropZone({
   accept,
-  allowUrl,
-  value,
-  onChange,
+  maxFileSize,
+  children
+}: FlowInputDropZoneProps): react_jsx_runtime0.JSX.Element;
+/**
+ * Props for Flow.Input.UrlField component.
+ */
+interface FlowInputUrlFieldProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "value" | "onChange" | "type"> {
+  /** Placeholder text */
+  placeholder?: string;
+}
+/**
+ * URL input field for a specific input within a Flow.Input.
+ * Automatically binds to the input context value.
+ */
+declare function FlowInputUrlField({
+  placeholder,
+  ...props
+}: FlowInputUrlFieldProps): react_jsx_runtime0.JSX.Element;
+/**
+ * Render props for Flow.Input.Preview component.
+ */
+interface FlowInputPreviewRenderProps {
+  /** Current value */
+  value: unknown;
+  /** Whether value is a File */
+  isFile: boolean;
+  /** Whether value is a URL string */
+  isUrl: boolean;
+  /** File name (if value is File) */
+  fileName: string | null;
+  /** File size in bytes (if value is File) */
+  fileSize: number | 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_runtime0.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;
+}
+/**
+ * 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_runtime0.JSX.Element;
+/**
+ * Render props for Flow.Status component.
+ */
+interface FlowStatusRenderProps {
+  /** Current status */
+  status: FlowUploadStatus;
+  /** 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_runtime0.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_runtime0.JSX.Element;
+/**
+ * Props for Flow.Submit component.
+ */
+interface FlowSubmitProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "onClick"> {
+  /** Button content */
+  children: ReactNode;
+}
+/**
+ * Submit button that executes the flow with current inputs.
+ * Automatically disabled when uploading.
+ */
+declare function FlowSubmit({
+  children,
   disabled,
-  className
-}: FlowInputProps): react_jsx_runtime0.JSX.Element;
+  ...props
+}: FlowSubmitProps): react_jsx_runtime0.JSX.Element;
+/**
+ * Props for Flow.Cancel component.
+ */
+interface FlowCancelProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "onClick"> {
+  /** Button content */
+  children: ReactNode;
+}
+/**
+ * Cancel button that aborts the current upload.
+ */
+declare function FlowCancel({
+  children,
+  ...props
+}: FlowCancelProps): react_jsx_runtime0.JSX.Element;
+/**
+ * Props for Flow.Reset component.
+ */
+interface FlowResetProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "onClick"> {
+  /** Button content */
+  children: ReactNode;
+}
+/**
+ * Reset button that clears all inputs and resets to idle state.
+ */
+declare function FlowReset({
+  children,
+  ...props
+}: FlowResetProps): react_jsx_runtime0.JSX.Element;
+/**
+ * Flow compound component for flow-based file uploads.
+ *
+ * Provides a composable, headless API for building flow upload interfaces.
+ * All sub-components use render props for complete UI control.
+ *
+ * @example Simple Drop Zone
+ * ```tsx
+ * <Flow flowId="image-optimizer" storageId="s3" onSuccess={handleSuccess}>
+ *   <Flow.DropZone accept="image/*">
+ *     {({ isDragging, progress, getRootProps, getInputProps }) => (
+ *       <div {...getRootProps()}>
+ *         <input {...getInputProps()} />
+ *         {isDragging ? "Drop here" : "Drag or click"}
+ *         {progress > 0 && <progress value={progress} max={100} />}
+ *       </div>
+ *     )}
+ *   </Flow.DropZone>
+ * </Flow>
+ * ```
+ *
+ * @example Multi-Input Flow
+ * ```tsx
+ * <Flow flowId="video-processor" storageId="s3">
+ *   <Flow.Inputs>
+ *     {({ inputs }) => inputs.map(input => (
+ *       <Flow.Input key={input.nodeId} nodeId={input.nodeId}>
+ *         {({ metadata }) => (
+ *           <div>
+ *             <label>{metadata.nodeName}</label>
+ *             <Flow.Input.DropZone accept="video/*">
+ *               {({ getRootProps, getInputProps }) => (
+ *                 <div {...getRootProps()}>
+ *                   <input {...getInputProps()} />
+ *                 </div>
+ *               )}
+ *             </Flow.Input.DropZone>
+ *           </div>
+ *         )}
+ *       </Flow.Input>
+ *     ))}
+ *   </Flow.Inputs>
+ *   <Flow.Submit>Process</Flow.Submit>
+ * </Flow>
+ * ```
+ */
+declare const Flow: typeof FlowRoot & {
+  DropZone: typeof FlowDropZone;
+  Inputs: typeof FlowInputs;
+  Input: typeof FlowInput & {
+    DropZone: typeof FlowInputDropZone;
+    UrlField: typeof FlowInputUrlField;
+    Preview: typeof FlowInputPreview;
+  };
+  Progress: typeof FlowProgress;
+  Status: typeof FlowStatus;
+  Error: typeof FlowError;
+  Submit: typeof FlowSubmit;
+  Cancel: typeof FlowCancel;
+  Reset: typeof FlowReset;
+};
 //#endregion
 //#region src/components/flow-upload-list.d.ts
 /**
@@ -400,276 +864,6 @@ declare function SimpleFlowUploadList({
   accept
 }: SimpleFlowUploadListProps): react_jsx_runtime0.JSX.Element;
 //#endregion
-//#region src/components/flow-upload-zone.d.ts
-/**
- * Render props passed to the FlowUploadZone children function.
- * Provides access to flow upload state, drag-drop handlers, and helper functions.
- *
- * @property dragDrop - Complete drag-and-drop state and handlers
- * @property flowUpload - Flow upload hook with upload state and controls
- * @property isActive - True when dragging over zone
- * @property openFilePicker - Programmatically open file selection dialog
- * @property getRootProps - Returns props to spread on the drop zone container
- * @property getInputProps - Returns props to spread on the hidden file input
- */
-interface FlowUploadZoneRenderProps {
-  /**
-   * Drag and drop state and handlers
-   */
-  dragDrop: UseDragDropReturn;
-  /**
-   * Flow upload functionality
-   */
-  flowUpload: UseFlowUploadReturn;
-  /**
-   * Whether the zone is currently active (dragging or uploading)
-   */
-  isActive: boolean;
-  /**
-   * Open file picker
-   */
-  openFilePicker: () => void;
-  /**
-   * Props to spread on the drop zone element
-   */
-  getRootProps: () => {
-    onDragEnter: (e: React.DragEvent) => void;
-    onDragOver: (e: React.DragEvent) => void;
-    onDragLeave: (e: React.DragEvent) => void;
-    onDrop: (e: React.DragEvent) => void;
-  };
-  /**
-   * Props to spread on the file input element
-   */
-  getInputProps: () => React.InputHTMLAttributes<HTMLInputElement>;
-}
-/**
- * Props for the FlowUploadZone component.
- *
- * @property flowConfig - Flow execution configuration (flowId, storageId, etc.)
- * @property options - Flow upload options (callbacks, metadata, etc.)
- * @property accept - Accepted file types (e.g., "image/*", ".pdf")
- * @property multiple - Allow multiple file selection (default: false)
- * @property children - Render function receiving flow upload zone state
- */
-interface FlowUploadZoneProps {
-  /**
-   * Flow configuration
-   */
-  flowConfig: FlowUploadConfig;
-  /**
-   * Upload options
-   */
-  options?: Omit<FlowUploadOptions, "flowConfig">;
-  /**
-   * Accepted file types (e.g., "image/*", ".pdf", etc.)
-   */
-  accept?: string;
-  /**
-   * Whether to allow multiple files (uses multi-upload internally)
-   */
-  multiple?: boolean;
-  /**
-   * Render function for the drop zone
-   */
-  children: (props: FlowUploadZoneRenderProps) => ReactNode;
-}
-/**
- * Headless flow upload zone component with drag-and-drop support.
- * Combines drag-drop functionality with flow processing, using render props
- * for complete UI control.
- *
- * Files uploaded through this zone are automatically processed through the
- * specified flow, which can perform operations like image optimization,
- * storage saving, webhooks, etc.
- *
- * Must be used within an UploadistaProvider.
- *
- * @param props - Flow upload zone configuration and render prop
- * @returns Rendered flow upload zone using the provided render prop
- *
- * @example
- * ```tsx
- * // Image upload with flow processing
- * <FlowUploadZone
- *   flowConfig={{
- *     flowId: "image-processing-flow",
- *     storageId: "s3-images",
- *     outputNodeId: "optimized-image",
- *   }}
- *   options={{
- *     onSuccess: (result) => console.log('Processed:', result),
- *     onFlowComplete: (outputs) => {
- *       console.log('All outputs:', outputs);
- *     },
- *   }}
- *   accept="image/*"
- * >
- *   {({ dragDrop, flowUpload, getRootProps, getInputProps, openFilePicker }) => (
- *     <div {...getRootProps()} style={{
- *       border: dragDrop.state.isDragging ? '2px solid blue' : '2px dashed gray',
- *       padding: '2rem',
- *       textAlign: 'center'
- *     }}>
- *       <input {...getInputProps()} />
- *
- *       {dragDrop.state.isDragging && (
- *         <p>Drop image here...</p>
- *       )}
- *
- *       {!dragDrop.state.isDragging && !flowUpload.isUploading && (
- *         <div>
- *           <p>Drag an image or click to browse</p>
- *           <button onClick={openFilePicker}>Choose File</button>
- *         </div>
- *       )}
- *
- *       {flowUpload.isUploadingFile && (
- *         <div>
- *           <p>Uploading...</p>
- *           <progress value={flowUpload.state.progress} max={100} />
- *           <span>{flowUpload.state.progress}%</span>
- *         </div>
- *       )}
- *
- *       {flowUpload.isProcessing && (
- *         <div>
- *           <p>Processing image...</p>
- *           {flowUpload.state.currentNodeName && (
- *             <span>Step: {flowUpload.state.currentNodeName}</span>
- *           )}
- *         </div>
- *       )}
- *
- *       {flowUpload.state.status === "success" && (
- *         <div>
- *           <p>✓ Upload complete!</p>
- *           {flowUpload.state.result && (
- *             <img src={flowUpload.state.result.url} alt="Uploaded" />
- *           )}
- *         </div>
- *       )}
- *
- *       {flowUpload.state.status === "error" && (
- *         <div>
- *           <p>Error: {flowUpload.state.error?.message}</p>
- *           <button onClick={flowUpload.reset}>Try Again</button>
- *         </div>
- *       )}
- *
- *       {flowUpload.isUploading && (
- *         <button onClick={flowUpload.abort}>Cancel</button>
- *       )}
- *     </div>
- *   )}
- * </FlowUploadZone>
- * ```
- *
- * @see {@link SimpleFlowUploadZone} for a pre-styled version
- * @see {@link useFlowUpload} for the underlying hook
- */
-declare function FlowUploadZone({
-  flowConfig,
-  options,
-  accept,
-  multiple,
-  children
-}: FlowUploadZoneProps): react_jsx_runtime0.JSX.Element;
-/**
- * Props for the SimpleFlowUploadZone component.
- *
- * @property flowConfig - Flow execution configuration
- * @property options - Flow upload options (callbacks, metadata)
- * @property accept - Accepted file types
- * @property className - CSS class name for custom styling
- * @property dragText - Text displayed when dragging files over zone
- * @property idleText - Text displayed when zone is idle
- */
-interface SimpleFlowUploadZoneProps {
-  /**
-   * Flow configuration
-   */
-  flowConfig: FlowUploadConfig;
-  /**
-   * Upload options
-   */
-  options?: Omit<FlowUploadOptions, "flowConfig">;
-  /**
-   * Accepted file types
-   */
-  accept?: string;
-  /**
-   * CSS class for the container
-   */
-  className?: string;
-  /**
-   * Custom drag overlay text
-   */
-  dragText?: string;
-  /**
-   * Custom idle text
-   */
-  idleText?: string;
-}
-/**
- * Simple pre-styled flow upload zone component with built-in UI.
- * Provides a ready-to-use drag-and-drop interface for flow uploads.
- *
- * Features:
- * - Built-in drag-and-drop visual feedback
- * - Automatic progress display for upload and processing phases
- * - Success and error state display
- * - Cancel button during upload
- * - Customizable text labels
- *
- * @param props - Flow upload zone configuration with styling options
- * @returns Styled flow upload zone component
- *
- * @example
- * ```tsx
- * // Basic image upload with flow processing
- * <SimpleFlowUploadZone
- *   flowConfig={{
- *     flowId: "image-optimization-flow",
- *     storageId: "s3-images",
- *   }}
- *   accept="image/*"
- *   options={{
- *     onSuccess: (result) => console.log("Image processed:", result),
- *     onError: (error) => console.error("Processing failed:", error),
- *   }}
- *   idleText="Drop an image to optimize and upload"
- *   dragText="Release to start processing"
- *   className="my-upload-zone"
- * />
- *
- * // Document upload with custom flow
- * <SimpleFlowUploadZone
- *   flowConfig={{
- *     flowId: "document-processing-flow",
- *     storageId: "docs",
- *     outputNodeId: "processed-doc",
- *   }}
- *   accept=".pdf,.doc,.docx"
- *   options={{
- *     onFlowComplete: (outputs) => {
- *       console.log('Processing outputs:', outputs);
- *     },
- *   }}
- * />
- * ```
- *
- * @see {@link FlowUploadZone} for the headless version with full control
- */
-declare function SimpleFlowUploadZone({
-  flowConfig,
-  options,
-  accept,
-  className,
-  dragText,
-  idleText
-}: SimpleFlowUploadZoneProps): react_jsx_runtime0.JSX.Element;
-//#endregion
 //#region src/components/upload-list.d.ts
 /**
  * Render props passed to the UploadList children function.
@@ -1198,7 +1392,7 @@ type UploadistaContextValue = UseUploadistaClientReturn & {
    * Subscribe to events (used internally by hooks)
    * @internal
    */
-  subscribeToEvents: (handler: (event: UploadistaEvent) => void) => () => void;
+  subscribeToEvents: (handler: (event: UploadistaEvent$1) => void) => () => void;
 };
 /**
  * Context provider that provides uploadista client functionality to child components.
@@ -1279,5 +1473,5 @@ declare function UploadistaProvider({
  */
 declare function useUploadistaContext(): UploadistaContextValue;
 //#endregion
-export { SimpleFlowUploadListItemProps as C, FlowInputProps as E, SimpleFlowUploadListItem as S, FlowInput as T, SimpleFlowUploadZoneProps as _, UploadZone as a, FlowUploadListRenderProps as b, SimpleUploadListItem as c, UploadListProps as d, UploadListRenderProps as f, SimpleFlowUploadZone as g, FlowUploadZoneRenderProps as h, SimpleUploadZoneProps as i, SimpleUploadListItemProps as l, FlowUploadZoneProps as m, useUploadistaContext as n, UploadZoneProps as o, FlowUploadZone as p, SimpleUploadZone as r, UploadZoneRenderProps as s, UploadistaProvider as t, UploadList as u, FlowUploadList as v, SimpleFlowUploadListProps as w, SimpleFlowUploadList as x, FlowUploadListProps as y };
-//# sourceMappingURL=uploadista-provider-CM48PPSp.d.mts.map
+export { FlowInputPreviewProps as A, FlowStatusProps as B, FlowDropZoneProps as C, FlowInputContextValue as D, FlowErrorRenderProps as E, FlowInputsRenderProps as F, FlowSubmitProps as H, FlowProgressProps as I, FlowProgressRenderProps as L, FlowInputProps as M, FlowInputUrlFieldProps as N, FlowInputDropZoneProps as O, FlowInputsProps as P, FlowProps as R, FlowContextValue as S, FlowErrorProps as T, useFlowContext as U, FlowStatusRenderProps as V, useFlowInputContext as W, SimpleFlowUploadListItem as _, UploadZone as a, Flow as b, SimpleUploadListItem as c, UploadListProps as d, UploadListRenderProps as f, SimpleFlowUploadList as g, FlowUploadListRenderProps as h, SimpleUploadZoneProps as i, FlowInputPreviewRenderProps as j, FlowInputDropZoneRenderProps as k, SimpleUploadListItemProps as l, FlowUploadListProps as m, useUploadistaContext as n, UploadZoneProps as o, FlowUploadList as p, SimpleUploadZone as r, UploadZoneRenderProps as s, UploadistaProvider as t, UploadList as u, SimpleFlowUploadListItemProps as v, FlowDropZoneRenderProps as w, FlowCancelProps as x, SimpleFlowUploadListProps as y, FlowResetProps as z };
+//# sourceMappingURL=uploadista-provider-C1l0iBc9.d.mts.map