@uploadista/core 0.0.13 → 0.0.14

package/dist/{index-4VDJDcWM.d.cts → index-5K4oXy67.d.cts}

@@ -1,10 +1,158 @@
-import { n as UploadistaError } from "./uploadista-error-BQLhNZcY.cjs";
-import { l as GenerateId, p as GenerateIdShape } from "./index-qZ90PVNl.cjs";
+import { n as UploadistaError } from "./uploadista-error-DgdQnozn.cjs";
+import { l as GenerateId, p as GenerateIdShape } from "./index-T6MZvUlM.cjs";
 import { Context, Effect, Layer, Option, Stream } from "effect";
 import * as zod0 from "zod";
 import z$1, { z } from "zod";
 import * as zod_v4_core0 from "zod/v4/core";
 
+//#region src/types/upload-file.d.ts
+
+/**
+ * Zod schema for validating UploadFile objects.
+ *
+ * This schema defines the structure and validation rules for upload file metadata.
+ * Use this schema to parse and validate UploadFile data from external sources.
+ *
+ * @see {@link UploadFile} for the TypeScript type
+ */
+declare const uploadFileSchema: z.ZodObject<{
+  id: z.ZodString;
+  size: z.ZodOptional<z.ZodNumber>;
+  offset: z.ZodNumber;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+  creationDate: z.ZodOptional<z.ZodString>;
+  url: z.ZodOptional<z.ZodString>;
+  sizeIsDeferred: z.ZodOptional<z.ZodBoolean>;
+  checksum: z.ZodOptional<z.ZodString>;
+  checksumAlgorithm: z.ZodOptional<z.ZodString>;
+  storage: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    uploadId: z.ZodOptional<z.ZodString>;
+    bucket: z.ZodOptional<z.ZodString>;
+    parts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      partNumber: z.ZodNumber;
+      etag: z.ZodString;
+      size: z.ZodNumber;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>;
+  flow: z.ZodOptional<z.ZodObject<{
+    flowId: z.ZodString;
+    nodeId: z.ZodString;
+    jobId: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Represents an uploaded file with its metadata and storage information.
+ *
+ * This is the core data structure that tracks file uploads throughout their lifecycle.
+ * It contains all metadata needed to resume uploads, track progress, and locate files
+ * in storage backends.
+ *
+ * @property id - Unique identifier for this upload
+ * @property offset - Current byte offset (how many bytes have been uploaded)
+ * @property storage - Storage backend information
+ * @property storage.id - Storage backend identifier (e.g., "s3-production")
+ * @property storage.type - Storage backend type (e.g., "s3", "azure", "gcs")
+ * @property storage.path - Optional path prefix within the storage backend
+ * @property storage.uploadId - Optional backend-specific upload ID (e.g., S3 multipart upload ID)
+ * @property storage.bucket - Optional bucket or container name
+ * @property storage.parts - Optional array of uploaded parts (used by data stores that need to track parts locally, like R2)
+ * @property flow - Optional flow processing information (when file is part of a flow)
+ * @property flow.flowId - ID of the flow processing this file
+ * @property flow.nodeId - ID of the flow node that created this file
+ * @property flow.jobId - ID of the flow job execution
+ * @property size - Total file size in bytes (undefined if deferred)
+ * @property metadata - Custom key-value metadata attached to the file
+ * @property creationDate - ISO 8601 timestamp when upload was created
+ * @property url - Optional public URL to access the file
+ * @property sizeIsDeferred - True if file size is not known at upload start
+ * @property checksum - Optional file checksum/hash value
+ * @property checksumAlgorithm - Algorithm used for checksum (e.g., "md5", "sha256")
+ *
+ * @example
+ * ```typescript
+ * // Create an UploadFile for a new upload
+ * const uploadFile: UploadFile = {
+ *   id: "upload_abc123",
+ *   offset: 0,
+ *   size: 1024000,
+ *   storage: {
+ *     id: "s3-production",
+ *     type: "s3",
+ *     bucket: "my-uploads",
+ *     path: "files/"
+ *   },
+ *   metadata: {
+ *     fileName: "image.jpg",
+ *     contentType: "image/jpeg",
+ *     userId: "user_123"
+ *   },
+ *   creationDate: new Date().toISOString(),
+ *   checksum: "5d41402abc4b2a76b9719d911017c592",
+ *   checksumAlgorithm: "md5"
+ * };
+ *
+ * // UploadFile with flow processing
+ * const flowFile: UploadFile = {
+ *   id: "upload_xyz789",
+ *   offset: 0,
+ *   size: 2048000,
+ *   storage: {
+ *     id: "s3-temp",
+ *     type: "s3",
+ *     bucket: "temp-processing"
+ *   },
+ *   flow: {
+ *     flowId: "flow_resize_optimize",
+ *     nodeId: "input_1",
+ *     jobId: "job_456"
+ *   }
+ * };
+ *
+ * // Resume an interrupted upload
+ * const resumingFile: UploadFile = {
+ *   id: "upload_resume",
+ *   offset: 524288, // Already uploaded 512KB
+ *   size: 1024000,
+ *   storage: {
+ *     id: "s3-production",
+ *     type: "s3",
+ *     uploadId: "multipart_xyz" // S3 multipart upload ID
+ *   }
+ * };
+ * ```
+ */
+type UploadFile = {
+  id: string;
+  offset: number;
+  storage: {
+    id: string;
+    type: string;
+    path?: string | undefined;
+    uploadId?: string | undefined;
+    bucket?: string | undefined;
+    parts?: Array<{
+      partNumber: number;
+      etag: string;
+      size: number;
+    }> | undefined;
+  };
+  flow?: {
+    flowId: string;
+    nodeId: string;
+    jobId: string;
+  };
+  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;
+};
+//#endregion
 //#region src/flow/node.d.ts
 /**
  * Defines the type of node in a flow, determining its role in the processing pipeline.
@@ -65,6 +213,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).
  *
  * @returns An Effect that succeeds with the created FlowNode
  *
@@ -110,7 +259,8 @@ declare function createFlowNode<Input, Output, TType extends NodeType = NodeType
   multiInput,
   multiOutput,
   pausable,
-  retry
+  retry,
+  nodeTypeId
 }: {
   id: string;
   name: string;
@@ -138,9 +288,10 @@ declare function createFlowNode<Input, Output, TType extends NodeType = NodeType
     retryDelay?: number;
     exponentialBackoff?: boolean;
   };
+  nodeTypeId?: string;
 }): Effect.Effect<FlowNode<Input, Output, UploadistaError> & {
   type: TType;
-}>;
+}, UploadistaError>;
 /**
  * Extracts serializable node metadata from a FlowNode instance.
  *
@@ -226,12 +377,31 @@ type FlowEventFlowStart = {
 /**
  * Event emitted when a flow completes successfully.
  *
- * @property result - The final output from all output nodes in the flow
+ * @property outputs - Array of typed outputs from all output nodes in the flow
+ * @property result - Legacy field for backward compatibility (deprecated, use outputs instead)
+ *
+ * @remarks
+ * The `outputs` field contains an array of TypedOutput objects, each with:
+ * - nodeId: The specific node that produced the output
+ * - nodeType: The registered type ID (e.g., "storage-output-v1")
+ * - data: The actual output data
+ * - timestamp: When the output was produced
+ *
+ * @example
+ * ```typescript
+ * // Handle flow completion with typed outputs
+ * if (event.eventType === EventType.FlowEnd && event.outputs) {
+ *   for (const output of event.outputs) {
+ *     console.log(`${output.nodeId} (${output.nodeType}):`, output.data);
+ *   }
+ * }
+ * ```
  */
 type FlowEventFlowEnd = {
   jobId: string;
   flowId: string;
   eventType: EventType.FlowEnd;
+  outputs?: TypedOutput[];
   result?: unknown;
 };
 /**
@@ -299,7 +469,11 @@ type FlowEventNodeError = {
 /**
  * Event emitted when a node completes successfully.
  *
- * @property result - The output data produced by the node
+ * @property result - The typed output data produced by the node
+ *
+ * @remarks
+ * For output nodes, the result will be a TypedOutput containing type information.
+ * For other nodes, it may be untyped (nodeType will be undefined).
  */
 type FlowEventNodeEnd = {
   jobId: string;
@@ -307,7 +481,7 @@ type FlowEventNodeEnd = {
   nodeId: string;
   eventType: EventType.NodeEnd;
   nodeName: string;
-  result?: unknown;
+  result?: TypedOutput | unknown;
 };
 /**
  * Event emitted when a node pauses execution, waiting for additional data.
@@ -402,6 +576,134 @@ type FlowNodeData = {
   description: string;
   type: NodeType;
 };
+/**
+ * Built-in typed outputs with automatic TypeScript narrowing.
+ *
+ * These outputs use discriminated unions to enable automatic type narrowing
+ * in switch statements without requiring type guards.
+ *
+ * @remarks
+ * Built-in types automatically narrow when using switch statements:
+ * ```typescript
+ * switch (output.nodeType) {
+ *   case 'storage-output-v1':
+ *     output.data.url // ✅ TypeScript knows data is UploadFile
+ *     break;
+ * }
+ * ```
+ */
+type BuiltInTypedOutput = {
+  nodeType: "storage-output-v1";
+  data: UploadFile;
+  nodeId: string;
+  timestamp: string;
+} | {
+  nodeType: "streaming-input-v1";
+  data: UploadFile;
+  nodeId: string;
+  timestamp: string;
+};
+/**
+ * Custom typed output for user-defined node types.
+ *
+ * Custom outputs require type guards for type narrowing:
+ * ```typescript
+ * if (isThumbnailOutput(output)) {
+ *   output.data.width // ✅ Type guard narrows data to ThumbnailOutput
+ * }
+ * ```
+ *
+ * @template T - The TypeScript type of the output data
+ */
+type CustomTypedOutput<T = unknown> = {
+  nodeType?: string;
+  data: T;
+  nodeId: string;
+  timestamp: string;
+};
+/**
+ * Typed output structure from a flow node.
+ *
+ * This is a discriminated union that provides automatic type narrowing for
+ * built-in types while maintaining extensibility for custom types.
+ *
+ * @template T - The TypeScript type of the output data (for custom outputs)
+ *
+ * @property nodeId - Node instance ID that produced this output
+ * @property nodeType - Type ID from the registry (e.g., "storage-output-v1")
+ * @property data - The actual output data from the node
+ * @property timestamp - ISO 8601 timestamp when the result was produced
+ *
+ * @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
+ * for (const output of state.flowOutputs) {
+ *   switch (output.nodeType) {
+ *     case 'storage-output-v1':
+ *       // ✅ 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;
+ *   }
+ * }
+ * ```
+ *
+ * **Custom types (require type guards):**
+ * ```typescript
+ * import { isThumbnailOutput } from './type-guards';
+ *
+ * if (isThumbnailOutput(output)) {
+ *   // ✅ Type guard narrows output.data to ThumbnailOutput
+ *   console.log(output.data.width);
+ * }
+ * ```
+ *
+ * **Untyped nodes (backward compatible):**
+ * ```typescript
+ * const untypedOutput: TypedOutput = {
+ *   nodeId: "custom-node-1",
+ *   data: { custom: "data" },
+ *   timestamp: "2024-01-15T10:30:00Z"
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Storage output result (built-in, automatic narrowing)
+ * const output: TypedOutput = {
+ *   nodeId: "storage-1",
+ *   nodeType: "storage-output-v1",
+ *   data: {
+ *     id: "file-123",
+ *     url: "https://cdn.example.com/file.jpg",
+ *     size: 1024000,
+ *     // ... rest of UploadFile
+ *   },
+ *   timestamp: "2024-01-15T10:30:00Z"
+ * };
+ *
+ * // Custom output (requires type guard)
+ * const thumbnailOutput: TypedOutput<ThumbnailOutput> = {
+ *   nodeId: "thumbnail-1",
+ *   nodeType: "thumbnail-output-v1",
+ *   data: {
+ *     url: "https://cdn.example.com/thumb.jpg",
+ *     width: 200,
+ *     height: 200,
+ *     format: "webp",
+ *   },
+ *   timestamp: "2024-01-15T10:30:00Z"
+ * };
+ * ```
+ */
+type TypedOutput<T = unknown> = BuiltInTypedOutput | CustomTypedOutput<T>;
 /**
  * Result of a node execution - either complete or waiting for more data.
  *
@@ -412,10 +714,15 @@ type FlowNodeData = {
  * data (e.g., chunked uploads, external service responses). The flow can be
  * resumed later with the missing data.
  *
+ * Results now include optional type information (`nodeType` and `nodeId`) to
+ * enable type-safe result consumption. These fields are automatically added
+ * by the node execution wrapper when a node is created with a `nodeTypeId`.
+ *
  * @example
  * ```typescript
- * // Node completes immediately
+ * // Node completes immediately with type information
  * return completeNodeExecution({ processedData });
+ * // Result will be wrapped with: { type: "complete", data, nodeType, nodeId }
  *
  * // Node waits for more chunks
  * if (needsMoreData) {
@@ -426,9 +733,13 @@ type FlowNodeData = {
 type NodeExecutionResult<TOutput> = {
   type: "complete";
   data: TOutput;
+  nodeType?: string;
+  nodeId?: string;
 } | {
   type: "waiting";
   partialData?: unknown;
+  nodeType?: string;
+  nodeId?: string;
 };
 /**
  * Helper function to create a complete node execution result.
@@ -790,6 +1101,7 @@ declare const getFlowData: <TRequirements>(flow: Flow<any, any, TRequirements>)
 type FlowExecutionResult<TOutput> = {
   type: "completed";
   result: TOutput;
+  outputs?: TypedOutput[];
 } | {
   type: "paused";
   nodeId: string;
@@ -950,159 +1262,301 @@ type Flow<TFlowInputSchema extends z.ZodSchema<any>, TFlowOutputSchema extends z
  *     return { eventId: event.jobId };
  *   })
  * });
- * ```
+ * ```
+ *
+ * @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.
+ *
+ * - `input`: Nodes that receive data from external sources (e.g., file uploads)
+ * - `output`: Nodes that produce final results (e.g., storage, webhooks, descriptions)
+ */
+type NodeTypeCategory = "input" | "output";
+/**
+ * Defines a registered node type with its schema and metadata.
+ *
+ * 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 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",
+ * };
+ * ```
+ */
+interface NodeTypeDefinition<TSchema = unknown> {
+  id: string;
+  category: NodeTypeCategory;
+  schema: z.ZodSchema<TSchema>;
+  version: string;
+  description: string;
+}
+/**
+ * Result type for validation operations.
+ *
+ * @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
+ * // Register a new type
+ * flowTypeRegistry.register({
+ *   id: "webhook-output-v1",
+ *   category: "output",
+ *   schema: webhookResponseSchema,
+ *   version: "1.0.0",
+ *   description: "HTTP webhook notification output",
+ * });
+ *
+ * // 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);
+ * }
+ * ```
+ */
+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;
+}
+/**
+ * Global singleton instance of the flow type registry.
+ *
+ * Use this instance to register and access node type definitions throughout
+ * your application. The registry is initialized once and shared globally.
+ *
+ * @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",
+ * });
  *
- * @see {@link Flow} for the returned flow type
- * @see {@link FlowConfig} for configuration options
+ * // Validate data
+ * const result = flowTypeRegistry.validate("my-output-v1", data);
+ * ```
  */
-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>;
+declare const flowTypeRegistry: FlowTypeRegistry;
 //#endregion
-//#region src/types/upload-file.d.ts
+//#region src/flow/node-types/index.d.ts
 /**
- * Zod schema for validating UploadFile objects.
+ * Built-in node type registrations for the flow engine.
  *
- * This schema defines the structure and validation rules for upload file metadata.
- * Use this schema to parse and validate UploadFile data from external sources.
+ * This module automatically registers the standard input and output node types
+ * when imported. These types enable type-safe result consumption in clients.
  *
- * @see {@link UploadFile} for the TypeScript type
+ * @module flow/node-types
+ *
+ * @remarks
+ * This module should be imported by the flow engine initialization to ensure
+ * built-in types are registered before any flows are created.
+ *
+ * @example
+ * ```typescript
+ * // Types are automatically registered on import
+ * import "@uploadista/core/flow/node-types";
+ * import { flowTypeRegistry } from "@uploadista/core/flow";
+ *
+ * // Check registered types
+ * const inputTypes = flowTypeRegistry.listByCategory("input");
+ * console.log(inputTypes.map(t => t.id)); // ["streaming-input-v1"]
+ * ```
  */
-declare const uploadFileSchema: z.ZodObject<{
-  id: z.ZodString;
-  size: z.ZodOptional<z.ZodNumber>;
-  offset: z.ZodNumber;
-  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
-  creationDate: z.ZodOptional<z.ZodString>;
-  url: z.ZodOptional<z.ZodString>;
-  sizeIsDeferred: z.ZodOptional<z.ZodBoolean>;
-  checksum: z.ZodOptional<z.ZodString>;
-  checksumAlgorithm: z.ZodOptional<z.ZodString>;
-  storage: z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodString;
-    path: z.ZodOptional<z.ZodString>;
-    uploadId: z.ZodOptional<z.ZodString>;
-    bucket: z.ZodOptional<z.ZodString>;
-    parts: z.ZodOptional<z.ZodArray<z.ZodObject<{
-      partNumber: z.ZodNumber;
-      etag: z.ZodString;
-      size: z.ZodNumber;
-    }, z.core.$strip>>>;
-  }, z.core.$strip>;
-  flow: z.ZodOptional<z.ZodObject<{
-    flowId: z.ZodString;
-    nodeId: z.ZodString;
-    jobId: z.ZodString;
-  }, z.core.$strip>>;
-}, z.core.$strip>;
 /**
- * Represents an uploaded file with its metadata and storage information.
- *
- * This is the core data structure that tracks file uploads throughout their lifecycle.
- * It contains all metadata needed to resume uploads, track progress, and locate files
- * in storage backends.
+ * Type ID constants for built-in node types.
  *
- * @property id - Unique identifier for this upload
- * @property offset - Current byte offset (how many bytes have been uploaded)
- * @property storage - Storage backend information
- * @property storage.id - Storage backend identifier (e.g., "s3-production")
- * @property storage.type - Storage backend type (e.g., "s3", "azure", "gcs")
- * @property storage.path - Optional path prefix within the storage backend
- * @property storage.uploadId - Optional backend-specific upload ID (e.g., S3 multipart upload ID)
- * @property storage.bucket - Optional bucket or container name
- * @property storage.parts - Optional array of uploaded parts (used by data stores that need to track parts locally, like R2)
- * @property flow - Optional flow processing information (when file is part of a flow)
- * @property flow.flowId - ID of the flow processing this file
- * @property flow.nodeId - ID of the flow node that created this file
- * @property flow.jobId - ID of the flow job execution
- * @property size - Total file size in bytes (undefined if deferred)
- * @property metadata - Custom key-value metadata attached to the file
- * @property creationDate - ISO 8601 timestamp when upload was created
- * @property url - Optional public URL to access the file
- * @property sizeIsDeferred - True if file size is not known at upload start
- * @property checksum - Optional file checksum/hash value
- * @property checksumAlgorithm - Algorithm used for checksum (e.g., "md5", "sha256")
+ * Use these constants when creating nodes with type information to ensure
+ * consistency and avoid typos.
  *
  * @example
  * ```typescript
- * // Create an UploadFile for a new upload
- * const uploadFile: UploadFile = {
- *   id: "upload_abc123",
- *   offset: 0,
- *   size: 1024000,
- *   storage: {
- *     id: "s3-production",
- *     type: "s3",
- *     bucket: "my-uploads",
- *     path: "files/"
- *   },
- *   metadata: {
- *     fileName: "image.jpg",
- *     contentType: "image/jpeg",
- *     userId: "user_123"
- *   },
- *   creationDate: new Date().toISOString(),
- *   checksum: "5d41402abc4b2a76b9719d911017c592",
- *   checksumAlgorithm: "md5"
- * };
- *
- * // UploadFile with flow processing
- * const flowFile: UploadFile = {
- *   id: "upload_xyz789",
- *   offset: 0,
- *   size: 2048000,
- *   storage: {
- *     id: "s3-temp",
- *     type: "s3",
- *     bucket: "temp-processing"
- *   },
- *   flow: {
- *     flowId: "flow_resize_optimize",
- *     nodeId: "input_1",
- *     jobId: "job_456"
- *   }
- * };
+ * import { STREAMING_INPUT_TYPE_ID } from "@uploadista/core/flow/node-types";
  *
- * // Resume an interrupted upload
- * const resumingFile: UploadFile = {
- *   id: "upload_resume",
- *   offset: 524288, // Already uploaded 512KB
- *   size: 1024000,
- *   storage: {
- *     id: "s3-production",
- *     type: "s3",
- *     uploadId: "multipart_xyz" // S3 multipart upload ID
- *   }
- * };
+ * const inputNode = createFlowNode({
+ *   // ... other config
+ *   nodeTypeId: STREAMING_INPUT_TYPE_ID
+ * });
  * ```
  */
-type UploadFile = {
-  id: string;
-  offset: number;
-  storage: {
-    id: string;
-    type: string;
-    path?: string | undefined;
-    uploadId?: string | undefined;
-    bucket?: string | undefined;
-    parts?: Array<{
-      partNumber: number;
-      etag: string;
-      size: number;
-    }> | undefined;
-  };
-  flow?: {
-    flowId: string;
-    nodeId: string;
-    jobId: string;
-  };
-  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;
-};
+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
 /**
@@ -2465,6 +2919,201 @@ declare const MiddlewareService_base: Context.TagClass<MiddlewareService, "Middl
 declare class MiddlewareService extends MiddlewareService_base {}
 declare const MiddlewareServiceLive: Layer.Layer<MiddlewareService, never, never>;
 //#endregion
+//#region src/flow/type-guards.d.ts
+/**
+ * Factory function to create type guards for specific node types.
+ *
+ * Creates a TypeScript type guard that validates both the type tag and
+ * the data structure against the registered schema. This enables type-safe
+ * narrowing of TypedOutput objects in TypeScript.
+ *
+ * @template T - The expected TypeScript type after narrowing
+ * @param typeId - The registered type ID to check against (e.g., "storage-output-v1")
+ * @returns A type guard function that narrows TypedOutput to TypedOutput<T>
+ *
+ * @example
+ * ```typescript
+ * import { createTypeGuard } from "@uploadista/core/flow";
+ * import { z } from "zod";
+ *
+ * const descriptionSchema = z.object({
+ *   description: z.string(),
+ *   confidence: z.number(),
+ * });
+ *
+ * type DescriptionOutput = z.infer<typeof descriptionSchema>;
+ *
+ * const isDescriptionOutput = createTypeGuard<DescriptionOutput>(
+ *   "description-output-v1"
+ * );
+ *
+ * // Use in code
+ * if (isDescriptionOutput(output)) {
+ *   // output.data is typed as DescriptionOutput
+ *   console.log(output.data.description);
+ * }
+ * ```
+ */
+declare function createTypeGuard<T>(typeId: string): (output: TypedOutput) => output is TypedOutput<T>;
+/**
+ * Type guard for storage output nodes.
+ *
+ * Validates that an output is from a storage node and contains valid UploadFile data.
+ *
+ * @param output - The output to check
+ * @returns True if the output is a storage output with valid UploadFile data
+ *
+ * @example
+ * ```typescript
+ * import { isStorageOutput } from "@uploadista/core/flow";
+ *
+ * if (isStorageOutput(output)) {
+ *   // output.data is typed as UploadFile
+ *   console.log("File URL:", output.data.url);
+ *   console.log("File size:", output.data.size);
+ * }
+ * ```
+ */
+declare const isStorageOutput: (output: TypedOutput) => output is TypedOutput<UploadFile>;
+/**
+ * Filter an array of outputs to only those matching a specific type.
+ *
+ * This helper function filters outputs using a type guard and returns a
+ * properly typed array of results. It's useful for extracting specific
+ * output types from multi-output flows.
+ *
+ * @template T - The expected output data type
+ * @param outputs - Array of typed outputs to filter
+ * @param typeGuard - Type guard function to use for filtering
+ * @returns Array of outputs that match the type guard, properly typed
+ *
+ * @example
+ * ```typescript
+ * import { filterOutputsByType, isStorageOutput } from "@uploadista/core/flow";
+ *
+ * // Get all storage outputs from a multi-output flow
+ * const storageOutputs = filterOutputsByType(
+ *   flowResult.outputs,
+ *   isStorageOutput
+ * );
+ *
+ * for (const output of storageOutputs) {
+ *   // Each output.data is typed as UploadFile
+ *   console.log("Saved file:", output.data.url);
+ * }
+ * ```
+ */
+declare function filterOutputsByType<T>(outputs: TypedOutput[], typeGuard: (output: TypedOutput) => output is TypedOutput<T>): TypedOutput<T>[];
+/**
+ * Get a single output of a specific type from an array of outputs.
+ *
+ * This helper function finds exactly one output matching the type guard.
+ * It throws an error if no outputs match or if multiple outputs match,
+ * ensuring the caller receives exactly the expected result.
+ *
+ * @template T - The expected output data type
+ * @param outputs - Array of typed outputs to search
+ * @param typeGuard - Type guard function to use for matching
+ * @returns The single matching output, properly typed
+ * @throws {UploadistaError} If no outputs match (OUTPUT_NOT_FOUND)
+ * @throws {UploadistaError} If multiple outputs match (MULTIPLE_OUTPUTS_FOUND)
+ *
+ * @example
+ * ```typescript
+ * import { getSingleOutputByType, isStorageOutput } from "@uploadista/core/flow";
+ *
+ * try {
+ *   const storageOutput = getSingleOutputByType(
+ *     flowResult.outputs,
+ *     isStorageOutput
+ *   );
+ *   // storageOutput.data is typed as UploadFile
+ *   console.log("File saved at:", storageOutput.data.url);
+ * } catch (error) {
+ *   if (error.code === "OUTPUT_NOT_FOUND") {
+ *     console.error("No storage output found");
+ *   } else if (error.code === "MULTIPLE_OUTPUTS_FOUND") {
+ *     console.error("Multiple storage outputs found, expected one");
+ *   }
+ * }
+ * ```
+ */
+declare function getSingleOutputByType<T>(outputs: TypedOutput[], typeGuard: (output: TypedOutput) => output is TypedOutput<T>): Effect.Effect<TypedOutput<T>, UploadistaError>;
+/**
+ * Get the first output of a specific type, if any exists.
+ *
+ * Unlike getSingleOutputByType, this function returns undefined if no outputs
+ * match, and returns the first match if multiple outputs exist. This is useful
+ * when you want a more lenient matching strategy.
+ *
+ * @template T - The expected output data type
+ * @param outputs - Array of typed outputs to search
+ * @param typeGuard - Type guard function to use for matching
+ * @returns The first matching output, or undefined if none match
+ *
+ * @example
+ * ```typescript
+ * import { getFirstOutputByType, isStorageOutput } from "@uploadista/core/flow";
+ *
+ * const storageOutput = getFirstOutputByType(
+ *   flowResult.outputs,
+ *   isStorageOutput
+ * );
+ *
+ * if (storageOutput) {
+ *   console.log("First storage output:", storageOutput.data.url);
+ * } else {
+ *   console.log("No storage outputs found");
+ * }
+ * ```
+ */
+declare function getFirstOutputByType<T>(outputs: TypedOutput[], typeGuard: (output: TypedOutput) => output is TypedOutput<T>): TypedOutput<T> | undefined;
+/**
+ * Get an output by its node ID.
+ *
+ * This helper finds an output produced by a specific node instance,
+ * regardless of its type. Useful when you know the specific node ID
+ * you're looking for.
+ *
+ * @param outputs - Array of typed outputs to search
+ * @param nodeId - The node ID to match
+ * @returns The output from the specified node, or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * import { getOutputByNodeId } from "@uploadista/core/flow";
+ *
+ * const cdnOutput = getOutputByNodeId(flowResult.outputs, "cdn-storage");
+ * if (cdnOutput) {
+ *   console.log("CDN output:", cdnOutput.data);
+ * }
+ * ```
+ */
+declare function getOutputByNodeId(outputs: TypedOutput[], nodeId: string): TypedOutput | undefined;
+/**
+ * Check if any outputs match a specific type.
+ *
+ * Simple predicate function to check if at least one output of a given
+ * type exists in the results.
+ *
+ * @template T - The expected output data type
+ * @param outputs - Array of typed outputs to check
+ * @param typeGuard - Type guard function to use for checking
+ * @returns True if at least one output matches the type guard
+ *
+ * @example
+ * ```typescript
+ * import { hasOutputOfType, isStorageOutput } from "@uploadista/core/flow";
+ *
+ * if (hasOutputOfType(flowResult.outputs, isStorageOutput)) {
+ *   console.log("Flow produced at least one storage output");
+ * } else {
+ *   console.log("No storage outputs in this flow");
+ * }
+ * ```
+ */
+declare function hasOutputOfType<T>(outputs: TypedOutput[], typeGuard: (output: TypedOutput) => output is TypedOutput<T>): boolean;
+//#endregion
 //#region src/upload/mime.d.ts
 /**
  * Detect MIME type from buffer using magic bytes (file signatures).
@@ -2672,7 +3321,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, UploadFileDataStores | UploadFileKVStore | UploadEventEmitter | GenerateId>;
+}, never, GenerateId | UploadFileDataStores | UploadFileKVStore | UploadEventEmitter>;
 /**
  * Pre-built UploadServer Effect Layer.
  *
@@ -2703,7 +3352,7 @@ declare function createUploadServer(): Effect.Effect<{
  * }).pipe(Effect.provide(fullUploadSystem));
  * ```
  */
-declare const uploadServer: Layer.Layer<UploadServer, never, UploadFileDataStores | UploadFileKVStore | UploadEventEmitter | GenerateId>;
+declare const uploadServer: Layer.Layer<UploadServer, never, GenerateId | UploadFileDataStores | UploadFileKVStore | UploadEventEmitter>;
 //#endregion
 //#region src/upload/upload-strategy-negotiator.d.ts
 /**
@@ -2854,16 +3503,6 @@ declare class UploadStrategyNegotiator {
 }
 //#endregion
 //#region src/flow/types/flow-job.d.ts
-/**
- * Flow job tracking and state management types.
- *
- * A FlowJob represents a single execution instance of a flow, tracking its progress,
- * node results, and execution state. Jobs can be paused and resumed, making them
- * suitable for long-running or interactive flows.
- *
- * @module flow/types/flow-job
- * @see {@link FlowServer} for job management operations
- */
 /**
  * Status of an individual node within a flow job.
  *
@@ -2879,11 +3518,20 @@ type FlowJobTaskStatus = "started" | "pending" | "running" | "completed" | "paus
  *
  * @property nodeId - Unique identifier of the node this task represents
  * @property status - Current execution status of the node
- * @property result - Output data from the node (if completed successfully)
+ * @property result - Node execution result data (can be partial data if paused, or complete data if finished)
  * @property error - Error message if the node failed
  * @property retryCount - Number of retry attempts made before success or final failure
  * @property createdAt - When the task was created
  * @property updatedAt - When the task was last updated
+ *
+ * @remarks
+ * The result field can contain:
+ * - Partial/intermediate data when status is "paused" (unknown type)
+ * - Complete data when status is "completed" (could be TypedOutput for output nodes)
+ * - undefined when status is "pending", "running", "started", or "failed"
+ *
+ * For type-safe access to final outputs, use FlowJob.result instead, which contains
+ * the array of TypedOutput from all output nodes.
  */
 type FlowJobTask = {
   nodeId: string;
@@ -2910,7 +3558,7 @@ type FlowJobTask = {
  * @property tasks - Array of node execution tasks
  * @property error - Error message if the job failed
  * @property endedAt - When the job completed or failed
- * @property result - Final output from the flow (only set when completed)
+ * @property result - Array of typed outputs from all output nodes (only set when completed)
  * @property pausedAt - Node ID where execution is paused (if applicable)
  * @property executionState - State needed to resume a paused flow
  * @property intermediateFiles - File IDs to cleanup after completion
@@ -2920,6 +3568,7 @@ type FlowJobTask = {
  * - Paused jobs store execution state and can be resumed with new data
  * - Intermediate files from non-output nodes are automatically cleaned up
  * - Tasks are updated as nodes progress through their lifecycle
+ * - The result field now contains an array of TypedOutput for all output nodes
  *
  * @example
  * ```typescript
@@ -2933,7 +3582,11 @@ type FlowJobTask = {
  * // Poll for status
  * const status = yield* flowServer.getJobStatus(job.id);
  * if (status.status === "completed") {
- *   console.log("Final result:", status.result);
+ *   // Access typed outputs
+ *   console.log("Outputs:", status.result);
+ *   for (const output of status.result || []) {
+ *     console.log(`${output.nodeId} (${output.nodeType}):`, output.data);
+ *   }
  * } else if (status.status === "paused") {
  *   // Resume with additional data
  *   yield* flowServer.resumeFlow({
@@ -2955,7 +3608,7 @@ type FlowJob = {
   tasks: FlowJobTask[];
   error?: string;
   endedAt?: Date;
-  result?: unknown;
+  result?: TypedOutput[];
   pausedAt?: string;
   executionState?: {
     executionOrder: string[];
@@ -3254,8 +3907,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, UploadServer | FlowEventEmitter | FlowJobKVStore | FlowProvider>;
-declare const flowServer: Layer.Layer<FlowServer, never, UploadServer | FlowEventEmitter | FlowJobKVStore | FlowProvider>;
+}, never, FlowProvider | FlowJobKVStore | FlowEventEmitter | UploadServer>;
+declare const flowServer: Layer.Layer<FlowServer, never, FlowProvider | FlowJobKVStore | FlowEventEmitter | UploadServer>;
 type FlowServerLayer = typeof flowServer;
 //#endregion
 //#region src/flow/nodes/input-node.d.ts
@@ -3381,7 +4034,7 @@ declare function createInputNode(id: string, params?: InputNodeParams): Effect.E
   };
 } & {
   type: NodeType.input;
-}, never, UploadServer>;
+}, UploadistaError, UploadServer>;
 //#endregion
 //#region src/flow/nodes/storage-node.d.ts
 /**
@@ -3529,7 +4182,7 @@ declare function createStorageNode(id: string, postProcessFile?: (file: UploadFi
   };
 } & {
   type: NodeType.output;
-}, never, UploadServer>;
+}, UploadistaError, UploadServer>;
 //#endregion
 //#region src/flow/nodes/transform-node.d.ts
 /**
@@ -3620,7 +4273,7 @@ declare function createTransformNode({
   };
 } & {
   type: NodeType;
-}, never, UploadServer>;
+}, UploadistaError, UploadServer>;
 //#endregion
 //#region src/flow/parallel-scheduler.d.ts
 /**
@@ -5051,5 +5704,5 @@ type ResolvedUploadMetadata = {
 };
 declare function resolveUploadMetadata(metadata: FileMetadata): ResolvedUploadMetadata;
 //#endregion
-export { LogoTransform as $, BaseKvStore as $n, FlowServerShape as $t, ZipPluginLayer as A, UploadEventEmitter as An, FlowEventFlowError as Ar, ImageAiPluginLayer as At, resizeVideoParamsSchema as B, EventBroadcaster as Bn, FlowEventNodeStart as Br, StorageParams as Bt, DescribeImageParams as C, InputFile as Cn, TypeCompatibilityChecker as Cr, watermarkTransformSchema as Ct, ZipInput as D, EventEmitter as Dn, FlowEvent as Dr, optimizeParamsSchema as Dt, PluginLayer as E, BaseEventEmitterService as En, EventType as Er, OptimizeParams as Et, TrimVideoParams as F, WebSocketMessage as Fn, FlowEventNodeEnd as Fr, ExecutionLevel as Ft, ImagePlugin as G, DataStoreConfig as Gn, createFlowNode as Gr, createInputNode as Gt, extractFrameVideoParamsSchema as H, BufferedUploadFileDataStore as Hn, ConditionOperator as Hr, storageParamsSchema as Ht, trimVideoParamsSchema as I, webSocketMessageSchema as In, FlowEventNodeError as Ir, ParallelScheduler as It, BlurTransform as J, UploadFileDataStores as Jn, FlowProvider as Jt, ImagePluginLayer as K, DataStoreWriteOptions as Kn, getNodeData as Kr, inputDataSchema as Kt, TranscodeVideoParams as L, UploadEvent as Ln, FlowEventNodePause as Lr, ParallelSchedulerConfig as Lt, VideoPlugin as M, flowEventEmitter as Mn, FlowEventFlowStart as Mr, CredentialProvider as Mt, VideoPluginLayer as N, uploadEventEmitter as Nn, FlowEventJobEnd as Nr, CredentialProviderLayer as Nt, ZipParams as O, FlowEventEmitter as On, FlowEventFlowCancel as Or, ImageAiContext as Ot, VideoPluginShape as P, WebSocketConnection as Pn, FlowEventJobStart as Pr, CredentialProviderShape as Pt, GrayscaleTransform as Q, isDataStore as Qn, FlowServerOptions as Qt, transcodeVideoParamsSchema as R, UploadEventType as Rn, FlowEventNodeResponse as Rr, TransformNodeConfig as Rt, removeBackgroundParamsSchema as S, MiddlewareServiceLive as Sn, NodeTypeMap as Sr, transformationSchema as St, Plugin as T, BaseEventEmitter as Tn, waitingNodeExecution as Tr, resizeParamsSchema as Tt, DescribeVideoMetadata as U, DataStore as Un, ConditionValue as Ur, InputData as Ut, ExtractFrameVideoParams as V, EventBroadcasterService as Vn, ConditionField as Vr, createStorageNode as Vt, describeVideoMetadataSchema as W, DataStoreCapabilities as Wn, NodeType as Wr, InputNodeParams as Wt, ContrastTransform as X, UploadStrategy as Xn, FlowServer as Xt, BrightnessTransform as Y, UploadFileDataStoresShape as Yn, FlowProviderShape as Yt, FlipTransform as Z, createDataStoreLayer as Zn, FlowServerLayer as Zt, ExtractLayerService as _, detectMimeType as _n, FlowConfig as _r, rotateTransformSchema as _t, FlowInputMap as a, FlowJobStatus as an, flowJobKvStore as ar, TextTransform as at, FlowCondition as b, MiddlewareNext as bn, NodeConnectionValidator as br, textTransformSchema as bt, FlowRequirements as c, NegotiatedStrategy as cn, UploadFile as cr, TransformationType as ct, TypedFlow as d, UploadServer as dn, FlowData as dr, brightnessTransformSchema as dt, FlowWaitUntil as en, BaseKvStoreService as er, OverlayPosition as et, TypedFlowConfig as f, UploadServerOptions as fn, FlowExecutionResult as fr, contrastTransformSchema as ft, ExtractEffectRequirements as g, compareMimeTypes as gn, createFlowEdge as gr, resizeTransformSchema as gt, ExtractEffectError as h, uploadServer as hn, FlowEdge as hr, logoTransformSchema as ht, runArgsSchema as i, FlowJob as in, UploadFileKVStore as ir, SharpenTransform as it, ZipPluginShape as j, eventToMessageSerializer as jn, FlowEventFlowPause as jr, ImageAiPluginShape as jt, ZipPlugin as k, TypedEventEmitter as kn, FlowEventFlowEnd as kr, ImageAiPlugin as kt, NodeDefinition as l, UploadStrategyNegotiator as ln, uploadFileSchema as lr, WatermarkTransform as lt, createFlow as m, createUploadServer as mn, getFlowData as mr, grayscaleTransformSchema as mt, resolveUploadMetadata as n, createFlowServer as nn, KvStore as nr, RotateTransform as nt, FlowOutputMap as o, FlowJobTask as on, jsonSerializer as or, TransformImageParams as ot, TypedFlowEdge as p, UploadServerShape as pn, createFlowWithSchema as pr, flipTransformSchema as pt, ImagePluginShape as q, UploadFileDataStore as qn, inputNodeParamsSchema as qt, RunArgs as r, flowServer as rn, TypedKvStore as rr, SepiaTransform as rt, FlowPluginRequirements as s, FlowJobTaskStatus as sn, uploadFileKvStore as sr, Transformation as st, ResolvedUploadMetadata as t, WaitUntilCallback as tn, FlowJobKVStore as tr, ResizeTransform as tt, NodeDefinitionsRecord as u, UploadStrategyOptions as un, Flow as ur, blurTransformSchema as ut, ExtractLayerServices as v, Middleware as vn, FlowNode as vr, sepiaTransformSchema as vt, describeImageParamsSchema as w, inputFileSchema as wn, completeNodeExecution as wr, ResizeParams as wt, RemoveBackgroundParams as x, MiddlewareService as xn, NodeExecutionResult as xr, transformImageParamsSchema as xt, ResolveEffect as y, MiddlewareContext as yn, FlowNodeData as yr, sharpenTransformSchema as yt, ResizeVideoParams as z, uploadEventSchema as zn, FlowEventNodeResume as zr, createTransformNode as zt };
-//# sourceMappingURL=index-4VDJDcWM.d.cts.map
+export { LogoTransform as $, DataStoreWriteOptions as $n, FlowEventNodeResponse as $r, FlowServerShape as $t, ZipPluginLayer as A, InputFile as An, CustomTypedOutput as Ar, ImageAiPluginLayer as At, resizeVideoParamsSchema as B, uploadEventEmitter as Bn, waitingNodeExecution as Br, StorageParams as Bt, DescribeImageParams as C, hasOutputOfType as Cn, FlowData as Cr, watermarkTransformSchema as Ct, ZipInput as D, MiddlewareNext as Dn, FlowEdge as Dr, optimizeParamsSchema as Dt, PluginLayer as E, MiddlewareContext as En, getFlowData as Er, OptimizeParams as Et, TrimVideoParams as F, FlowEventEmitter as Fn, NodeExecutionResult as Fr, ExecutionLevel as Ft, ImagePlugin as G, UploadEventType as Gn, FlowEventFlowError as Gr, createInputNode as Gt, extractFrameVideoParamsSchema as H, WebSocketMessage as Hn, FlowEvent as Hr, storageParamsSchema as Ht, trimVideoParamsSchema as I, TypedEventEmitter as In, NodeTypeMap as Ir, ParallelScheduler as It, BlurTransform as J, EventBroadcasterService as Jn, FlowEventJobEnd as Jr, FlowProvider as Jt, ImagePluginLayer as K, uploadEventSchema as Kn, FlowEventFlowPause as Kr, inputDataSchema as Kt, TranscodeVideoParams as L, UploadEventEmitter as Ln, TypeCompatibilityChecker as Lr, ParallelSchedulerConfig as Lt, VideoPlugin as M, BaseEventEmitter as Mn, FlowNode as Mr, CredentialProvider as Mt, VideoPluginLayer as N, BaseEventEmitterService as Nn, FlowNodeData as Nr, CredentialProviderLayer as Nt, ZipParams as O, MiddlewareService as On, createFlowEdge as Or, ImageAiContext as Ot, VideoPluginShape as P, EventEmitter as Pn, NodeConnectionValidator as Pr, CredentialProviderShape as Pt, GrayscaleTransform as Q, DataStoreConfig as Qn, FlowEventNodePause as Qr, FlowServerOptions as Qt, transcodeVideoParamsSchema as R, eventToMessageSerializer as Rn, TypedOutput as Rr, TransformNodeConfig as Rt, removeBackgroundParamsSchema as S, getSingleOutputByType as Sn, Flow as Sr, transformationSchema as St, Plugin as T, Middleware as Tn, createFlowWithSchema as Tr, resizeParamsSchema as Tt, DescribeVideoMetadata as U, webSocketMessageSchema as Un, FlowEventFlowCancel as Ur, InputData as Ut, ExtractFrameVideoParams as V, WebSocketConnection as Vn, EventType as Vr, createStorageNode as Vt, describeVideoMetadataSchema as W, UploadEvent as Wn, FlowEventFlowEnd as Wr, InputNodeParams as Wt, ContrastTransform as X, DataStore as Xn, FlowEventNodeEnd as Xr, FlowServer as Xt, BrightnessTransform as Y, BufferedUploadFileDataStore as Yn, FlowEventJobStart as Yr, FlowProviderShape as Yt, FlipTransform as Z, DataStoreCapabilities as Zn, FlowEventNodeError as Zr, FlowServerLayer as Zt, ExtractLayerService as _, detectMimeType as _n, FlowTypeRegistry as _r, rotateTransformSchema as _t, FlowInputMap as a, NodeType as ai, FlowJobStatus as an, isDataStore as ar, TextTransform as at, FlowCondition as b, getFirstOutputByType as bn, ValidationResult as br, textTransformSchema as bt, FlowRequirements as c, UploadFile as ci, NegotiatedStrategy as cn, FlowJobKVStore as cr, TransformationType as ct, TypedFlow as d, UploadServer as dn, UploadFileKVStore as dr, brightnessTransformSchema as dt, FlowEventNodeResume as ei, FlowWaitUntil as en, UploadFileDataStore as er, OverlayPosition as et, TypedFlowConfig as f, UploadServerOptions as fn, flowJobKvStore as fr, contrastTransformSchema as ft, ExtractEffectRequirements as g, compareMimeTypes as gn, STREAMING_INPUT_TYPE_ID as gr, resizeTransformSchema as gt, ExtractEffectError as h, uploadServer as hn, STORAGE_OUTPUT_TYPE_ID as hr, logoTransformSchema as ht, runArgsSchema as i, ConditionValue as ii, FlowJob as in, createDataStoreLayer as ir, SharpenTransform as it, ZipPluginShape as j, inputFileSchema as jn, FlowConfig as jr, ImageAiPluginShape as jt, ZipPlugin as k, MiddlewareServiceLive as kn, BuiltInTypedOutput as kr, ImageAiPlugin as kt, NodeDefinition as l, uploadFileSchema as li, UploadStrategyNegotiator as ln, KvStore as lr, WatermarkTransform as lt, createFlow as m, createUploadServer as mn, uploadFileKvStore as mr, grayscaleTransformSchema as mt, resolveUploadMetadata as n, ConditionField as ni, createFlowServer as nn, UploadFileDataStoresShape as nr, RotateTransform as nt, FlowOutputMap as o, createFlowNode as oi, FlowJobTask as on, BaseKvStore as or, TransformImageParams as ot, TypedFlowEdge as p, UploadServerShape as pn, jsonSerializer as pr, flipTransformSchema as pt, ImagePluginShape as q, EventBroadcaster as qn, FlowEventFlowStart as qr, inputNodeParamsSchema as qt, RunArgs as r, ConditionOperator as ri, flowServer as rn, UploadStrategy as rr, SepiaTransform as rt, FlowPluginRequirements as s, getNodeData as si, FlowJobTaskStatus as sn, BaseKvStoreService as sr, Transformation as st, ResolvedUploadMetadata as t, FlowEventNodeStart as ti, WaitUntilCallback as tn, UploadFileDataStores as tr, ResizeTransform as tt, NodeDefinitionsRecord as u, UploadStrategyOptions as un, TypedKvStore as ur, blurTransformSchema as ut, ExtractLayerServices as v, createTypeGuard as vn, NodeTypeCategory as vr, sepiaTransformSchema as vt, describeImageParamsSchema as w, isStorageOutput as wn, FlowExecutionResult as wr, ResizeParams as wt, RemoveBackgroundParams as x, getOutputByNodeId as xn, flowTypeRegistry as xr, transformImageParamsSchema as xt, ResolveEffect as y, filterOutputsByType as yn, NodeTypeDefinition as yr, sharpenTransformSchema as yt, ResizeVideoParams as z, flowEventEmitter as zn, completeNodeExecution as zr, createTransformNode as zt };
+//# sourceMappingURL=index-5K4oXy67.d.cts.map