@uploadista/core 0.0.16 → 0.0.17-beta.2

package/dist/{index-Dp6mTOB2.d.cts → index-D9YSNFdA.d.cts}

@@ -162,8 +162,6 @@ declare enum NodeType {
   input = "input",
   /** Transforms data during flow execution */
   process = "process",
-  /** Saves data to storage backends */
-  output = "output",
   /** Routes data based on conditions */
   conditional = "conditional",
   /** Splits data to multiple outputs */
@@ -201,7 +199,7 @@ type ConditionValue = string | number;
  * @param config.id - Unique identifier for this node in the flow
  * @param config.name - Human-readable name for the node
  * @param config.description - Description of what this node does
- * @param config.type - The type of node (input, process, output, conditional, multiplex, merge)
+ * @param config.type - The type of node (input, process, conditional, multiplex, merge)
  * @param config.inputSchema - Zod schema for validating input data
  * @param config.outputSchema - Zod schema for validating output data
  * @param config.run - The processing function to execute for this node
@@ -213,7 +211,7 @@ type ConditionValue = string | number;
  * @param config.retry.maxRetries - Maximum number of retry attempts (default: 0)
  * @param config.retry.retryDelay - Base delay in milliseconds between retries (default: 1000)
  * @param config.retry.exponentialBackoff - Whether to use exponential backoff for retries (default: true)
- * @param config.nodeTypeId - Optional type ID from the registry (e.g., "storage-output-v1"). If provided, the node type must be registered and its category must match the node type (input/output).
+ * @param config.nodeTypeId - Optional type ID from the registry (e.g., "storage-output-v1"). If provided, the node type must be registered.
  *
  * @returns An Effect that succeeds with the created FlowNode
  *
@@ -597,11 +595,6 @@ type BuiltInTypedOutput = {
   data: UploadFile;
   nodeId: string;
   timestamp: string;
-} | {
-  nodeType: "streaming-input-v1";
-  data: UploadFile;
-  nodeId: string;
-  timestamp: string;
 };
 /**
  * Custom typed output for user-defined node types.
@@ -637,7 +630,6 @@ type CustomTypedOutput<T = unknown> = {
  * @remarks
  * **Built-in types (automatic narrowing):**
  * - `storage-output-v1` - Storage node output (UploadFile)
- * - `streaming-input-v1` - Streaming input node (UploadFile)
  *
  * Use switch statements for automatic narrowing:
  * ```typescript
@@ -647,10 +639,6 @@ type CustomTypedOutput<T = unknown> = {
  *       // ✅ output.data is automatically UploadFile
  *       console.log(output.data.url);
  *       break;
- *     case 'streaming-input-v1':
- *       // ✅ output.data is automatically UploadFile
- *       console.log(output.data.size);
- *       break;
  *   }
  * }
  * ```
@@ -991,6 +979,45 @@ type FlowConfig<TFlowInputSchema extends z.ZodSchema<any>, TFlowOutputSchema ext
     enabled?: boolean;
     maxConcurrency?: number;
   };
+  hooks?: {
+    /**
+     * Called when a sink node (terminal node with no outgoing edges) produces an output.
+     * This hook runs after auto-persistence for UploadFile outputs.
+     *
+     * Use this hook to perform additional post-processing such as:
+     * - Saving output metadata to a database
+     * - Tracking outputs in external systems
+     * - Adding custom metadata to outputs
+     * - Triggering downstream workflows
+     *
+     * The hook receives the output and context, and can optionally modify
+     * and return the output (e.g., adding metadata fields).
+     *
+     * @param context - Output context including the output data, node ID, flow ID, etc.
+     * @returns Effect that resolves to the (optionally modified) output
+     *
+     * @example
+     * ```typescript
+     * hooks: {
+     *   onNodeOutput: ({ output, nodeId, flowId }) =>
+     *     Effect.gen(function* () {
+     *       // Save to database
+     *       yield* saveToDatabase(output);
+     *       // Return output with additional metadata
+     *       return { ...output, metadata: { ...output.metadata, tracked: true } };
+     *     })
+     * }
+     * ```
+     */
+    onNodeOutput?: <TOutput>(context: {
+      output: TOutput;
+      nodeId: string;
+      flowId: string;
+      jobId: string;
+      storageId: string;
+      clientId: string | null;
+    }) => Effect.Effect<TOutput, UploadistaError, any>;
+  };
 };
 //#endregion
 //#region src/flow/edge.d.ts
@@ -1045,1101 +1072,1117 @@ declare function createFlowEdge({
   targetPort?: string;
 }): FlowEdge;
 //#endregion
-//#region src/flow/flow.d.ts
+//#region src/types/kv-store.d.ts
 /**
- * Serialized flow data for storage and transport.
- * Contains the minimal information needed to reconstruct a flow.
+ * Base key-value store interface for raw string storage.
  *
- * @property id - Unique flow identifier
- * @property name - Human-readable flow name
- * @property nodes - Array of node data (without execution logic)
- * @property edges - Connections between nodes defining data flow
- */
-type FlowData = {
-  id: string;
-  name: string;
-  nodes: FlowNodeData[];
-  edges: FlowEdge[];
-};
-/**
- * Extracts serializable flow data from a Flow instance.
- * Useful for storing flow definitions or sending them over the network.
+ * This is the low-level interface that storage adapters implement.
+ * It stores raw string values without type safety or serialization.
  *
- * @template TRequirements - Effect requirements for the flow
- * @param flow - Flow instance to extract data from
- * @returns Serializable flow data without execution logic
+ * @property get - Retrieves a value by key, returns null if not found
+ * @property set - Stores a value with the given key
+ * @property delete - Removes a value by key
+ * @property list - Optional operation to list all keys with a given prefix
  *
  * @example
  * ```typescript
- * const flowData = getFlowData(myFlow);
- * // Store in database or send to client
- * await db.flows.save(flowData);
+ * // Implement a BaseKvStore with Redis
+ * const redisKvStore: BaseKvStore = {
+ *   get: (key) => Effect.tryPromise({
+ *     try: () => redis.get(key),
+ *     catch: (error) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause: error })
+ *   }),
+ *
+ *   set: (key, value) => Effect.tryPromise({
+ *     try: () => redis.set(key, value),
+ *     catch: (error) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause: error })
+ *   }),
+ *
+ *   delete: (key) => Effect.tryPromise({
+ *     try: () => redis.del(key),
+ *     catch: (error) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause: error })
+ *   }),
+ *
+ *   list: (prefix) => Effect.tryPromise({
+ *     try: () => redis.keys(`${prefix}*`),
+ *     catch: (error) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause: error })
+ *   })
+ * };
  * ```
  */
-declare const getFlowData: <TRequirements>(flow: Flow<any, any, TRequirements>) => FlowData;
+interface BaseKvStore {
+  readonly get: (key: string) => Effect.Effect<string | null, UploadistaError>;
+  readonly set: (key: string, value: string) => Effect.Effect<void, UploadistaError>;
+  readonly delete: (key: string) => Effect.Effect<void, UploadistaError>;
+  readonly list?: (keyPrefix: string) => Effect.Effect<Array<string>, UploadistaError>;
+}
 /**
- * Result of a flow execution - either completed or paused.
+ * Type-safe key-value store interface with automatic serialization.
  *
- * @template TOutput - Type of the flow's output data
+ * This wraps a BaseKvStore and handles JSON serialization/deserialization
+ * for a specific data type, providing type safety and eliminating the need
+ * for manual JSON.stringify/parse calls.
  *
- * @remarks
- * Flows can pause when a node needs additional data (e.g., waiting for user input
- * or external service). The execution state allows resuming from where it paused.
+ * @template TData - The type of data stored in this KV store
+ *
+ * @property get - Retrieves and deserializes a value, fails if not found
+ * @property set - Serializes and stores a value
+ * @property delete - Removes a value by key
+ * @property list - Optional operation to list all keys (without prefix)
  *
  * @example
  * ```typescript
- * const result = await Effect.runPromise(flow.run({ inputs, storageId, jobId }));
+ * // Use a typed KV store
+ * const uploadStore: KvStore<UploadFile> = new TypedKvStore(
+ *   baseStore,
+ *   "uploads:",
+ *   jsonSerializer.serialize,
+ *   jsonSerializer.deserialize
+ * );
  *
- * if (result.type === "completed") {
- *   console.log("Flow completed:", result.result);
- * } else {
- *   console.log("Flow paused at node:", result.nodeId);
- *   // Can resume later with: flow.resume({ jobId, executionState: result.executionState, ... })
- * }
+ * // Store and retrieve typed data
+ * const program = Effect.gen(function* () {
+ *   const file: UploadFile = {
+ *     id: "file123",
+ *     offset: 0,
+ *     storage: { id: "s3", type: "s3" }
+ *   };
+ *
+ *   // Automatic serialization
+ *   yield* uploadStore.set("file123", file);
+ *
+ *   // Automatic deserialization with type safety
+ *   const retrieved = yield* uploadStore.get("file123");
+ *   console.log(retrieved.offset); // TypeScript knows this is a number
+ * });
  * ```
  */
-type FlowExecutionResult<TOutput> = {
-  type: "completed";
-  result: TOutput;
-  outputs?: TypedOutput[];
-} | {
-  type: "paused";
-  nodeId: string;
-  executionState: {
-    executionOrder: string[];
-    currentIndex: number;
-    inputs: Record<string, unknown>;
-  };
+type KvStore<TData> = {
+  readonly get: (key: string) => Effect.Effect<TData, UploadistaError>;
+  readonly set: (key: string, value: TData) => Effect.Effect<void, UploadistaError>;
+  readonly delete: (key: string) => Effect.Effect<void, UploadistaError>;
+  readonly list?: () => Effect.Effect<Array<string>, UploadistaError>;
 };
 /**
- * A Flow represents a directed acyclic graph (DAG) of processing nodes.
- *
- * Flows execute nodes in topological order, passing data between nodes through edges.
- * They support conditional execution, retry logic, pausable nodes, and event emission.
- *
- * @template TFlowInputSchema - Zod schema defining the shape of input data
- * @template TFlowOutputSchema - Zod schema defining the shape of output data
- * @template TRequirements - Effect requirements (services/contexts) needed by nodes
+ * Typed wrapper class that adds serialization to a BaseKvStore.
  *
- * @property id - Unique flow identifier
- * @property name - Human-readable flow name
- * @property nodes - Array of nodes in the flow
- * @property edges - Connections between nodes
- * @property inputSchema - Zod schema for validating flow inputs
- * @property outputSchema - Zod schema for validating flow outputs
- * @property onEvent - Optional callback for flow execution events
- * @property run - Executes the flow from the beginning
- * @property resume - Resumes a paused flow execution
- * @property validateTypes - Validates node type compatibility
- * @property validateInputs - Validates input data against schema
- * @property validateOutputs - Validates output data against schema
+ * This class implements the KvStore interface by wrapping a BaseKvStore
+ * and handling serialization/deserialization for a specific type. It also
+ * adds a key prefix to isolate different data types in the same store.
  *
- * @remarks
- * Flows are created using {@link createFlowWithSchema}. The Effect-based design
- * allows for composable error handling, resource management, and dependency injection.
+ * @template TData - The type of data to store
  *
  * @example
  * ```typescript
- * const flow = yield* createFlowWithSchema({
- *   flowId: "image-pipeline",
- *   name: "Image Processing Pipeline",
- *   nodes: [inputNode, resizeNode, optimizeNode, storageNode],
- *   edges: [
- *     { source: "input", target: "resize" },
- *     { source: "resize", target: "optimize" },
- *     { source: "optimize", target: "storage" }
- *   ],
- *   inputSchema: z.object({ file: z.instanceof(File) }),
- *   outputSchema: uploadFileSchema
- * });
+ * // Create a typed store for UploadFile
+ * const uploadFileStore = new TypedKvStore<UploadFile>(
+ *   baseKvStore,
+ *   "uploadista:upload-file:", // All keys will be prefixed
+ *   (data) => JSON.stringify(data),
+ *   (str) => JSON.parse(str) as UploadFile
+ * );
  *
- * const result = yield* flow.run({
- *   inputs: { input: { file: myFile } },
- *   storageId: "storage-1",
- *   jobId: "job-123"
+ * // Use the store
+ * const effect = Effect.gen(function* () {
+ *   const file: UploadFile = { ... };
+ *   yield* uploadFileStore.set("abc123", file);
+ *   // Internally stores at key "uploadista:upload-file:abc123"
+ *
+ *   const retrieved = yield* uploadFileStore.get("abc123");
+ *   return retrieved;
  * });
+ *
+ * // Custom serialization for binary data
+ * const binaryStore = new TypedKvStore<Uint8Array>(
+ *   baseKvStore,
+ *   "binary:",
+ *   (data) => btoa(String.fromCharCode(...data)), // Base64 encode
+ *   (str) => Uint8Array.from(atob(str), c => c.charCodeAt(0)) // Base64 decode
+ * );
  * ```
  */
-type Flow<TFlowInputSchema extends z.ZodSchema<any>, TFlowOutputSchema extends z.ZodSchema<any>, TRequirements> = {
-  id: string;
-  name: string;
-  nodes: FlowNode<any, any, UploadistaError>[];
-  edges: FlowEdge[];
-  inputSchema: TFlowInputSchema;
-  outputSchema: TFlowOutputSchema;
-  onEvent?: FlowConfig<TFlowInputSchema, TFlowOutputSchema, TRequirements>["onEvent"];
-  checkJobStatus?: FlowConfig<TFlowInputSchema, TFlowOutputSchema, TRequirements>["checkJobStatus"];
-  run: (args: {
-    inputs?: Record<string, z.infer<TFlowInputSchema>>;
-    storageId: string;
-    jobId: string;
-    clientId: string | null;
-  }) => Effect.Effect<FlowExecutionResult<Record<string, z.infer<TFlowOutputSchema>>>, UploadistaError, TRequirements>;
-  resume: (args: {
-    jobId: string;
-    storageId: string;
-    nodeResults: Record<string, unknown>;
-    executionState: {
-      executionOrder: string[];
-      currentIndex: number;
-      inputs: Record<string, z.infer<TFlowInputSchema>>;
-    };
-    clientId: string | null;
-  }) => Effect.Effect<FlowExecutionResult<Record<string, z.infer<TFlowOutputSchema>>>, UploadistaError, TRequirements>;
-  validateTypes: () => {
-    isValid: boolean;
-    errors: string[];
-  };
-  validateInputs: (inputs: unknown) => {
-    isValid: boolean;
-    errors: string[];
-  };
-  validateOutputs: (outputs: unknown) => {
-    isValid: boolean;
-    errors: string[];
-  };
-};
+declare class TypedKvStore<TData> implements KvStore<TData> {
+  private baseStore;
+  private keyPrefix;
+  private serialize;
+  private deserialize;
+  constructor(baseStore: BaseKvStore, keyPrefix: string, serialize: (data: TData) => string, deserialize: (str: string) => TData);
+  get: (key: string) => Effect.Effect<TData, UploadistaError>;
+  set: (key: string, value: TData) => Effect.Effect<void, UploadistaError>;
+  delete: (key: string) => Effect.Effect<void, UploadistaError>;
+  list: () => Effect.Effect<Array<string>, UploadistaError>;
+}
 /**
- * Creates a new Flow with Zod schema-based type validation.
+ * Default JSON serialization helpers.
  *
- * This is the primary way to create flows in Uploadista. It constructs a Flow
- * instance that validates inputs/outputs, executes nodes in topological order,
- * handles errors with retries, and emits events during execution.
+ * These functions provide standard JSON serialization for use with TypedKvStore.
+ * They work with any JSON-serializable type.
  *
- * @template TFlowInputSchema - Zod schema for flow input validation
- * @template TFlowOutputSchema - Zod schema for flow output validation
- * @template TRequirements - Effect requirements/services needed by the flow
- * @template TNodeError - Union of possible errors from nodes
- * @template TNodeRequirements - Union of requirements from nodes
+ * @example
+ * ```typescript
+ * const store = new TypedKvStore<MyType>(
+ *   baseStore,
+ *   "mydata:",
+ *   jsonSerializer.serialize,
+ *   jsonSerializer.deserialize
+ * );
+ * ```
+ */
+declare const jsonSerializer: {
+  serialize: <T>(data: T) => string;
+  deserialize: <T>(str: string) => T;
+};
+declare const BaseKvStoreService_base: Context.TagClass<BaseKvStoreService, "BaseKvStore", BaseKvStore>;
+/**
+ * Effect-TS context tag for the base untyped KV store.
  *
- * @param config - Flow configuration object
- * @param config.flowId - Unique identifier for the flow
- * @param config.name - Human-readable flow name
- * @param config.nodes - Array of nodes (can be plain nodes or Effects resolving to nodes)
- * @param config.edges - Array of edges connecting nodes
- * @param config.inputSchema - Zod schema for validating inputs
- * @param config.outputSchema - Zod schema for validating outputs
- * @param config.typeChecker - Optional custom type compatibility checker
- * @param config.onEvent - Optional event callback for monitoring execution
+ * This is the low-level store that storage adapter implementations provide.
+ * Most application code should use typed stores like UploadFileKVStore instead.
  *
- * @returns Effect that resolves to a Flow instance
+ * @example
+ * ```typescript
+ * // Provide a base store implementation
+ * const baseStoreLayer = Layer.succeed(BaseKvStoreService, redisKvStore);
  *
- * @throws {UploadistaError} FLOW_CYCLE_ERROR if the graph contains cycles
- * @throws {UploadistaError} FLOW_NODE_NOT_FOUND if a node is referenced but missing
- * @throws {UploadistaError} FLOW_NODE_ERROR if node execution fails
- * @throws {UploadistaError} FLOW_OUTPUT_VALIDATION_ERROR if outputs don't match schema
+ * // Use in an Effect
+ * const effect = Effect.gen(function* () {
+ *   const baseStore = yield* BaseKvStoreService;
+ *   yield* baseStore.set("raw-key", "raw-value");
+ * });
+ * ```
+ */
+declare class BaseKvStoreService extends BaseKvStoreService_base {}
+declare const UploadFileKVStore_base: Context.TagClass<UploadFileKVStore, "UploadFileKVStore", KvStore<UploadFile>>;
+/**
+ * Effect-TS context tag for the UploadFile typed KV store.
  *
- * @remarks
- * - Nodes can be provided as plain objects or as Effects that resolve to nodes
- * - The flow performs topological sorting to determine execution order
- * - Conditional nodes are evaluated before execution
- * - Nodes can specify retry configuration with exponential backoff
- * - Pausable nodes can halt execution and resume later
+ * This provides type-safe storage for UploadFile metadata. It's the primary
+ * way to store and retrieve upload metadata in the system.
  *
  * @example
  * ```typescript
- * const flow = yield* createFlowWithSchema({
- *   flowId: "image-upload",
- *   name: "Image Upload with Processing",
- *   nodes: [
- *     inputNode,
- *     yield* createResizeNode({ width: 1920, height: 1080 }),
- *     optimizeNode,
- *     storageNode
- *   ],
- *   edges: [
- *     { source: "input", target: "resize" },
- *     { source: "resize", target: "optimize" },
- *     { source: "optimize", target: "storage" }
- *   ],
- *   inputSchema: z.object({
- *     file: z.instanceof(File),
- *     metadata: z.record(z.string(), z.any()).optional()
- *   }),
- *   outputSchema: uploadFileSchema,
- *   onEvent: (event) => Effect.gen(function* () {
- *     console.log("Flow event:", event);
- *     return { eventId: event.jobId };
- *   })
+ * const uploadEffect = Effect.gen(function* () {
+ *   const kvStore = yield* UploadFileKVStore;
+ *
+ *   // Store upload metadata
+ *   const file: UploadFile = {
+ *     id: "upload123",
+ *     offset: 0,
+ *     storage: { id: "s3", type: "s3" }
+ *   };
+ *   yield* kvStore.set("upload123", file);
+ *
+ *   // Retrieve with type safety
+ *   const retrieved = yield* kvStore.get("upload123");
+ *   return retrieved;
  * });
  * ```
- *
- * @see {@link Flow} for the returned flow type
- * @see {@link FlowConfig} for configuration options
  */
-declare function createFlowWithSchema<TFlowInputSchema extends z.ZodSchema<any>, TFlowOutputSchema extends z.ZodSchema<any>, TRequirements = never, TNodeError = never, TNodeRequirements = never>(config: FlowConfig<TFlowInputSchema, TFlowOutputSchema, TNodeError, TNodeRequirements>): Effect.Effect<Flow<TFlowInputSchema, TFlowOutputSchema, TRequirements>, TNodeError, TNodeRequirements>;
-//#endregion
-//#region src/flow/type-registry.d.ts
+declare class UploadFileKVStore extends UploadFileKVStore_base {}
 /**
- * Node type category - determines where the node appears in the flow.
+ * Effect Layer that creates the UploadFileKVStore from a BaseKvStore.
  *
- * - `input`: Nodes that receive data from external sources (e.g., file uploads)
- * - `output`: Nodes that produce final results (e.g., storage, webhooks, descriptions)
+ * This layer automatically wires up JSON serialization for UploadFile objects
+ * with the "uploadista:upload-file:" key prefix.
+ *
+ * @example
+ * ```typescript
+ * const program = Effect.gen(function* () {
+ *   const kvStore = yield* UploadFileKVStore;
+ *   // Use the store...
+ * }).pipe(
+ *   Effect.provide(uploadFileKvStore),
+ *   Effect.provide(baseStoreLayer)
+ * );
+ * ```
  */
-type NodeTypeCategory = "input" | "output";
+declare const uploadFileKvStore: Layer.Layer<UploadFileKVStore, never, BaseKvStoreService>;
+declare const FlowJobKVStore_base: Context.TagClass<FlowJobKVStore, "FlowJobKVStore", KvStore<FlowJob>>;
 /**
- * Defines a registered node type with its schema and metadata.
+ * Effect-TS context tag for the FlowJob typed KV store.
  *
- * Node type definitions are registered globally and used to validate and type-narrow
- * flow results at runtime. Each definition includes:
- * - A unique identifier with versioning
- * - A category (input or output)
- * - A Zod schema for runtime validation
- * - A semantic version for evolution
- * - A human-readable description
+ * This provides type-safe storage for FlowJob metadata, tracking the
+ * execution state of flow processing jobs.
  *
- * @template TSchema - The Zod schema type for this node's data
+ * @example
+ * ```typescript
+ * const flowEffect = Effect.gen(function* () {
+ *   const jobStore = yield* FlowJobKVStore;
  *
- * @property id - Unique identifier (e.g., "storage-output-v1", "webhook-output-v1")
- * @property category - Whether this is an input or output node type
- * @property schema - Zod schema for validating data produced by this node type
- * @property version - Semantic version (e.g., "1.0.0") for tracking type evolution
- * @property description - Human-readable explanation of what this node type does
+ *   // Store job state
+ *   const job: FlowJob = {
+ *     id: "job123",
+ *     flowId: "flow_resize",
+ *     status: "running",
+ *     tasks: [],
+ *     createdAt: new Date(),
+ *     updatedAt: new Date()
+ *   };
+ *   yield* jobStore.set("job123", job);
+ *
+ *   // Retrieve and check status
+ *   const retrieved = yield* jobStore.get("job123");
+ *   return retrieved.status;
+ * });
+ * ```
+ */
+declare class FlowJobKVStore extends FlowJobKVStore_base {}
+/**
+ * Effect Layer that creates the FlowJobKVStore from a BaseKvStore.
+ *
+ * This layer automatically wires up JSON serialization for FlowJob objects
+ * with the "uploadista:flow-job:" key prefix.
  *
  * @example
  * ```typescript
- * const storageOutputDef: NodeTypeDefinition<z.infer<typeof uploadFileSchema>> = {
- *   id: "storage-output-v1",
- *   category: "output",
- *   schema: uploadFileSchema,
- *   version: "1.0.0",
- *   description: "Storage output node that saves files to configured storage backend",
- * };
+ * const program = Effect.gen(function* () {
+ *   const jobStore = yield* FlowJobKVStore;
+ *   // Use the store...
+ * }).pipe(
+ *   Effect.provide(flowJobKvStore),
+ *   Effect.provide(baseStoreLayer)
+ * );
  * ```
  */
-interface NodeTypeDefinition<TSchema = unknown> {
-  id: string;
-  category: NodeTypeCategory;
-  schema: z.ZodSchema<TSchema>;
-  version: string;
-  description: string;
-}
+declare const flowJobKvStore: Layer.Layer<FlowJobKVStore, never, BaseKvStoreService>;
+//#endregion
+//#region src/types/data-store.d.ts
 /**
- * Result type for validation operations.
+ * Options for writing data to a DataStore.
  *
- * @template T - The expected type on successful validation
+ * @property file_id - Unique identifier for the file being written
+ * @property stream - Stream of byte chunks to write to storage
+ * @property offset - Byte offset where writing should begin (for resumable uploads)
  */
-type ValidationResult<T> = {
-  success: true;
-  data: T;
-} | {
-  success: false;
-  error: UploadistaError;
+type DataStoreWriteOptions = {
+  file_id: string;
+  stream: Stream.Stream<Uint8Array, UploadistaError>;
+  offset: number;
 };
 /**
- * Central registry for node type definitions.
+ * Upload strategy type indicating how chunks are uploaded.
  *
- * The FlowTypeRegistry maintains a global registry of node types with their schemas
- * and metadata. It provides methods for:
- * - Registering new node types
- * - Retrieving type definitions
- * - Listing types by category
- * - Validating data against registered schemas
+ * - `single`: Upload file in a single request (traditional upload)
+ * - `parallel`: Upload file chunks in parallel (for large files)
+ */
+type UploadStrategy = "single" | "parallel";
+/**
+ * Capabilities and constraints of a DataStore implementation.
  *
- * The registry is immutable after registration - types cannot be modified or removed
- * once registered to prevent runtime errors.
+ * This type describes what features a storage backend supports and what
+ * limitations it has. Use this to determine the optimal upload strategy
+ * and validate client requests.
  *
- * @remarks
- * - This is a singleton - use the exported `flowTypeRegistry` instance
- * - Types cannot be unregistered or modified after registration
- * - Duplicate type IDs are rejected
- * - Version strings should follow semantic versioning
+ * @property supportsParallelUploads - Can upload chunks in parallel (e.g., S3 multipart)
+ * @property supportsConcatenation - Can concatenate multiple uploads into one file
+ * @property supportsDeferredLength - Can start upload without knowing final size
+ * @property supportsResumableUploads - Can resume interrupted uploads from last offset
+ * @property supportsTransactionalUploads - Guarantees atomic upload success/failure
+ * @property maxConcurrentUploads - Maximum parallel upload parts (if parallel supported)
+ * @property minChunkSize - Minimum size in bytes for each chunk (except last)
+ * @property maxChunkSize - Maximum size in bytes for each chunk
+ * @property maxParts - Maximum number of parts in a multipart upload
+ * @property optimalChunkSize - Recommended chunk size for best performance
+ * @property requiresOrderedChunks - Must receive chunks in sequential order
+ * @property requiresMimeTypeValidation - Validates file MIME type matches declaration
+ * @property maxValidationSize - Maximum file size for MIME type validation
  *
  * @example
  * ```typescript
- * // Register a new type
- * flowTypeRegistry.register({
- *   id: "webhook-output-v1",
- *   category: "output",
- *   schema: webhookResponseSchema,
- *   version: "1.0.0",
- *   description: "HTTP webhook notification output",
- * });
+ * const capabilities = dataStore.getCapabilities();
  *
- * // Retrieve a type definition
- * const def = flowTypeRegistry.get("webhook-output-v1");
- * if (def) {
- *   console.log(def.description);
- * }
- *
- * // List all output types
- * const outputTypes = flowTypeRegistry.listByCategory("output");
- * console.log(outputTypes.map(t => t.id));
- *
- * // Validate data
- * const result = flowTypeRegistry.validate("webhook-output-v1", data);
- * if (result.success) {
- *   // data is now typed according to the schema
- *   processWebhookResponse(result.data);
+ * if (capabilities.supportsParallelUploads && fileSize > 10_000_000) {
+ *   // Use parallel upload for large files
+ *   const chunkSize = capabilities.optimalChunkSize || 5_242_880; // 5MB default
+ *   uploadInParallel(file, chunkSize);
+ * } else {
+ *   // Use single upload
+ *   uploadAsSingleChunk(file);
  * }
  * ```
  */
-declare class FlowTypeRegistry {
-  private readonly types;
-  constructor();
-  /**
-   * Register a new node type in the registry.
-   *
-   * Once registered, a type cannot be modified or removed. Attempting to register
-   * a type with a duplicate ID will throw an error.
-   *
-   * @template T - The TypeScript type inferred from the Zod schema
-   * @param definition - The complete type definition including schema and metadata
-   * @throws {UploadistaError} If a type with the same ID is already registered
-   *
-   * @example
-   * ```typescript
-   * import { z } from "zod";
-   *
-   * flowTypeRegistry.register({
-   *   id: "description-output-v1",
-   *   category: "output",
-   *   schema: z.object({
-   *     description: z.string(),
-   *     confidence: z.number().min(0).max(1),
-   *     tags: z.array(z.string()).optional(),
-   *   }),
-   *   version: "1.0.0",
-   *   description: "AI-generated image description with confidence score",
-   * });
-   * ```
-   */
-  register<T>(definition: NodeTypeDefinition<T>): void;
-  /**
-   * Retrieve a registered type definition by its ID.
-   *
-   * @param id - The unique type identifier (e.g., "storage-output-v1")
-   * @returns The type definition if found, undefined otherwise
-   *
-   * @example
-   * ```typescript
-   * const def = flowTypeRegistry.get("storage-output-v1");
-   * if (def) {
-   *   console.log(`Found ${def.description} (v${def.version})`);
-   * } else {
-   *   console.warn("Type not registered");
-   * }
-   * ```
-   */
-  get(id: string): NodeTypeDefinition<unknown> | undefined;
-  /**
-   * List all registered types in a specific category.
-   *
-   * @param category - The node category to filter by ("input" or "output")
-   * @returns Array of type definitions in the specified category
-   *
-   * @example
-   * ```typescript
-   * // List all registered output types
-   * const outputTypes = flowTypeRegistry.listByCategory("output");
-   * console.log("Available output types:");
-   * for (const type of outputTypes) {
-   *   console.log(`- ${type.id}: ${type.description}`);
-   * }
-   * ```
-   */
-  listByCategory(category: NodeTypeCategory): NodeTypeDefinition<unknown>[];
-  /**
-   * Validate data against a registered type's schema.
-   *
-   * This method performs runtime validation using the Zod schema associated with
-   * the type. If validation succeeds, the data is returned with proper typing.
-   * If validation fails, an UploadistaError is returned with details.
-   *
-   * @template T - The expected TypeScript type after validation
-   * @param typeId - The ID of the registered type to validate against
-   * @param data - The data to validate
-   * @returns A result object with either the validated data or an error
-   *
-   * @example
-   * ```typescript
-   * const result = flowTypeRegistry.validate("storage-output-v1", unknownData);
-   *
-   * if (result.success) {
-   *   // TypeScript knows result.data is an UploadFile
-   *   console.log(`File stored at: ${result.data.url}`);
-   * } else {
-   *   console.error(`Validation failed: ${result.error.body}`);
-   * }
-   * ```
-   */
-  validate<T>(typeId: string, data: unknown): ValidationResult<T>;
-  /**
-   * Check if a type is registered.
-   *
-   * @param id - The unique type identifier to check
-   * @returns True if the type is registered, false otherwise
-   *
-   * @example
-   * ```typescript
-   * if (flowTypeRegistry.has("custom-output-v1")) {
-   *   console.log("Custom output type is available");
-   * }
-   * ```
-   */
-  has(id: string): boolean;
-  /**
-   * Get the total number of registered types.
-   *
-   * @returns The count of registered types
-   *
-   * @example
-   * ```typescript
-   * console.log(`Registry contains ${flowTypeRegistry.size()} types`);
-   * ```
-   */
-  size(): number;
-}
+type DataStoreCapabilities = {
+  supportsParallelUploads: boolean;
+  supportsConcatenation: boolean;
+  supportsDeferredLength: boolean;
+  supportsResumableUploads: boolean;
+  supportsTransactionalUploads: boolean;
+  maxConcurrentUploads?: number;
+  minChunkSize?: number;
+  maxChunkSize?: number;
+  maxParts?: number;
+  optimalChunkSize?: number;
+  requiresOrderedChunks: boolean;
+  requiresMimeTypeValidation?: boolean;
+  maxValidationSize?: number;
+};
 /**
- * Global singleton instance of the flow type registry.
+ * Core interface for all storage backend implementations.
  *
- * Use this instance to register and access node type definitions throughout
- * your application. The registry is initialized once and shared globally.
+ * DataStore abstracts file storage operations across different backends
+ * (S3, Azure Blob, GCS, local filesystem, etc.). All storage adapters
+ * must implement this interface.
+ *
+ * @template TData - The data type stored (typically UploadFile)
+ *
+ * @property bucket - Optional storage bucket or container name
+ * @property path - Optional base path prefix for all stored files
+ * @property create - Creates a new file record in storage
+ * @property remove - Deletes a file from storage
+ * @property read - Reads complete file contents as bytes
+ * @property write - Writes data stream to storage at specified offset
+ * @property deleteExpired - Optional cleanup of expired files
+ * @property getCapabilities - Returns storage backend capabilities
+ * @property validateUploadStrategy - Validates if strategy is supported
  *
  * @example
  * ```typescript
- * import { flowTypeRegistry } from "@uploadista/core/flow";
- *
- * // Register a type
- * flowTypeRegistry.register({
- *   id: "my-output-v1",
- *   category: "output",
- *   schema: mySchema,
- *   version: "1.0.0",
- *   description: "My custom output type",
- * });
+ * // Implement a custom DataStore
+ * const myDataStore: DataStore<UploadFile> = {
+ *   bucket: "my-uploads",
+ *   path: "files/",
  *
- * // Validate data
- * const result = flowTypeRegistry.validate("my-output-v1", data);
- * ```
- */
-declare const flowTypeRegistry: FlowTypeRegistry;
-//#endregion
-//#region src/flow/node-types/index.d.ts
-/**
- * Built-in node type registrations for the flow engine.
+ *   create: (file) => Effect.gen(function* () {
+ *     // Store file metadata
+ *     yield* saveMetadata(file);
+ *     return file;
+ *   }),
  *
- * This module automatically registers the standard input and output node types
- * when imported. These types enable type-safe result consumption in clients.
+ *   write: ({ file_id, stream, offset }, { onProgress }) => Effect.gen(function* () {
+ *     // Write chunks to storage
+ *     let bytesWritten = offset;
+ *     yield* Stream.runForEach(stream, (chunk) => Effect.sync(() => {
+ *       writeChunk(file_id, chunk, bytesWritten);
+ *       bytesWritten += chunk.byteLength;
+ *       onProgress?.(chunk.byteLength);
+ *     }));
+ *     return bytesWritten;
+ *   }),
  *
- * @module flow/node-types
+ *   read: (file_id) => Effect.gen(function* () {
+ *     // Read complete file
+ *     const data = yield* readFromStorage(file_id);
+ *     return data;
+ *   }),
  *
- * @remarks
- * This module should be imported by the flow engine initialization to ensure
- * built-in types are registered before any flows are created.
+ *   remove: (file_id) => Effect.gen(function* () {
+ *     yield* deleteFromStorage(file_id);
+ *   }),
  *
- * @example
- * ```typescript
- * // Types are automatically registered on import
- * import "@uploadista/core/flow/node-types";
- * import { flowTypeRegistry } from "@uploadista/core/flow";
+ *   getCapabilities: () => ({
+ *     supportsParallelUploads: true,
+ *     supportsConcatenation: false,
+ *     supportsDeferredLength: true,
+ *     supportsResumableUploads: true,
+ *     supportsTransactionalUploads: false,
+ *     maxConcurrentUploads: 10,
+ *     optimalChunkSize: 5_242_880, // 5MB
+ *     requiresOrderedChunks: false,
+ *   }),
  *
- * // Check registered types
- * const inputTypes = flowTypeRegistry.listByCategory("input");
- * console.log(inputTypes.map(t => t.id)); // ["streaming-input-v1"]
+ *   validateUploadStrategy: (strategy) =>
+ *     Effect.succeed(strategy === "parallel" || strategy === "single"),
+ * };
  * ```
  */
+type DataStore<TData = unknown> = {
+  readonly bucket?: string;
+  readonly path?: string;
+  readonly create: (file: TData) => Effect.Effect<TData, UploadistaError>;
+  readonly remove: (file_id: string) => Effect.Effect<void, UploadistaError>;
+  readonly read: (file_id: string) => Effect.Effect<Uint8Array, UploadistaError>;
+  readonly write: (options: DataStoreWriteOptions, dependencies: {
+    onProgress?: (chunkSize: number) => void;
+  }) => Effect.Effect<number, UploadistaError>;
+  readonly deleteExpired?: () => Effect.Effect<number, UploadistaError>;
+  readonly getCapabilities: () => DataStoreCapabilities;
+  readonly validateUploadStrategy: (strategy: UploadStrategy) => Effect.Effect<boolean, never>;
+};
+declare const UploadFileDataStore_base: Context.TagClass<UploadFileDataStore, "UploadFileDataStore", DataStore<UploadFile>>;
 /**
- * Type ID constants for built-in node types.
+ * Effect-TS context tag for UploadFile DataStore.
  *
- * Use these constants when creating nodes with type information to ensure
- * consistency and avoid typos.
+ * Use this tag to access the primary DataStore in an Effect context.
+ * This is the standard storage backend for uploaded files.
  *
  * @example
  * ```typescript
- * import { STREAMING_INPUT_TYPE_ID } from "@uploadista/core/flow/node-types";
- *
- * const inputNode = createFlowNode({
- *   // ... other config
- *   nodeTypeId: STREAMING_INPUT_TYPE_ID
- * });
+ * const uploadEffect = Effect.gen(function* () {
+ *   const dataStore = yield* UploadFileDataStore;
+ *   const file = yield* dataStore.create(uploadFile);
+ *   return file;
+ * });
  * ```
  */
-declare const STREAMING_INPUT_TYPE_ID = "streaming-input-v1";
-declare const STORAGE_OUTPUT_TYPE_ID = "storage-output-v1";
-//#endregion
-//#region src/types/kv-store.d.ts
+declare class UploadFileDataStore extends UploadFileDataStore_base {}
+declare const BufferedUploadFileDataStore_base: Context.TagClass<BufferedUploadFileDataStore, "BufferedUploadFileDataStore", DataStore<UploadFile>>;
 /**
- * Base key-value store interface for raw string storage.
- *
- * This is the low-level interface that storage adapters implement.
- * It stores raw string values without type safety or serialization.
+ * Effect-TS context tag for buffered/temporary DataStore.
  *
- * @property get - Retrieves a value by key, returns null if not found
- * @property set - Stores a value with the given key
- * @property delete - Removes a value by key
- * @property list - Optional operation to list all keys with a given prefix
+ * This is an optional storage backend used for temporary or intermediate files
+ * during flow processing. Not all implementations provide a buffered store.
  *
  * @example
  * ```typescript
- * // Implement a BaseKvStore with Redis
- * const redisKvStore: BaseKvStore = {
- *   get: (key) => Effect.tryPromise({
- *     try: () => redis.get(key),
- *     catch: (error) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause: error })
- *   }),
- *
- *   set: (key, value) => Effect.tryPromise({
- *     try: () => redis.set(key, value),
- *     catch: (error) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause: error })
- *   }),
- *
- *   delete: (key) => Effect.tryPromise({
- *     try: () => redis.del(key),
- *     catch: (error) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause: error })
- *   }),
- *
- *   list: (prefix) => Effect.tryPromise({
- *     try: () => redis.keys(`${prefix}*`),
- *     catch: (error) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause: error })
- *   })
- * };
+ * const processEffect = Effect.gen(function* () {
+ *   const bufferedStore = yield* BufferedUploadFileDataStore;
+ *   // Store intermediate processing results
+ *   const tempFile = yield* bufferedStore.create(intermediateFile);
+ *   return tempFile;
+ * });
  * ```
  */
-interface BaseKvStore {
-  readonly get: (key: string) => Effect.Effect<string | null, UploadistaError>;
-  readonly set: (key: string, value: string) => Effect.Effect<void, UploadistaError>;
-  readonly delete: (key: string) => Effect.Effect<void, UploadistaError>;
-  readonly list?: (keyPrefix: string) => Effect.Effect<Array<string>, UploadistaError>;
-}
+declare class BufferedUploadFileDataStore extends BufferedUploadFileDataStore_base {}
 /**
- * Type-safe key-value store interface with automatic serialization.
+ * Service interface for managing multiple DataStore instances.
  *
- * This wraps a BaseKvStore and handles JSON serialization/deserialization
- * for a specific data type, providing type safety and eliminating the need
- * for manual JSON.stringify/parse calls.
+ * This allows routing files to different storage backends based on
+ * storageId (e.g., different S3 buckets, Azure containers, or storage tiers).
  *
- * @template TData - The type of data stored in this KV store
+ * @property getDataStore - Retrieves the appropriate DataStore for a given storage ID
+ * @property bufferedDataStore - Optional temporary storage for intermediate files
+ */
+type UploadFileDataStoresShape = {
+  getDataStore: (storageId: string, clientId: string | null) => Effect.Effect<DataStore<UploadFile>, UploadistaError>;
+  bufferedDataStore: Effect.Effect<DataStore<UploadFile> | undefined, UploadistaError>;
+};
+declare const UploadFileDataStores_base: Context.TagClass<UploadFileDataStores, "UploadFileDataStores", UploadFileDataStoresShape>;
+/**
+ * Effect-TS context tag for the DataStore routing service.
  *
- * @property get - Retrieves and deserializes a value, fails if not found
- * @property set - Serializes and stores a value
- * @property delete - Removes a value by key
- * @property list - Optional operation to list all keys (without prefix)
+ * Provides access to multiple DataStore instances with routing logic.
  *
  * @example
  * ```typescript
- * // Use a typed KV store
- * const uploadStore: KvStore<UploadFile> = new TypedKvStore(
- *   baseStore,
- *   "uploads:",
- *   jsonSerializer.serialize,
- *   jsonSerializer.deserialize
- * );
- *
- * // Store and retrieve typed data
- * const program = Effect.gen(function* () {
- *   const file: UploadFile = {
- *     id: "file123",
- *     offset: 0,
- *     storage: { id: "s3", type: "s3" }
- *   };
- *
- *   // Automatic serialization
- *   yield* uploadStore.set("file123", file);
- *
- *   // Automatic deserialization with type safety
- *   const retrieved = yield* uploadStore.get("file123");
- *   console.log(retrieved.offset); // TypeScript knows this is a number
+ * const uploadEffect = Effect.gen(function* () {
+ *   const dataStores = yield* UploadFileDataStores;
+ *   // Route to specific storage based on storageId
+ *   const dataStore = yield* dataStores.getDataStore("s3-production", clientId);
+ *   const file = yield* dataStore.create(uploadFile);
+ *   return file;
  * });
  * ```
  */
-type KvStore<TData> = {
-  readonly get: (key: string) => Effect.Effect<TData, UploadistaError>;
-  readonly set: (key: string, value: TData) => Effect.Effect<void, UploadistaError>;
-  readonly delete: (key: string) => Effect.Effect<void, UploadistaError>;
-  readonly list?: () => Effect.Effect<Array<string>, UploadistaError>;
-};
+declare class UploadFileDataStores extends UploadFileDataStores_base {}
 /**
- * Typed wrapper class that adds serialization to a BaseKvStore.
- *
- * This class implements the KvStore interface by wrapping a BaseKvStore
- * and handling serialization/deserialization for a specific type. It also
- * adds a key prefix to isolate different data types in the same store.
+ * Simplified DataStore configuration for easy setup.
  *
- * @template TData - The type of data to store
+ * This type allows flexible configuration:
+ * - Single DataStore instance
+ * - Multiple named stores with routing
+ * - Effect that resolves to a DataStore
+ * - Pre-built Effect Layer
  *
  * @example
  * ```typescript
- * // Create a typed store for UploadFile
- * const uploadFileStore = new TypedKvStore<UploadFile>(
- *   baseKvStore,
- *   "uploadista:upload-file:", // All keys will be prefixed
- *   (data) => JSON.stringify(data),
- *   (str) => JSON.parse(str) as UploadFile
- * );
+ * // Single store
+ * const config: DataStoreConfig = s3DataStore;
  *
- * // Use the store
- * const effect = Effect.gen(function* () {
- *   const file: UploadFile = { ... };
- *   yield* uploadFileStore.set("abc123", file);
- *   // Internally stores at key "uploadista:upload-file:abc123"
+ * // Multiple stores with routing
+ * const config: DataStoreConfig = {
+ *   stores: {
+ *     "s3-prod": s3ProdStore,
+ *     "s3-dev": s3DevStore,
+ *     "local": localFileStore,
+ *   },
+ *   default: "s3-prod"
+ * };
  *
- *   const retrieved = yield* uploadFileStore.get("abc123");
- *   return retrieved;
+ * // Effect that creates a store
+ * const config: DataStoreConfig = Effect.gen(function* () {
+ *   const kvStore = yield* UploadFileKVStore;
+ *   return s3Store(kvStore);
  * });
  *
- * // Custom serialization for binary data
- * const binaryStore = new TypedKvStore<Uint8Array>(
- *   baseKvStore,
- *   "binary:",
- *   (data) => btoa(String.fromCharCode(...data)), // Base64 encode
- *   (str) => Uint8Array.from(atob(str), c => c.charCodeAt(0)) // Base64 decode
- * );
+ * // Pre-built Layer
+ * const config: DataStoreConfig = Layer.succeed(UploadFileDataStores, {...});
  * ```
  */
-declare class TypedKvStore<TData> implements KvStore<TData> {
-  private baseStore;
-  private keyPrefix;
-  private serialize;
-  private deserialize;
-  constructor(baseStore: BaseKvStore, keyPrefix: string, serialize: (data: TData) => string, deserialize: (str: string) => TData);
-  get: (key: string) => Effect.Effect<TData, UploadistaError>;
-  set: (key: string, value: TData) => Effect.Effect<void, UploadistaError>;
-  delete: (key: string) => Effect.Effect<void, UploadistaError>;
-  list: () => Effect.Effect<Array<string>, UploadistaError>;
-}
+type DataStoreConfig = DataStore<UploadFile> | Effect.Effect<DataStore<UploadFile>, never, UploadFileKVStore> | {
+  stores: Record<string, DataStore<UploadFile> | Effect.Effect<DataStore<UploadFile>, never, UploadFileKVStore>>;
+  default?: string;
+} | Layer.Layer<UploadFileDataStores, never, UploadFileKVStore>;
 /**
- * Default JSON serialization helpers.
+ * Type guard to check if a value is a DataStore instance.
  *
- * These functions provide standard JSON serialization for use with TypedKvStore.
- * They work with any JSON-serializable type.
+ * @param config - The value to check
+ * @returns True if the value is a DataStore
  *
  * @example
  * ```typescript
- * const store = new TypedKvStore<MyType>(
- *   baseStore,
- *   "mydata:",
- *   jsonSerializer.serialize,
- *   jsonSerializer.deserialize
- * );
+ * if (isDataStore(config)) {
+ *   const capabilities = config.getCapabilities();
+ * }
  * ```
  */
-declare const jsonSerializer: {
-  serialize: <T>(data: T) => string;
-  deserialize: <T>(str: string) => T;
-};
-declare const BaseKvStoreService_base: Context.TagClass<BaseKvStoreService, "BaseKvStore", BaseKvStore>;
+declare const isDataStore: (config: DataStoreConfig) => config is DataStore<UploadFile>;
 /**
- * Effect-TS context tag for the base untyped KV store.
+ * Creates an Effect Layer from simplified DataStoreConfig.
  *
- * This is the low-level store that storage adapter implementations provide.
- * Most application code should use typed stores like UploadFileKVStore instead.
+ * This function converts any DataStoreConfig format into a proper Effect Layer
+ * that can be provided to the UploadFileDataStores context tag.
+ *
+ * It handles:
+ * - Single DataStore: Wraps in a Layer that always returns that store
+ * - Multiple stores: Creates routing logic with optional default
+ * - Effect<DataStore>: Executes the Effect and wraps the result
+ * - Layer: Returns as-is
+ *
+ * @param config - The DataStore configuration
+ * @returns A Layer that provides UploadFileDataStores service
  *
  * @example
  * ```typescript
- * // Provide a base store implementation
- * const baseStoreLayer = Layer.succeed(BaseKvStoreService, redisKvStore);
+ * // Create from single store
+ * const layer = await createDataStoreLayer(s3DataStore);
  *
- * // Use in an Effect
- * const effect = Effect.gen(function* () {
- *   const baseStore = yield* BaseKvStoreService;
- *   yield* baseStore.set("raw-key", "raw-value");
+ * // Create from multiple stores
+ * const layer = await createDataStoreLayer({
+ *   stores: {
+ *     "production": s3Store,
+ *     "development": localStore,
+ *   },
+ *   default: "development"
  * });
+ *
+ * // Use the layer
+ * const program = Effect.gen(function* () {
+ *   const stores = yield* UploadFileDataStores;
+ *   const store = yield* stores.getDataStore("production", null);
+ *   return store;
+ * }).pipe(Effect.provide(layer));
  * ```
  */
-declare class BaseKvStoreService extends BaseKvStoreService_base {}
-declare const UploadFileKVStore_base: Context.TagClass<UploadFileKVStore, "UploadFileKVStore", KvStore<UploadFile>>;
+declare const createDataStoreLayer: (config: DataStoreConfig) => Promise<Layer.Layer<UploadFileDataStores, never, UploadFileKVStore>>;
+//#endregion
+//#region src/flow/flow.d.ts
 /**
- * Effect-TS context tag for the UploadFile typed KV store.
- *
- * This provides type-safe storage for UploadFile metadata. It's the primary
- * way to store and retrieve upload metadata in the system.
- *
- * @example
- * ```typescript
- * const uploadEffect = Effect.gen(function* () {
- *   const kvStore = yield* UploadFileKVStore;
+ * Serialized flow data for storage and transport.
+ * Contains the minimal information needed to reconstruct a flow.
  *
- *   // Store upload metadata
- *   const file: UploadFile = {
- *     id: "upload123",
- *     offset: 0,
- *     storage: { id: "s3", type: "s3" }
- *   };
- *   yield* kvStore.set("upload123", file);
- *
- *   // Retrieve with type safety
- *   const retrieved = yield* kvStore.get("upload123");
- *   return retrieved;
- * });
- * ```
+ * @property id - Unique flow identifier
+ * @property name - Human-readable flow name
+ * @property nodes - Array of node data (without execution logic)
+ * @property edges - Connections between nodes defining data flow
  */
-declare class UploadFileKVStore extends UploadFileKVStore_base {}
+type FlowData = {
+  id: string;
+  name: string;
+  nodes: FlowNodeData[];
+  edges: FlowEdge[];
+};
 /**
- * Effect Layer that creates the UploadFileKVStore from a BaseKvStore.
+ * Extracts serializable flow data from a Flow instance.
+ * Useful for storing flow definitions or sending them over the network.
  *
- * This layer automatically wires up JSON serialization for UploadFile objects
- * with the "uploadista:upload-file:" key prefix.
+ * @template TRequirements - Effect requirements for the flow
+ * @param flow - Flow instance to extract data from
+ * @returns Serializable flow data without execution logic
  *
  * @example
  * ```typescript
- * const program = Effect.gen(function* () {
- *   const kvStore = yield* UploadFileKVStore;
- *   // Use the store...
- * }).pipe(
- *   Effect.provide(uploadFileKvStore),
- *   Effect.provide(baseStoreLayer)
- * );
+ * const flowData = getFlowData(myFlow);
+ * // Store in database or send to client
+ * await db.flows.save(flowData);
  * ```
  */
-declare const uploadFileKvStore: Layer.Layer<UploadFileKVStore, never, BaseKvStoreService>;
-declare const FlowJobKVStore_base: Context.TagClass<FlowJobKVStore, "FlowJobKVStore", KvStore<FlowJob>>;
+declare const getFlowData: <TRequirements>(flow: Flow<any, any, TRequirements>) => FlowData;
 /**
- * Effect-TS context tag for the FlowJob typed KV store.
- *
- * This provides type-safe storage for FlowJob metadata, tracking the
- * execution state of flow processing jobs.
- *
- * @example
- * ```typescript
- * const flowEffect = Effect.gen(function* () {
- *   const jobStore = yield* FlowJobKVStore;
- *
- *   // Store job state
- *   const job: FlowJob = {
- *     id: "job123",
- *     flowId: "flow_resize",
- *     status: "running",
- *     tasks: [],
- *     createdAt: new Date(),
- *     updatedAt: new Date()
- *   };
- *   yield* jobStore.set("job123", job);
+ * Result of a flow execution - either completed or paused.
  *
- *   // Retrieve and check status
- *   const retrieved = yield* jobStore.get("job123");
- *   return retrieved.status;
- * });
- * ```
- */
-declare class FlowJobKVStore extends FlowJobKVStore_base {}
-/**
- * Effect Layer that creates the FlowJobKVStore from a BaseKvStore.
+ * @template TOutput - Type of the flow's output data
  *
- * This layer automatically wires up JSON serialization for FlowJob objects
- * with the "uploadista:flow-job:" key prefix.
+ * @remarks
+ * Flows can pause when a node needs additional data (e.g., waiting for user input
+ * or external service). The execution state allows resuming from where it paused.
  *
  * @example
  * ```typescript
- * const program = Effect.gen(function* () {
- *   const jobStore = yield* FlowJobKVStore;
- *   // Use the store...
- * }).pipe(
- *   Effect.provide(flowJobKvStore),
- *   Effect.provide(baseStoreLayer)
- * );
- * ```
- */
-declare const flowJobKvStore: Layer.Layer<FlowJobKVStore, never, BaseKvStoreService>;
-//#endregion
-//#region src/types/data-store.d.ts
-/**
- * Options for writing data to a DataStore.
+ * const result = await Effect.runPromise(flow.run({ inputs, storageId, jobId }));
  *
- * @property file_id - Unique identifier for the file being written
- * @property stream - Stream of byte chunks to write to storage
- * @property offset - Byte offset where writing should begin (for resumable uploads)
+ * if (result.type === "completed") {
+ *   console.log("Flow completed:", result.result);
+ * } else {
+ *   console.log("Flow paused at node:", result.nodeId);
+ *   // Can resume later with: flow.resume({ jobId, executionState: result.executionState, ... })
+ * }
+ * ```
  */
-type DataStoreWriteOptions = {
-  file_id: string;
-  stream: Stream.Stream<Uint8Array, UploadistaError>;
-  offset: number;
+type FlowExecutionResult<TOutput> = {
+  type: "completed";
+  result: TOutput;
+  outputs?: TypedOutput[];
+} | {
+  type: "paused";
+  nodeId: string;
+  executionState: {
+    executionOrder: string[];
+    currentIndex: number;
+    inputs: Record<string, unknown>;
+  };
 };
 /**
- * Upload strategy type indicating how chunks are uploaded.
+ * A Flow represents a directed acyclic graph (DAG) of processing nodes.
  *
- * - `single`: Upload file in a single request (traditional upload)
- * - `parallel`: Upload file chunks in parallel (for large files)
- */
-type UploadStrategy = "single" | "parallel";
-/**
- * Capabilities and constraints of a DataStore implementation.
+ * Flows execute nodes in topological order, passing data between nodes through edges.
+ * They support conditional execution, retry logic, pausable nodes, and event emission.
  *
- * This type describes what features a storage backend supports and what
- * limitations it has. Use this to determine the optimal upload strategy
- * and validate client requests.
+ * @template TFlowInputSchema - Zod schema defining the shape of input data
+ * @template TFlowOutputSchema - Zod schema defining the shape of output data
+ * @template TRequirements - Effect requirements (services/contexts) needed by nodes
  *
- * @property supportsParallelUploads - Can upload chunks in parallel (e.g., S3 multipart)
- * @property supportsConcatenation - Can concatenate multiple uploads into one file
- * @property supportsDeferredLength - Can start upload without knowing final size
- * @property supportsResumableUploads - Can resume interrupted uploads from last offset
- * @property supportsTransactionalUploads - Guarantees atomic upload success/failure
- * @property maxConcurrentUploads - Maximum parallel upload parts (if parallel supported)
- * @property minChunkSize - Minimum size in bytes for each chunk (except last)
- * @property maxChunkSize - Maximum size in bytes for each chunk
- * @property maxParts - Maximum number of parts in a multipart upload
- * @property optimalChunkSize - Recommended chunk size for best performance
- * @property requiresOrderedChunks - Must receive chunks in sequential order
- * @property requiresMimeTypeValidation - Validates file MIME type matches declaration
- * @property maxValidationSize - Maximum file size for MIME type validation
+ * @property id - Unique flow identifier
+ * @property name - Human-readable flow name
+ * @property nodes - Array of nodes in the flow
+ * @property edges - Connections between nodes
+ * @property inputSchema - Zod schema for validating flow inputs
+ * @property outputSchema - Zod schema for validating flow outputs
+ * @property onEvent - Optional callback for flow execution events
+ * @property run - Executes the flow from the beginning
+ * @property resume - Resumes a paused flow execution
+ * @property validateTypes - Validates node type compatibility
+ * @property validateInputs - Validates input data against schema
+ * @property validateOutputs - Validates output data against schema
+ *
+ * @remarks
+ * Flows are created using {@link createFlowWithSchema}. The Effect-based design
+ * allows for composable error handling, resource management, and dependency injection.
  *
  * @example
  * ```typescript
- * const capabilities = dataStore.getCapabilities();
+ * const flow = yield* createFlowWithSchema({
+ *   flowId: "image-pipeline",
+ *   name: "Image Processing Pipeline",
+ *   nodes: [inputNode, resizeNode, optimizeNode, storageNode],
+ *   edges: [
+ *     { source: "input", target: "resize" },
+ *     { source: "resize", target: "optimize" },
+ *     { source: "optimize", target: "storage" }
+ *   ],
+ *   inputSchema: z.object({ file: z.instanceof(File) }),
+ *   outputSchema: uploadFileSchema
+ * });
  *
- * if (capabilities.supportsParallelUploads && fileSize > 10_000_000) {
- *   // Use parallel upload for large files
- *   const chunkSize = capabilities.optimalChunkSize || 5_242_880; // 5MB default
- *   uploadInParallel(file, chunkSize);
- * } else {
- *   // Use single upload
- *   uploadAsSingleChunk(file);
- * }
+ * const result = yield* flow.run({
+ *   inputs: { input: { file: myFile } },
+ *   storageId: "storage-1",
+ *   jobId: "job-123"
+ * });
  * ```
  */
-type DataStoreCapabilities = {
-  supportsParallelUploads: boolean;
-  supportsConcatenation: boolean;
-  supportsDeferredLength: boolean;
-  supportsResumableUploads: boolean;
-  supportsTransactionalUploads: boolean;
-  maxConcurrentUploads?: number;
-  minChunkSize?: number;
-  maxChunkSize?: number;
-  maxParts?: number;
-  optimalChunkSize?: number;
-  requiresOrderedChunks: boolean;
-  requiresMimeTypeValidation?: boolean;
-  maxValidationSize?: number;
+type Flow<TFlowInputSchema extends z.ZodSchema<any>, TFlowOutputSchema extends z.ZodSchema<any>, TRequirements> = {
+  id: string;
+  name: string;
+  nodes: FlowNode<any, any, UploadistaError>[];
+  edges: FlowEdge[];
+  inputSchema: TFlowInputSchema;
+  outputSchema: TFlowOutputSchema;
+  onEvent?: FlowConfig<TFlowInputSchema, TFlowOutputSchema, TRequirements>["onEvent"];
+  checkJobStatus?: FlowConfig<TFlowInputSchema, TFlowOutputSchema, TRequirements>["checkJobStatus"];
+  hooks?: FlowConfig<TFlowInputSchema, TFlowOutputSchema, TRequirements>["hooks"];
+  run: (args: {
+    inputs?: Record<string, z.infer<TFlowInputSchema>>;
+    storageId: string;
+    jobId: string;
+    clientId: string | null;
+  }) => Effect.Effect<FlowExecutionResult<Record<string, z.infer<TFlowOutputSchema>>>, UploadistaError, TRequirements | UploadFileDataStores>;
+  resume: (args: {
+    jobId: string;
+    storageId: string;
+    nodeResults: Record<string, unknown>;
+    executionState: {
+      executionOrder: string[];
+      currentIndex: number;
+      inputs: Record<string, z.infer<TFlowInputSchema>>;
+    };
+    clientId: string | null;
+  }) => Effect.Effect<FlowExecutionResult<Record<string, z.infer<TFlowOutputSchema>>>, UploadistaError, TRequirements | UploadFileDataStores>;
+  validateTypes: () => {
+    isValid: boolean;
+    errors: string[];
+  };
+  validateInputs: (inputs: unknown) => {
+    isValid: boolean;
+    errors: string[];
+  };
+  validateOutputs: (outputs: unknown) => {
+    isValid: boolean;
+    errors: string[];
+  };
 };
 /**
- * Core interface for all storage backend implementations.
+ * Creates a new Flow with Zod schema-based type validation.
  *
- * DataStore abstracts file storage operations across different backends
- * (S3, Azure Blob, GCS, local filesystem, etc.). All storage adapters
- * must implement this interface.
+ * This is the primary way to create flows in Uploadista. It constructs a Flow
+ * instance that validates inputs/outputs, executes nodes in topological order,
+ * handles errors with retries, and emits events during execution.
  *
- * @template TData - The data type stored (typically UploadFile)
+ * @template TFlowInputSchema - Zod schema for flow input validation
+ * @template TFlowOutputSchema - Zod schema for flow output validation
+ * @template TRequirements - Effect requirements/services needed by the flow
+ * @template TNodeError - Union of possible errors from nodes
+ * @template TNodeRequirements - Union of requirements from nodes
  *
- * @property bucket - Optional storage bucket or container name
- * @property path - Optional base path prefix for all stored files
- * @property create - Creates a new file record in storage
- * @property remove - Deletes a file from storage
- * @property read - Reads complete file contents as bytes
- * @property write - Writes data stream to storage at specified offset
- * @property deleteExpired - Optional cleanup of expired files
- * @property getCapabilities - Returns storage backend capabilities
- * @property validateUploadStrategy - Validates if strategy is supported
- *
- * @example
- * ```typescript
- * // Implement a custom DataStore
- * const myDataStore: DataStore<UploadFile> = {
- *   bucket: "my-uploads",
- *   path: "files/",
+ * @param config - Flow configuration object
+ * @param config.flowId - Unique identifier for the flow
+ * @param config.name - Human-readable flow name
+ * @param config.nodes - Array of nodes (can be plain nodes or Effects resolving to nodes)
+ * @param config.edges - Array of edges connecting nodes
+ * @param config.inputSchema - Zod schema for validating inputs
+ * @param config.outputSchema - Zod schema for validating outputs
+ * @param config.typeChecker - Optional custom type compatibility checker
+ * @param config.onEvent - Optional event callback for monitoring execution
  *
- *   create: (file) => Effect.gen(function* () {
- *     // Store file metadata
- *     yield* saveMetadata(file);
- *     return file;
- *   }),
+ * @returns Effect that resolves to a Flow instance
  *
- *   write: ({ file_id, stream, offset }, { onProgress }) => Effect.gen(function* () {
- *     // Write chunks to storage
- *     let bytesWritten = offset;
- *     yield* Stream.runForEach(stream, (chunk) => Effect.sync(() => {
- *       writeChunk(file_id, chunk, bytesWritten);
- *       bytesWritten += chunk.byteLength;
- *       onProgress?.(chunk.byteLength);
- *     }));
- *     return bytesWritten;
- *   }),
+ * @throws {UploadistaError} FLOW_CYCLE_ERROR if the graph contains cycles
+ * @throws {UploadistaError} FLOW_NODE_NOT_FOUND if a node is referenced but missing
+ * @throws {UploadistaError} FLOW_NODE_ERROR if node execution fails
+ * @throws {UploadistaError} FLOW_OUTPUT_VALIDATION_ERROR if outputs don't match schema
  *
- *   read: (file_id) => Effect.gen(function* () {
- *     // Read complete file
- *     const data = yield* readFromStorage(file_id);
- *     return data;
- *   }),
+ * @remarks
+ * - Nodes can be provided as plain objects or as Effects that resolve to nodes
+ * - The flow performs topological sorting to determine execution order
+ * - Conditional nodes are evaluated before execution
+ * - Nodes can specify retry configuration with exponential backoff
+ * - Pausable nodes can halt execution and resume later
  *
- *   remove: (file_id) => Effect.gen(function* () {
- *     yield* deleteFromStorage(file_id);
+ * @example
+ * ```typescript
+ * const flow = yield* createFlowWithSchema({
+ *   flowId: "image-upload",
+ *   name: "Image Upload with Processing",
+ *   nodes: [
+ *     inputNode,
+ *     yield* createResizeNode({ width: 1920, height: 1080 }),
+ *     optimizeNode,
+ *     storageNode
+ *   ],
+ *   edges: [
+ *     { source: "input", target: "resize" },
+ *     { source: "resize", target: "optimize" },
+ *     { source: "optimize", target: "storage" }
+ *   ],
+ *   inputSchema: z.object({
+ *     file: z.instanceof(File),
+ *     metadata: z.record(z.string(), z.any()).optional()
  *   }),
+ *   outputSchema: uploadFileSchema,
+ *   onEvent: (event) => Effect.gen(function* () {
+ *     console.log("Flow event:", event);
+ *     return { eventId: event.jobId };
+ *   })
+ * });
+ * ```
  *
- *   getCapabilities: () => ({
- *     supportsParallelUploads: true,
- *     supportsConcatenation: false,
- *     supportsDeferredLength: true,
- *     supportsResumableUploads: true,
- *     supportsTransactionalUploads: false,
- *     maxConcurrentUploads: 10,
- *     optimalChunkSize: 5_242_880, // 5MB
- *     requiresOrderedChunks: false,
- *   }),
+ * @see {@link Flow} for the returned flow type
+ * @see {@link FlowConfig} for configuration options
+ */
+declare function createFlowWithSchema<TFlowInputSchema extends z.ZodSchema<any>, TFlowOutputSchema extends z.ZodSchema<any>, TRequirements = never, TNodeError = never, TNodeRequirements = never>(config: FlowConfig<TFlowInputSchema, TFlowOutputSchema, TNodeError, TNodeRequirements>): Effect.Effect<Flow<TFlowInputSchema, TFlowOutputSchema, TRequirements>, TNodeError, TNodeRequirements>;
+//#endregion
+//#region src/flow/type-registry.d.ts
+/**
+ * Node type category - determines where the node appears in the flow.
  *
- *   validateUploadStrategy: (strategy) =>
- *     Effect.succeed(strategy === "parallel" || strategy === "single"),
- * };
- * ```
+ * - `input`: Nodes that receive data from external sources (e.g., file uploads)
+ * - `output`: Nodes that produce final results (e.g., storage, webhooks, descriptions)
  */
-type DataStore<TData = unknown> = {
-  readonly bucket?: string;
-  readonly path?: string;
-  readonly create: (file: TData) => Effect.Effect<TData, UploadistaError>;
-  readonly remove: (file_id: string) => Effect.Effect<void, UploadistaError>;
-  readonly read: (file_id: string) => Effect.Effect<Uint8Array, UploadistaError>;
-  readonly write: (options: DataStoreWriteOptions, dependencies: {
-    onProgress?: (chunkSize: number) => void;
-  }) => Effect.Effect<number, UploadistaError>;
-  readonly deleteExpired?: () => Effect.Effect<number, UploadistaError>;
-  readonly getCapabilities: () => DataStoreCapabilities;
-  readonly validateUploadStrategy: (strategy: UploadStrategy) => Effect.Effect<boolean, never>;
-};
-declare const UploadFileDataStore_base: Context.TagClass<UploadFileDataStore, "UploadFileDataStore", DataStore<UploadFile>>;
+type NodeTypeCategory = "input" | "output";
 /**
- * Effect-TS context tag for UploadFile DataStore.
+ * Defines a registered node type with its schema and metadata.
  *
- * Use this tag to access the primary DataStore in an Effect context.
- * This is the standard storage backend for uploaded files.
+ * Node type definitions are registered globally and used to validate and type-narrow
+ * flow results at runtime. Each definition includes:
+ * - A unique identifier with versioning
+ * - A category (input or output)
+ * - A Zod schema for runtime validation
+ * - A semantic version for evolution
+ * - A human-readable description
+ *
+ * @template TSchema - The Zod schema type for this node's data
+ *
+ * @property id - Unique identifier (e.g., "storage-output-v1", "webhook-output-v1")
+ * @property category - Whether this is an input or output node type
+ * @property schema - Zod schema for validating data produced by this node type
+ * @property version - Semantic version (e.g., "1.0.0") for tracking type evolution
+ * @property description - Human-readable explanation of what this node type does
  *
  * @example
  * ```typescript
- * const uploadEffect = Effect.gen(function* () {
- *   const dataStore = yield* UploadFileDataStore;
- *   const file = yield* dataStore.create(uploadFile);
- *   return file;
- * });
+ * const storageOutputDef: NodeTypeDefinition<z.infer<typeof uploadFileSchema>> = {
+ *   id: "storage-output-v1",
+ *   category: "output",
+ *   schema: uploadFileSchema,
+ *   version: "1.0.0",
+ *   description: "Storage output node that saves files to configured storage backend",
+ * };
  * ```
  */
-declare class UploadFileDataStore extends UploadFileDataStore_base {}
-declare const BufferedUploadFileDataStore_base: Context.TagClass<BufferedUploadFileDataStore, "BufferedUploadFileDataStore", DataStore<UploadFile>>;
+interface NodeTypeDefinition<TSchema = unknown> {
+  id: string;
+  category: NodeTypeCategory;
+  schema: z.ZodSchema<TSchema>;
+  version: string;
+  description: string;
+}
 /**
- * Effect-TS context tag for buffered/temporary DataStore.
+ * Result type for validation operations.
  *
- * This is an optional storage backend used for temporary or intermediate files
- * during flow processing. Not all implementations provide a buffered store.
+ * @template T - The expected type on successful validation
+ */
+type ValidationResult<T> = {
+  success: true;
+  data: T;
+} | {
+  success: false;
+  error: UploadistaError;
+};
+/**
+ * Central registry for node type definitions.
+ *
+ * The FlowTypeRegistry maintains a global registry of node types with their schemas
+ * and metadata. It provides methods for:
+ * - Registering new node types
+ * - Retrieving type definitions
+ * - Listing types by category
+ * - Validating data against registered schemas
+ *
+ * The registry is immutable after registration - types cannot be modified or removed
+ * once registered to prevent runtime errors.
+ *
+ * @remarks
+ * - This is a singleton - use the exported `flowTypeRegistry` instance
+ * - Types cannot be unregistered or modified after registration
+ * - Duplicate type IDs are rejected
+ * - Version strings should follow semantic versioning
  *
  * @example
  * ```typescript
- * const processEffect = Effect.gen(function* () {
- *   const bufferedStore = yield* BufferedUploadFileDataStore;
- *   // Store intermediate processing results
- *   const tempFile = yield* bufferedStore.create(intermediateFile);
- *   return tempFile;
+ * // Register a new type
+ * flowTypeRegistry.register({
+ *   id: "webhook-output-v1",
+ *   category: "output",
+ *   schema: webhookResponseSchema,
+ *   version: "1.0.0",
+ *   description: "HTTP webhook notification output",
  * });
- * ```
- */
-declare class BufferedUploadFileDataStore extends BufferedUploadFileDataStore_base {}
-/**
- * Service interface for managing multiple DataStore instances.
  *
- * This allows routing files to different storage backends based on
- * storageId (e.g., different S3 buckets, Azure containers, or storage tiers).
+ * // Retrieve a type definition
+ * const def = flowTypeRegistry.get("webhook-output-v1");
+ * if (def) {
+ *   console.log(def.description);
+ * }
  *
- * @property getDataStore - Retrieves the appropriate DataStore for a given storage ID
- * @property bufferedDataStore - Optional temporary storage for intermediate files
+ * // List all output types
+ * const outputTypes = flowTypeRegistry.listByCategory("output");
+ * console.log(outputTypes.map(t => t.id));
+ *
+ * // Validate data
+ * const result = flowTypeRegistry.validate("webhook-output-v1", data);
+ * if (result.success) {
+ *   // data is now typed according to the schema
+ *   processWebhookResponse(result.data);
+ * }
+ * ```
  */
-type UploadFileDataStoresShape = {
-  getDataStore: (storageId: string, clientId: string | null) => Effect.Effect<DataStore<UploadFile>, UploadistaError>;
-  bufferedDataStore: Effect.Effect<DataStore<UploadFile> | undefined, UploadistaError>;
-};
-declare const UploadFileDataStores_base: Context.TagClass<UploadFileDataStores, "UploadFileDataStores", UploadFileDataStoresShape>;
+declare class FlowTypeRegistry {
+  private readonly types;
+  constructor();
+  /**
+   * Register a new node type in the registry.
+   *
+   * Once registered, a type cannot be modified or removed. Attempting to register
+   * a type with a duplicate ID will throw an error.
+   *
+   * @template T - The TypeScript type inferred from the Zod schema
+   * @param definition - The complete type definition including schema and metadata
+   * @throws {UploadistaError} If a type with the same ID is already registered
+   *
+   * @example
+   * ```typescript
+   * import { z } from "zod";
+   *
+   * flowTypeRegistry.register({
+   *   id: "description-output-v1",
+   *   category: "output",
+   *   schema: z.object({
+   *     description: z.string(),
+   *     confidence: z.number().min(0).max(1),
+   *     tags: z.array(z.string()).optional(),
+   *   }),
+   *   version: "1.0.0",
+   *   description: "AI-generated image description with confidence score",
+   * });
+   * ```
+   */
+  register<T>(definition: NodeTypeDefinition<T>): void;
+  /**
+   * Retrieve a registered type definition by its ID.
+   *
+   * @param id - The unique type identifier (e.g., "storage-output-v1")
+   * @returns The type definition if found, undefined otherwise
+   *
+   * @example
+   * ```typescript
+   * const def = flowTypeRegistry.get("storage-output-v1");
+   * if (def) {
+   *   console.log(`Found ${def.description} (v${def.version})`);
+   * } else {
+   *   console.warn("Type not registered");
+   * }
+   * ```
+   */
+  get(id: string): NodeTypeDefinition<unknown> | undefined;
+  /**
+   * List all registered types in a specific category.
+   *
+   * @param category - The node category to filter by ("input" or "output")
+   * @returns Array of type definitions in the specified category
+   *
+   * @example
+   * ```typescript
+   * // List all registered output types
+   * const outputTypes = flowTypeRegistry.listByCategory("output");
+   * console.log("Available output types:");
+   * for (const type of outputTypes) {
+   *   console.log(`- ${type.id}: ${type.description}`);
+   * }
+   * ```
+   */
+  listByCategory(category: NodeTypeCategory): NodeTypeDefinition<unknown>[];
+  /**
+   * Validate data against a registered type's schema.
+   *
+   * This method performs runtime validation using the Zod schema associated with
+   * the type. If validation succeeds, the data is returned with proper typing.
+   * If validation fails, an UploadistaError is returned with details.
+   *
+   * @template T - The expected TypeScript type after validation
+   * @param typeId - The ID of the registered type to validate against
+   * @param data - The data to validate
+   * @returns A result object with either the validated data or an error
+   *
+   * @example
+   * ```typescript
+   * const result = flowTypeRegistry.validate("storage-output-v1", unknownData);
+   *
+   * if (result.success) {
+   *   // TypeScript knows result.data is an UploadFile
+   *   console.log(`File stored at: ${result.data.url}`);
+   * } else {
+   *   console.error(`Validation failed: ${result.error.body}`);
+   * }
+   * ```
+   */
+  validate<T>(typeId: string, data: unknown): ValidationResult<T>;
+  /**
+   * Check if a type is registered.
+   *
+   * @param id - The unique type identifier to check
+   * @returns True if the type is registered, false otherwise
+   *
+   * @example
+   * ```typescript
+   * if (flowTypeRegistry.has("custom-output-v1")) {
+   *   console.log("Custom output type is available");
+   * }
+   * ```
+   */
+  has(id: string): boolean;
+  /**
+   * Get the total number of registered types.
+   *
+   * @returns The count of registered types
+   *
+   * @example
+   * ```typescript
+   * console.log(`Registry contains ${flowTypeRegistry.size()} types`);
+   * ```
+   */
+  size(): number;
+}
 /**
- * Effect-TS context tag for the DataStore routing service.
+ * Global singleton instance of the flow type registry.
  *
- * Provides access to multiple DataStore instances with routing logic.
+ * Use this instance to register and access node type definitions throughout
+ * your application. The registry is initialized once and shared globally.
  *
  * @example
  * ```typescript
- * const uploadEffect = Effect.gen(function* () {
- *   const dataStores = yield* UploadFileDataStores;
- *   // Route to specific storage based on storageId
- *   const dataStore = yield* dataStores.getDataStore("s3-production", clientId);
- *   const file = yield* dataStore.create(uploadFile);
- *   return file;
+ * import { flowTypeRegistry } from "@uploadista/core/flow";
+ *
+ * // Register a type
+ * flowTypeRegistry.register({
+ *   id: "my-output-v1",
+ *   category: "output",
+ *   schema: mySchema,
+ *   version: "1.0.0",
+ *   description: "My custom output type",
  * });
+ *
+ * // Validate data
+ * const result = flowTypeRegistry.validate("my-output-v1", data);
  * ```
  */
-declare class UploadFileDataStores extends UploadFileDataStores_base {}
+declare const flowTypeRegistry: FlowTypeRegistry;
+//#endregion
+//#region src/flow/node-types/index.d.ts
 /**
- * Simplified DataStore configuration for easy setup.
+ * Type ID constants for built-in node types.
  *
- * This type allows flexible configuration:
- * - Single DataStore instance
- * - Multiple named stores with routing
- * - Effect that resolves to a DataStore
- * - Pre-built Effect Layer
+ * Use these constants when creating nodes with type information to ensure
+ * consistency and avoid typos.
  *
  * @example
  * ```typescript
- * // Single store
- * const config: DataStoreConfig = s3DataStore;
- *
- * // Multiple stores with routing
- * const config: DataStoreConfig = {
- *   stores: {
- *     "s3-prod": s3ProdStore,
- *     "s3-dev": s3DevStore,
- *     "local": localFileStore,
- *   },
- *   default: "s3-prod"
- * };
+ * import { STREAMING_INPUT_TYPE_ID } from "@uploadista/core/flow";
  *
- * // Effect that creates a store
- * const config: DataStoreConfig = Effect.gen(function* () {
- *   const kvStore = yield* UploadFileKVStore;
- *   return s3Store(kvStore);
+ * const inputNode = createFlowNode({
+ *   // ... other config
+ *   nodeTypeId: STREAMING_INPUT_TYPE_ID
  * });
- *
- * // Pre-built Layer
- * const config: DataStoreConfig = Layer.succeed(UploadFileDataStores, {...});
  * ```
  */
-type DataStoreConfig = DataStore<UploadFile> | Effect.Effect<DataStore<UploadFile>, never, UploadFileKVStore> | {
-  stores: Record<string, DataStore<UploadFile> | Effect.Effect<DataStore<UploadFile>, never, UploadFileKVStore>>;
-  default?: string;
-} | Layer.Layer<UploadFileDataStores, never, UploadFileKVStore>;
+declare const STORAGE_OUTPUT_TYPE_ID = "storage-output-v1";
+declare const OCR_OUTPUT_TYPE_ID = "ocr-output-v1";
+declare const IMAGE_DESCRIPTION_OUTPUT_TYPE_ID = "image-description-output-v1";
 /**
- * Type guard to check if a value is a DataStore instance.
- *
- * @param config - The value to check
- * @returns True if the value is a DataStore
+ * OCR output schema - structured text extraction result.
  *
- * @example
- * ```typescript
- * if (isDataStore(config)) {
- *   const capabilities = config.getCapabilities();
- * }
- * ```
+ * @property extractedText - The text extracted from the document
+ * @property format - Output format (text, markdown, or JSON)
+ * @property taskType - Type of OCR task performed
+ * @property confidence - Optional confidence score (0-1)
  */
-declare const isDataStore: (config: DataStoreConfig) => config is DataStore<UploadFile>;
+declare const ocrOutputSchema: z.ZodObject<{
+  extractedText: z.ZodString;
+  format: z.ZodEnum<{
+    markdown: "markdown";
+    plain: "plain";
+    structured: "structured";
+  }>;
+  taskType: z.ZodEnum<{
+    convertToMarkdown: "convertToMarkdown";
+    freeOcr: "freeOcr";
+    parseFigure: "parseFigure";
+    locateObject: "locateObject";
+  }>;
+  confidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type OcrOutput = z.infer<typeof ocrOutputSchema>;
 /**
- * Creates an Effect Layer from simplified DataStoreConfig.
- *
- * This function converts any DataStoreConfig format into a proper Effect Layer
- * that can be provided to the UploadFileDataStores context tag.
- *
- * It handles:
- * - Single DataStore: Wraps in a Layer that always returns that store
- * - Multiple stores: Creates routing logic with optional default
- * - Effect<DataStore>: Executes the Effect and wraps the result
- * - Layer: Returns as-is
- *
- * @param config - The DataStore configuration
- * @returns A Layer that provides UploadFileDataStores service
- *
- * @example
- * ```typescript
- * // Create from single store
- * const layer = await createDataStoreLayer(s3DataStore);
- *
- * // Create from multiple stores
- * const layer = await createDataStoreLayer({
- *   stores: {
- *     "production": s3Store,
- *     "development": localStore,
- *   },
- *   default: "development"
- * });
+ * Image description output schema - AI-generated image analysis result.
  *
- * // Use the layer
- * const program = Effect.gen(function* () {
- *   const stores = yield* UploadFileDataStores;
- *   const store = yield* stores.getDataStore("production", null);
- *   return store;
- * }).pipe(Effect.provide(layer));
- * ```
+ * @property description - Human-readable description of the image
+ * @property confidence - Confidence score for the description (0-1)
+ * @property metadata - Additional metadata about the description
  */
-declare const createDataStoreLayer: (config: DataStoreConfig) => Promise<Layer.Layer<UploadFileDataStores, never, UploadFileKVStore>>;
+declare const imageDescriptionOutputSchema: z.ZodObject<{
+  description: z.ZodString;
+  confidence: z.ZodOptional<z.ZodNumber>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type ImageDescriptionOutput = z.infer<typeof imageDescriptionOutputSchema>;
 //#endregion
 //#region src/types/event-broadcaster.d.ts
 /**
@@ -3126,7 +3169,7 @@ declare function createUploadServer(): Effect.Effect<{
   getCapabilities: (storageId: string, clientId: string | null) => Effect.Effect<DataStoreCapabilities, UploadistaError, never>;
   subscribeToUploadEvents: (uploadId: string, connection: WebSocketConnection) => Effect.Effect<void, UploadistaError, never>;
   unsubscribeFromUploadEvents: (uploadId: string) => Effect.Effect<void, UploadistaError, never>;
-}, never, GenerateId | UploadFileDataStores | UploadFileKVStore | UploadEventEmitter>;
+}, never, UploadFileDataStores | UploadFileKVStore | UploadEventEmitter | GenerateId>;
 /**
  * Pre-built UploadServer Effect Layer.
  *
@@ -3157,7 +3200,7 @@ declare function createUploadServer(): Effect.Effect<{
  * }).pipe(Effect.provide(fullUploadSystem));
  * ```
  */
-declare const uploadServer: Layer.Layer<UploadServer, never, GenerateId | UploadFileDataStores | UploadFileKVStore | UploadEventEmitter>;
+declare const uploadServer: Layer.Layer<UploadServer, never, UploadFileDataStores | UploadFileKVStore | UploadEventEmitter | GenerateId>;
 //#endregion
 //#region src/upload/upload-strategy-negotiator.d.ts
 /**
@@ -3712,8 +3755,8 @@ declare function createFlowServer(): Effect.Effect<{
   cancelFlow: (jobId: string, clientId: string | null) => Effect.Effect<FlowJob, UploadistaError, never>;
   subscribeToFlowEvents: (jobId: string, connection: WebSocketConnection) => Effect.Effect<void, UploadistaError, never>;
   unsubscribeFromFlowEvents: (jobId: string) => Effect.Effect<void, UploadistaError, never>;
-}, never, FlowJobKVStore | FlowEventEmitter | UploadServer | FlowProvider>;
-declare const flowServer: Layer.Layer<FlowServer, never, FlowJobKVStore | FlowEventEmitter | UploadServer | FlowProvider>;
+}, never, UploadServer | FlowEventEmitter | FlowJobKVStore | FlowProvider>;
+declare const flowServer: Layer.Layer<FlowServer, never, UploadServer | FlowEventEmitter | FlowJobKVStore | FlowProvider>;
 type FlowServerLayer = typeof flowServer;
 //#endregion
 //#region src/flow/nodes/input-node.d.ts
@@ -3841,154 +3884,6 @@ declare function createInputNode(id: string, params?: InputNodeParams): Effect.E
   type: NodeType.input;
 }, UploadistaError, UploadServer>;
 //#endregion
-//#region src/flow/nodes/storage-node.d.ts
-/**
- * Schema for storage node parameters.
- * Currently empty but can be extended for storage-specific configuration.
- */
-declare const storageParamsSchema: z.ZodObject<{}, z.core.$strip>;
-/**
- * Parameters for the storage node.
- * Currently no parameters are required, but the schema is available for future extensions.
- */
-type StorageParams = z.infer<typeof storageParamsSchema>;
-/**
- * Creates a storage node for storing files in the specified storage.
- *
- * The storage node handles the process of:
- * 1. Reading the input file from the upload server
- * 2. Checking if the file is already in the target storage
- * 3. If not, transferring the file to the target storage
- * 4. Applying optional post-processing
- * 5. Returning the final stored file
- *
- * @param id - Unique identifier for the node
- * @param postProcessFile - Optional function to process the file after storage
- * @returns An Effect that creates a flow node configured for file storage
- *
- * @example
- * ```typescript
- * // Create basic storage node
- * const storageNode = yield* createStorageNode("store-file");
- *
- * // Create storage node with post-processing
- * const storageWithProcessing = yield* createStorageNode("store-and-process", (file) => {
- *   return Effect.succeed({
- *     ...file,
- *     metadata: { ...file.metadata, processed: true }
- *   });
- * });
- * ```
- */
-declare function createStorageNode(id: string, postProcessFile?: (file: UploadFile) => Effect.Effect<UploadFile>): Effect.Effect<FlowNodeData & {
-  inputSchema: z.ZodType<{
-    id: string;
-    offset: number;
-    storage: {
-      id: string;
-      type: string;
-      path?: string | undefined;
-      uploadId?: string | undefined;
-      bucket?: string | undefined;
-      parts?: {
-        partNumber: number;
-        etag: string;
-        size: number;
-      }[] | undefined;
-    };
-    size?: number | undefined;
-    metadata?: Record<string, string | number | boolean> | undefined;
-    creationDate?: string | undefined;
-    url?: string | undefined;
-    sizeIsDeferred?: boolean | undefined;
-    checksum?: string | undefined;
-    checksumAlgorithm?: string | undefined;
-    flow?: {
-      flowId: string;
-      nodeId: string;
-      jobId: string;
-    } | undefined;
-  }, unknown, z.core.$ZodTypeInternals<{
-    id: string;
-    offset: number;
-    storage: {
-      id: string;
-      type: string;
-      path?: string | undefined;
-      uploadId?: string | undefined;
-      bucket?: string | undefined;
-      parts?: {
-        partNumber: number;
-        etag: string;
-        size: number;
-      }[] | undefined;
-    };
-    size?: number | undefined;
-    metadata?: Record<string, string | number | boolean> | undefined;
-    creationDate?: string | undefined;
-    url?: string | undefined;
-    sizeIsDeferred?: boolean | undefined;
-    checksum?: string | undefined;
-    checksumAlgorithm?: string | undefined;
-    flow?: {
-      flowId: string;
-      nodeId: string;
-      jobId: string;
-    } | undefined;
-  }, unknown>>;
-  outputSchema: z.ZodType<UploadFile, unknown, z.core.$ZodTypeInternals<UploadFile, unknown>>;
-  run: (args: {
-    data: {
-      id: string;
-      offset: number;
-      storage: {
-        id: string;
-        type: string;
-        path?: string | undefined;
-        uploadId?: string | undefined;
-        bucket?: string | undefined;
-        parts?: {
-          partNumber: number;
-          etag: string;
-          size: number;
-        }[] | undefined;
-      };
-      size?: number | undefined;
-      metadata?: Record<string, string | number | boolean> | undefined;
-      creationDate?: string | undefined;
-      url?: string | undefined;
-      sizeIsDeferred?: boolean | undefined;
-      checksum?: string | undefined;
-      checksumAlgorithm?: string | undefined;
-      flow?: {
-        flowId: string;
-        nodeId: string;
-        jobId: string;
-      } | undefined;
-    };
-    jobId: string;
-    storageId: string;
-    flowId: string;
-    inputs?: Record<string, unknown>;
-    clientId: string | null;
-  }) => Effect.Effect<NodeExecutionResult<UploadFile>, UploadistaError, never>;
-  condition?: {
-    field: string;
-    operator: string;
-    value: unknown;
-  };
-  multiInput?: boolean;
-  multiOutput?: boolean;
-  pausable?: boolean;
-  retry?: {
-    maxRetries?: number;
-    retryDelay?: number;
-    exponentialBackoff?: boolean;
-  };
-} & {
-  type: NodeType.output;
-}, UploadistaError, UploadServer>;
-//#endregion
 //#region src/flow/nodes/transform-node.d.ts
 /**
  * Configuration object for creating a transform node.
@@ -4000,6 +3895,8 @@ interface TransformNodeConfig {
   name: string;
   /** Description of what the node does */
   description: string;
+  /** Optional node type ID for result type registration */
+  nodeTypeId?: string;
   /** Function that transforms file bytes */
   transform: (bytes: Uint8Array, file: UploadFile) => Effect.Effect<Uint8Array | {
     bytes: Uint8Array;
@@ -4051,6 +3948,7 @@ declare function createTransformNode({
   id,
   name,
   description,
+  nodeTypeId,
   transform
 }: TransformNodeConfig): Effect.Effect<FlowNodeData & {
   inputSchema: zod0.ZodType<UploadFile, unknown, zod_v4_core0.$ZodTypeInternals<UploadFile, unknown>>;
@@ -5473,6 +5371,28 @@ type RemoveBackgroundParams = z.infer<typeof removeBackgroundParamsSchema>;
  * ```
  */
 declare function createTypeGuard<T>(typeId: string): (output: TypedOutput) => output is TypedOutput<T>;
+/**
+ * Type guard for UploadFile objects.
+ *
+ * Validates that a value is a valid UploadFile by checking its structure against the schema.
+ * This is useful for determining if a node result is an UploadFile, which affects
+ * auto-persistence and intermediate file tracking.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a valid UploadFile
+ *
+ * @example
+ * ```typescript
+ * import { isUploadFile } from "@uploadista/core/flow";
+ *
+ * if (isUploadFile(nodeResult)) {
+ *   // nodeResult is typed as UploadFile
+ *   console.log("File ID:", nodeResult.id);
+ *   console.log("Storage:", nodeResult.storage.id);
+ * }
+ * ```
+ */
+declare function isUploadFile(value: unknown): value is UploadFile;
 /**
  * Type guard for storage output nodes.
  *
@@ -5493,6 +5413,56 @@ declare function createTypeGuard<T>(typeId: string): (output: TypedOutput) => ou
  * ```
  */
 declare const isStorageOutput: (output: TypedOutput) => output is TypedOutput<UploadFile>;
+/**
+ * Type guard for OCR output nodes.
+ *
+ * Validates that an output is from an OCR node and contains valid structured OCR data.
+ *
+ * @param output - The output to check
+ * @returns True if the output is an OCR output with valid structured text data
+ *
+ * @example
+ * ```typescript
+ * import { isOcrOutput } from "@uploadista/core/flow";
+ *
+ * if (isOcrOutput(output)) {
+ *   // output.data is typed as OcrOutput
+ *   console.log("Extracted text:", output.data.extractedText);
+ *   console.log("Format:", output.data.format);
+ *   console.log("Task type:", output.data.taskType);
+ * }
+ * ```
+ */
+declare const isOcrOutput: (output: TypedOutput) => output is TypedOutput<{
+  extractedText: string;
+  format: "markdown" | "plain" | "structured";
+  taskType: "convertToMarkdown" | "freeOcr" | "parseFigure" | "locateObject";
+  confidence?: number | undefined;
+}>;
+/**
+ * Type guard for image description output nodes.
+ *
+ * Validates that an output is from an image description node and contains valid description data.
+ *
+ * @param output - The output to check
+ * @returns True if the output is an image description output with valid description data
+ *
+ * @example
+ * ```typescript
+ * import { isImageDescriptionOutput } from "@uploadista/core/flow";
+ *
+ * if (isImageDescriptionOutput(output)) {
+ *   // output.data is typed as ImageDescriptionOutput
+ *   console.log("Description:", output.data.description);
+ *   console.log("Confidence:", output.data.confidence);
+ * }
+ * ```
+ */
+declare const isImageDescriptionOutput: (output: TypedOutput) => output is TypedOutput<{
+  description: string;
+  confidence?: number | undefined;
+  metadata?: Record<string, unknown> | undefined;
+}>;
 /**
  * Filter an array of outputs to only those matching a specific type.
  *
@@ -5946,9 +5916,9 @@ type InferNode<T> = T extends FlowNode<any, any, UploadistaError> ? T : ResolveE
 type ExtractKeysByNodeType<TNodes extends NodeDefinitionsRecord, TType extends NodeType> = { [K in keyof TNodes]: InferNode<TNodes[K]>["type"] extends TType ? K : never }[keyof TNodes];
 type SchemaInfer<T> = T extends z.ZodTypeAny ? z.infer<T> : never;
 type FlowInputMap<TNodes extends NodeDefinitionsRecord> = { [K in Extract<ExtractKeysByNodeType<TNodes, NodeType.input>, string>]: SchemaInfer<InferNode<TNodes[K]>["inputSchema"]> };
-type FlowOutputMap<TNodes extends NodeDefinitionsRecord> = { [K in Extract<ExtractKeysByNodeType<TNodes, NodeType.output>, string>]: SchemaInfer<InferNode<TNodes[K]>["outputSchema"]> };
+type FlowOutputMap<TNodes extends NodeDefinitionsRecord> = { [K in Extract<keyof TNodes, string>]: SchemaInfer<InferNode<TNodes[K]>["outputSchema"]> };
 type FlowInputUnion<TNodes extends NodeDefinitionsRecord> = { [K in Extract<ExtractKeysByNodeType<TNodes, NodeType.input>, string>]: SchemaInfer<InferNode<TNodes[K]>["inputSchema"]> }[Extract<ExtractKeysByNodeType<TNodes, NodeType.input>, string>];
-type FlowOutputUnion<TNodes extends NodeDefinitionsRecord> = { [K in Extract<ExtractKeysByNodeType<TNodes, NodeType.output>, string>]: SchemaInfer<InferNode<TNodes[K]>["outputSchema"]> }[Extract<ExtractKeysByNodeType<TNodes, NodeType.output>, string>];
+type FlowOutputUnion<TNodes extends NodeDefinitionsRecord> = { [K in Extract<keyof TNodes, string>]: SchemaInfer<InferNode<TNodes[K]>["outputSchema"]> }[Extract<keyof TNodes, string>];
 type NodeKey<TNodes extends NodeDefinitionsRecord> = Extract<keyof TNodes, string>;
 type TypedFlowEdge<TNodes extends NodeDefinitionsRecord> = {
   source: NodeKey<TNodes>;
@@ -6071,5 +6041,5 @@ type ResolvedUploadMetadata = {
 };
 declare function resolveUploadMetadata(metadata: FileMetadata): ResolvedUploadMetadata;
 //#endregion
-export { ExtractFrameVideoParams as $, BaseEventEmitterService as $n, FlowNodeData as $r, DocumentAiPluginLayer as $t, DescribeImageParams as A, flowServer as An, TypedKvStore as Ar, sepiaTransformSchema as At, ScanResult as B, UploadServerShape as Bn, ValidationResult as Br, ImageAiContext as Bt, getFirstOutputByType as C, ConditionOperator as Ci, FlowServer as Cn, UploadStrategy as Cr, brightnessTransformSchema as Ct, isStorageOutput as D, getNodeData as Di, FlowWaitUntil as Dn, BaseKvStoreService as Dr, logoTransformSchema as Dt, hasOutputOfType as E, createFlowNode as Ei, FlowServerShape as En, BaseKvStore as Er, grayscaleTransformSchema as Et, ZipParams as F, NegotiatedStrategy as Fn, STORAGE_OUTPUT_TYPE_ID as Fr, watermarkTransformSchema as Ft, VideoPluginLayer as G, Middleware as Gn, createFlowWithSchema as Gr, DocumentPlugin as Gt, VirusScanPluginLayer as H, uploadServer as Hn, Flow as Hr, ImageAiPluginLayer as Ht, ZipPlugin as I, UploadStrategyNegotiator as In, STREAMING_INPUT_TYPE_ID as Ir, ResizeParams as It, trimVideoParamsSchema as J, MiddlewareService as Jn, createFlowEdge as Jr, MergePdfParams as Jt, VideoPluginShape as K, MiddlewareContext as Kn, getFlowData as Kr, DocumentPluginLayer as Kt, ZipPluginLayer as L, UploadStrategyOptions as Ln, FlowTypeRegistry as Lr, resizeParamsSchema as Lt, Plugin as M, FlowJobStatus as Mn, flowJobKvStore as Mr, textTransformSchema as Mt, PluginLayer as N, FlowJobTask as Nn, jsonSerializer as Nr, transformImageParamsSchema as Nt, RemoveBackgroundParams as O, UploadFile as Oi, WaitUntilCallback as On, FlowJobKVStore as Or, resizeTransformSchema as Ot, ZipInput as P, FlowJobTaskStatus as Pn, uploadFileKvStore as Pr, transformationSchema as Pt, resizeVideoParamsSchema as Q, BaseEventEmitter as Qn, FlowNode as Qr, DocumentAiPlugin as Qt, ZipPluginShape as R, UploadServer as Rn, NodeTypeCategory as Rr, OptimizeParams as Rt, filterOutputsByType as S, ConditionField as Si, FlowProviderShape as Sn, UploadFileDataStoresShape as Sr, blurTransformSchema as St, getSingleOutputByType as T, NodeType as Ti, FlowServerOptions as Tn, isDataStore as Tr, flipTransformSchema as Tt, VirusScanPluginShape as U, compareMimeTypes as Un, FlowData as Ur, ImageAiPluginShape as Ut, VirusScanPlugin as V, createUploadServer as Vn, flowTypeRegistry as Vr, ImageAiPlugin as Vt, VideoPlugin as W, detectMimeType as Wn, FlowExecutionResult as Wr, DocumentMetadata as Wt, transcodeVideoParamsSchema as X, InputFile as Xn, CustomTypedOutput as Xr, SplitPdfResult as Xt, TranscodeVideoParams as Y, MiddlewareServiceLive as Yn, BuiltInTypedOutput as Yr, SplitPdfParams as Yt, ResizeVideoParams as Z, inputFileSchema as Zn, FlowConfig as Zr, DocumentAiContext as Zt, ExtractLayerService as _, FlowEventNodeError as _i, InputNodeParams as _n, DataStoreCapabilities as _r, TextTransform as _t, FlowInputMap as a, completeNodeExecution as ai, CredentialProvider as an, flowEventEmitter as ar, ImagePluginShape as at, FlowCondition as b, FlowEventNodeResume as bi, inputNodeParamsSchema as bn, UploadFileDataStore as br, TransformationType as bt, FlowRequirements as c, FlowEvent as ci, ExecutionLevel as cn, WebSocketMessage as cr, ContrastTransform as ct, TypedFlow as d, FlowEventFlowError as di, TransformNodeConfig as dn, UploadEventType as dr, LogoTransform as dt, NodeConnectionValidator as ei, DocumentAiPluginShape as en, EventEmitter as er, extractFrameVideoParamsSchema as et, TypedFlowConfig as f, FlowEventFlowPause as fi, createTransformNode as fn, uploadEventSchema as fr, OverlayPosition as ft, ExtractEffectRequirements as g, FlowEventNodeEnd as gi, InputData as gn, DataStore as gr, SharpenTransform as gt, ExtractEffectError as h, FlowEventJobStart as hi, storageParamsSchema as hn, BufferedUploadFileDataStore as hr, SepiaTransform as ht, runArgsSchema as i, TypedOutput as ii, OcrTaskType as in, eventToMessageSerializer as ir, ImagePluginLayer as it, describeImageParamsSchema as j, FlowJob as jn, UploadFileKVStore as jr, sharpenTransformSchema as jt, removeBackgroundParamsSchema as k, uploadFileSchema as ki, createFlowServer as kn, KvStore as kr, rotateTransformSchema as kt, NodeDefinition as l, FlowEventFlowCancel as li, ParallelScheduler as ln, webSocketMessageSchema as lr, FlipTransform as lt, createFlow as m, FlowEventJobEnd as mi, createStorageNode as mn, EventBroadcasterService as mr, RotateTransform as mt, resolveUploadMetadata as n, NodeTypeMap as ni, OcrResolution as nn, TypedEventEmitter as nr, describeVideoMetadataSchema as nt, FlowOutputMap as o, waitingNodeExecution as oi, CredentialProviderLayer as on, uploadEventEmitter as or, BlurTransform as ot, TypedFlowEdge as p, FlowEventFlowStart as pi, StorageParams as pn, EventBroadcaster as pr, ResizeTransform as pt, TrimVideoParams as q, MiddlewareNext as qn, FlowEdge as qr, DocumentPluginShape as qt, RunArgs as r, TypeCompatibilityChecker as ri, OcrResult as rn, UploadEventEmitter as rr, ImagePlugin as rt, FlowPluginRequirements as s, EventType as si, CredentialProviderShape as sn, WebSocketConnection as sr, BrightnessTransform as st, ResolvedUploadMetadata as t, NodeExecutionResult as ti, OcrParams as tn, FlowEventEmitter as tr, DescribeVideoMetadata as tt, NodeDefinitionsRecord as u, FlowEventFlowEnd as ui, ParallelSchedulerConfig as un, UploadEvent as ur, GrayscaleTransform as ut, ExtractLayerServices as v, FlowEventNodePause as vi, createInputNode as vn, DataStoreConfig as vr, TransformImageParams as vt, getOutputByNodeId as w, ConditionValue as wi, FlowServerLayer as wn, createDataStoreLayer as wr, contrastTransformSchema as wt, createTypeGuard as x, FlowEventNodeStart as xi, FlowProvider as xn, UploadFileDataStores as xr, WatermarkTransform as xt, ResolveEffect as y, FlowEventNodeResponse as yi, inputDataSchema as yn, DataStoreWriteOptions as yr, Transformation as yt, ScanMetadata as z, UploadServerOptions as zn, NodeTypeDefinition as zr, optimizeParamsSchema as zt };
-//# sourceMappingURL=index-Dp6mTOB2.d.cts.map
+export { transcodeVideoParamsSchema as $, BaseEventEmitterService as $n, createFlowEdge as $r, SplitPdfResult as $t, isUploadFile as A, NodeType as Ai, flowServer as An, createFlowWithSchema as Ar, logoTransformSchema as At, ZipPluginLayer as B, UploadServerShape as Bn, UploadStrategy as Br, resizeParamsSchema as Bt, getFirstOutputByType as C, FlowEventNodePause as Ci, FlowServer as Cn, NodeTypeCategory as Cr, TransformationType as Ct, isImageDescriptionOutput as D, ConditionField as Di, FlowWaitUntil as Dn, Flow as Dr, contrastTransformSchema as Dt, hasOutputOfType as E, FlowEventNodeStart as Ei, FlowServerShape as En, flowTypeRegistry as Er, brightnessTransformSchema as Et, Plugin as F, NegotiatedStrategy as Fn, DataStoreConfig as Fr, textTransformSchema as Ft, VirusScanPluginLayer as G, Middleware as Gn, FlowJobKVStore as Gr, ImageAiPluginLayer as Gt, ScanMetadata as H, uploadServer as Hn, isDataStore as Hr, optimizeParamsSchema as Ht, PluginLayer as I, UploadStrategyNegotiator as In, DataStoreWriteOptions as Ir, transformImageParamsSchema as It, VideoPluginLayer as J, MiddlewareService as Jn, UploadFileKVStore as Jr, DocumentPlugin as Jt, VirusScanPluginShape as K, MiddlewareContext as Kn, KvStore as Kr, ImageAiPluginShape as Kt, ZipInput as L, UploadStrategyOptions as Ln, UploadFileDataStore as Lr, transformationSchema as Lt, removeBackgroundParamsSchema as M, getNodeData as Mi, FlowJobStatus as Mn, BufferedUploadFileDataStore as Mr, rotateTransformSchema as Mt, DescribeImageParams as N, UploadFile as Ni, FlowJobTask as Nn, DataStore as Nr, sepiaTransformSchema as Nt, isOcrOutput as O, ConditionOperator as Oi, WaitUntilCallback as On, FlowData as Or, flipTransformSchema as Ot, describeImageParamsSchema as P, uploadFileSchema as Pi, FlowJobTaskStatus as Pn, DataStoreCapabilities as Pr, sharpenTransformSchema as Pt, TranscodeVideoParams as Q, BaseEventEmitter as Qn, FlowEdge as Qr, SplitPdfParams as Qt, ZipParams as R, UploadServer as Rn, UploadFileDataStores as Rr, watermarkTransformSchema as Rt, filterOutputsByType as S, FlowEventNodeError as Si, FlowProviderShape as Sn, FlowTypeRegistry as Sr, Transformation as St, getSingleOutputByType as T, FlowEventNodeResume as Ti, FlowServerOptions as Tn, ValidationResult as Tr, blurTransformSchema as Tt, ScanResult as U, compareMimeTypes as Un, BaseKvStore as Ur, ImageAiContext as Ut, ZipPluginShape as V, createUploadServer as Vn, createDataStoreLayer as Vr, OptimizeParams as Vt, VirusScanPlugin as W, detectMimeType as Wn, BaseKvStoreService as Wr, ImageAiPlugin as Wt, TrimVideoParams as X, InputFile as Xn, jsonSerializer as Xr, DocumentPluginShape as Xt, VideoPluginShape as Y, MiddlewareServiceLive as Yn, flowJobKvStore as Yr, DocumentPluginLayer as Yt, trimVideoParamsSchema as Z, inputFileSchema as Zn, uploadFileKvStore as Zr, MergePdfParams as Zt, ExtractLayerService as _, FlowEventFlowPause as _i, InputNodeParams as _n, OCR_OUTPUT_TYPE_ID as _r, RotateTransform as _t, FlowInputMap as a, NodeConnectionValidator as ai, OcrResolution as an, flowEventEmitter as ar, describeVideoMetadataSchema as at, FlowCondition as b, FlowEventJobStart as bi, inputNodeParamsSchema as bn, imageDescriptionOutputSchema as br, TextTransform as bt, FlowRequirements as c, TypeCompatibilityChecker as ci, CredentialProvider as cn, WebSocketMessage as cr, ImagePluginShape as ct, TypedFlow as d, waitingNodeExecution as di, ExecutionLevel as dn, UploadEventType as dr, ContrastTransform as dt, BuiltInTypedOutput as ei, DocumentAiContext as en, EventEmitter as er, ResizeVideoParams as et, TypedFlowConfig as f, EventType as fi, ParallelScheduler as fn, uploadEventSchema as fr, FlipTransform as ft, ExtractEffectRequirements as g, FlowEventFlowError as gi, InputData as gn, ImageDescriptionOutput as gr, ResizeTransform as gt, ExtractEffectError as h, FlowEventFlowEnd as hi, createTransformNode as hn, IMAGE_DESCRIPTION_OUTPUT_TYPE_ID as hr, OverlayPosition as ht, runArgsSchema as i, FlowNodeData as ii, OcrParams as in, eventToMessageSerializer as ir, DescribeVideoMetadata as it, RemoveBackgroundParams as j, createFlowNode as ji, FlowJob as jn, getFlowData as jr, resizeTransformSchema as jt, isStorageOutput as k, ConditionValue as ki, createFlowServer as kn, FlowExecutionResult as kr, grayscaleTransformSchema as kt, NodeDefinition as l, TypedOutput as li, CredentialProviderLayer as ln, webSocketMessageSchema as lr, BlurTransform as lt, createFlow as m, FlowEventFlowCancel as mi, TransformNodeConfig as mn, EventBroadcasterService as mr, LogoTransform as mt, resolveUploadMetadata as n, FlowConfig as ni, DocumentAiPluginLayer as nn, TypedEventEmitter as nr, ExtractFrameVideoParams as nt, FlowOutputMap as o, NodeExecutionResult as oi, OcrResult as on, uploadEventEmitter as or, ImagePlugin as ot, TypedFlowEdge as p, FlowEvent as pi, ParallelSchedulerConfig as pn, EventBroadcaster as pr, GrayscaleTransform as pt, VideoPlugin as q, MiddlewareNext as qn, TypedKvStore as qr, DocumentMetadata as qt, RunArgs as r, FlowNode as ri, DocumentAiPluginShape as rn, UploadEventEmitter as rr, extractFrameVideoParamsSchema as rt, FlowPluginRequirements as s, NodeTypeMap as si, OcrTaskType as sn, WebSocketConnection as sr, ImagePluginLayer as st, ResolvedUploadMetadata as t, CustomTypedOutput as ti, DocumentAiPlugin as tn, FlowEventEmitter as tr, resizeVideoParamsSchema as tt, NodeDefinitionsRecord as u, completeNodeExecution as ui, CredentialProviderShape as un, UploadEvent as ur, BrightnessTransform as ut, ExtractLayerServices as v, FlowEventFlowStart as vi, createInputNode as vn, OcrOutput as vr, SepiaTransform as vt, getOutputByNodeId as w, FlowEventNodeResponse as wi, FlowServerLayer as wn, NodeTypeDefinition as wr, WatermarkTransform as wt, createTypeGuard as x, FlowEventNodeEnd as xi, FlowProvider as xn, ocrOutputSchema as xr, TransformImageParams as xt, ResolveEffect as y, FlowEventJobEnd as yi, inputDataSchema as yn, STORAGE_OUTPUT_TYPE_ID as yr, SharpenTransform as yt, ZipPlugin as z, UploadServerOptions as zn, UploadFileDataStoresShape as zr, ResizeParams as zt };
+//# sourceMappingURL=index-D9YSNFdA.d.cts.map