@uploadista/core 0.0.10 → 0.0.12

package/dist/{index-BQ8Ns-NS.d.mts → index-DdT18SQi.d.mts}

@@ -762,7 +762,7 @@ type FlowData = {
  * await db.flows.save(flowData);
  * ```
  */
-declare const getFlowData: <TRequirements$1>(flow: Flow<any, any, TRequirements$1>) => FlowData;
+declare const getFlowData: <TRequirements>(flow: Flow<any, any, TRequirements>) => FlowData;
 /**
  * Result of a flow execution - either completed or paused.
  *
@@ -845,21 +845,21 @@ type FlowExecutionResult<TOutput> = {
  * });
  * ```
  */
-type Flow<TFlowInputSchema extends z.ZodSchema<any>, TFlowOutputSchema extends z.ZodSchema<any>, TRequirements$1> = {
+type Flow<TFlowInputSchema extends z.ZodSchema<any>, TFlowOutputSchema extends z.ZodSchema<any>, TRequirements> = {
   id: string;
   name: string;
   nodes: FlowNode<any, any, UploadistaError$1>[];
   edges: FlowEdge[];
   inputSchema: TFlowInputSchema;
   outputSchema: TFlowOutputSchema;
-  onEvent?: FlowConfig<TFlowInputSchema, TFlowOutputSchema, TRequirements$1>["onEvent"];
-  checkJobStatus?: FlowConfig<TFlowInputSchema, TFlowOutputSchema, TRequirements$1>["checkJobStatus"];
+  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$1, TRequirements$1>;
+  }) => Effect.Effect<FlowExecutionResult<Record<string, z.infer<TFlowOutputSchema>>>, UploadistaError$1, TRequirements>;
   resume: (args: {
     jobId: string;
     storageId: string;
@@ -870,7 +870,7 @@ type Flow<TFlowInputSchema extends z.ZodSchema<any>, TFlowOutputSchema extends z
       inputs: Record<string, z.infer<TFlowInputSchema>>;
     };
     clientId: string | null;
-  }) => Effect.Effect<FlowExecutionResult<Record<string, z.infer<TFlowOutputSchema>>>, UploadistaError$1, TRequirements$1>;
+  }) => Effect.Effect<FlowExecutionResult<Record<string, z.infer<TFlowOutputSchema>>>, UploadistaError$1, TRequirements>;
   validateTypes: () => {
     isValid: boolean;
     errors: string[];
@@ -952,7 +952,7 @@ type Flow<TFlowInputSchema extends z.ZodSchema<any>, TFlowOutputSchema extends z
  * @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$1 = never, TNodeError = never, TNodeRequirements = never>(config: FlowConfig<TFlowInputSchema, TFlowOutputSchema, TNodeError, TNodeRequirements>): Effect.Effect<Flow<TFlowInputSchema, TFlowOutputSchema, TRequirements$1>, TNodeError, TNodeRequirements>;
+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/types/upload-file.d.ts
 /**
@@ -2669,7 +2669,7 @@ declare function createUploadServer(): Effect.Effect<{
   getCapabilities: (storageId: string, clientId: string | null) => Effect.Effect<DataStoreCapabilities, UploadistaError$1, never>;
   subscribeToUploadEvents: (uploadId: string, connection: WebSocketConnection) => Effect.Effect<void, UploadistaError$1, never>;
   unsubscribeFromUploadEvents: (uploadId: string) => Effect.Effect<void, UploadistaError$1, never>;
-}, never, UploadFileDataStores | UploadFileKVStore | UploadEventEmitter | GenerateId>;
+}, never, GenerateId | UploadFileDataStores | UploadFileKVStore | UploadEventEmitter>;
 /**
  * Pre-built UploadServer Effect Layer.
  *
@@ -2700,7 +2700,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
 /**
@@ -3035,8 +3035,8 @@ declare class FlowWaitUntil extends FlowWaitUntil_base {
  * const flowProviderLayer = Layer.succeed(FlowProvider, dbFlowProvider);
  * ```
  */
-type FlowProviderShape<TRequirements$1 = any> = {
-  getFlow: (flowId: string, clientId: string | null) => Effect.Effect<Flow<any, any, TRequirements$1>, UploadistaError$1>;
+type FlowProviderShape<TRequirements = any> = {
+  getFlow: (flowId: string, clientId: string | null) => Effect.Effect<Flow<any, any, TRequirements>, UploadistaError$1>;
 };
 declare const FlowProvider_base: Context.TagClass<FlowProvider, "FlowProvider", FlowProviderShape<any>>;
 /**
@@ -3142,9 +3142,9 @@ declare class FlowProvider extends FlowProvider_base {}
  * ```
  */
 type FlowServerShape = {
-  getFlow: <TRequirements$1>(flowId: string, clientId: string | null) => Effect.Effect<Flow<any, any, TRequirements$1>, UploadistaError$1>;
+  getFlow: <TRequirements>(flowId: string, clientId: string | null) => Effect.Effect<Flow<any, any, TRequirements>, UploadistaError$1>;
   getFlowData: (flowId: string, clientId: string | null) => Effect.Effect<FlowData, UploadistaError$1>;
-  runFlow: <TRequirements$1>({
+  runFlow: <TRequirements>({
     flowId,
     storageId,
     clientId,
@@ -3154,8 +3154,8 @@ type FlowServerShape = {
     storageId: string;
     clientId: string | null;
     inputs: any;
-  }) => Effect.Effect<FlowJob, UploadistaError$1, TRequirements$1>;
-  resumeFlow: <TRequirements$1>({
+  }) => Effect.Effect<FlowJob, UploadistaError$1, TRequirements>;
+  resumeFlow: <TRequirements>({
     jobId,
     nodeId,
     newData,
@@ -3165,7 +3165,7 @@ type FlowServerShape = {
     nodeId: string;
     newData: unknown;
     clientId: string | null;
-  }) => Effect.Effect<FlowJob, UploadistaError$1, TRequirements$1>;
+  }) => Effect.Effect<FlowJob, UploadistaError$1, TRequirements>;
   pauseFlow: (jobId: string, clientId: string | null) => Effect.Effect<FlowJob, UploadistaError$1>;
   cancelFlow: (jobId: string, clientId: string | null) => Effect.Effect<FlowJob, UploadistaError$1>;
   getJobStatus: (jobId: string) => Effect.Effect<FlowJob, UploadistaError$1>;
@@ -3212,17 +3212,17 @@ declare class FlowServer extends FlowServer_base {}
  * @property kvStore - KV store for flow job metadata
  */
 type FlowServerOptions = {
-  getFlow: <TRequirements$1>({
+  getFlow: <TRequirements>({
     flowId,
     storageId
   }: {
     flowId: string;
     storageId: string;
-  }) => Promise<Flow<any, any, TRequirements$1>>;
+  }) => Promise<Flow<any, any, TRequirements>>;
   kvStore: KvStore<FlowJob>;
 };
 declare function createFlowServer(): Effect.Effect<{
-  getFlow: <TRequirements$1>(flowId: string, clientId: string | null) => Effect.Effect<Flow<any, any, any>, UploadistaError$1, never>;
+  getFlow: <TRequirements>(flowId: string, clientId: string | null) => Effect.Effect<Flow<any, any, any>, UploadistaError$1, never>;
   getFlowData: (flowId: string, clientId: string | null) => Effect.Effect<FlowData, UploadistaError$1, never>;
   runFlow: ({
     flowId,
@@ -3251,8 +3251,8 @@ declare function createFlowServer(): Effect.Effect<{
   cancelFlow: (jobId: string, clientId: string | null) => Effect.Effect<FlowJob, UploadistaError$1, never>;
   subscribeToFlowEvents: (jobId: string, connection: WebSocketConnection) => Effect.Effect<void, UploadistaError$1, never>;
   unsubscribeFromFlowEvents: (jobId: string) => Effect.Effect<void, UploadistaError$1, never>;
-}, never, UploadServer | FlowEventEmitter | FlowJobKVStore | FlowProvider>;
-declare const flowServer: Layer.Layer<FlowServer, never, UploadServer | FlowEventEmitter | FlowJobKVStore | FlowProvider>;
+}, never, UploadServer | FlowProvider | FlowJobKVStore | FlowEventEmitter>;
+declare const flowServer: Layer.Layer<FlowServer, never, UploadServer | FlowProvider | FlowJobKVStore | FlowEventEmitter>;
 type FlowServerLayer = typeof flowServer;
 //#endregion
 //#region src/flow/nodes/input-node.d.ts
@@ -3595,7 +3595,7 @@ declare class ParallelScheduler {
    * // results will be in order: [result1, result2, result3]
    * ```
    */
-  executeNodesInParallel<T, E, R$1>(nodeExecutors: Array<() => Effect.Effect<T, E, R$1>>): Effect.Effect<T[], E, R$1>;
+  executeNodesInParallel<T, E$1, R$1>(nodeExecutors: Array<() => Effect.Effect<T, E$1, R$1>>): Effect.Effect<T[], E$1, R$1>;
   /**
    * Determines if a set of nodes can be safely executed in parallel.
    *
@@ -3677,6 +3677,7 @@ declare const CredentialProvider_base: Context.TagClass<CredentialProvider, "Cre
  * ```
  */
 declare class CredentialProvider extends CredentialProvider_base {}
+type CredentialProviderLayer = Layer.Layer<CredentialProvider, never, never>;
 //#endregion
 //#region src/flow/plugins/image-ai-plugin.d.ts
 /**
@@ -3735,6 +3736,7 @@ declare const ImageAiPlugin_base: Context.TagClass<ImageAiPlugin, "ImageAiPlugin
  * ```
  */
 declare class ImageAiPlugin extends ImageAiPlugin_base {}
+type ImageAiPluginLayer = Layer.Layer<ImageAiPlugin, never, never>;
 //#endregion
 //#region src/flow/plugins/types/optimize-node.d.ts
 /**
@@ -3777,6 +3779,337 @@ declare const resizeParamsSchema: z.ZodObject<{
  */
 type ResizeParams = z.infer<typeof resizeParamsSchema>;
 //#endregion
+//#region src/flow/plugins/types/transform-image-node.d.ts
+/**
+ * Type of transformation to apply to an image.
+ */
+type TransformationType = "resize" | "blur" | "rotate" | "flip" | "grayscale" | "sepia" | "brightness" | "contrast" | "sharpen" | "watermark" | "logo" | "text";
+/**
+ * Resize transformation parameters.
+ * Resizes the image to the specified dimensions with the given fit mode.
+ */
+declare const resizeTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"resize">;
+  width: z.ZodOptional<z.ZodNumber>;
+  height: z.ZodOptional<z.ZodNumber>;
+  fit: z.ZodEnum<{
+    fill: "fill";
+    contain: "contain";
+    cover: "cover";
+  }>;
+}, z.core.$strip>;
+type ResizeTransform = z.infer<typeof resizeTransformSchema>;
+/**
+ * Blur transformation parameters.
+ * Applies Gaussian blur to the image.
+ */
+declare const blurTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"blur">;
+  sigma: z.ZodNumber;
+}, z.core.$strip>;
+type BlurTransform = z.infer<typeof blurTransformSchema>;
+/**
+ * Rotate transformation parameters.
+ * Rotates the image by the specified angle.
+ */
+declare const rotateTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"rotate">;
+  angle: z.ZodNumber;
+  background: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type RotateTransform = z.infer<typeof rotateTransformSchema>;
+/**
+ * Flip transformation parameters.
+ * Flips the image horizontally or vertically.
+ */
+declare const flipTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"flip">;
+  direction: z.ZodEnum<{
+    horizontal: "horizontal";
+    vertical: "vertical";
+  }>;
+}, z.core.$strip>;
+type FlipTransform = z.infer<typeof flipTransformSchema>;
+/**
+ * Grayscale transformation parameters.
+ * Converts the image to grayscale.
+ */
+declare const grayscaleTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"grayscale">;
+}, z.core.$strip>;
+type GrayscaleTransform = z.infer<typeof grayscaleTransformSchema>;
+/**
+ * Sepia transformation parameters.
+ * Applies a sepia tone effect to the image.
+ */
+declare const sepiaTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"sepia">;
+}, z.core.$strip>;
+type SepiaTransform = z.infer<typeof sepiaTransformSchema>;
+/**
+ * Brightness transformation parameters.
+ * Adjusts the brightness of the image.
+ */
+declare const brightnessTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"brightness">;
+  value: z.ZodNumber;
+}, z.core.$strip>;
+type BrightnessTransform = z.infer<typeof brightnessTransformSchema>;
+/**
+ * Contrast transformation parameters.
+ * Adjusts the contrast of the image.
+ */
+declare const contrastTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"contrast">;
+  value: z.ZodNumber;
+}, z.core.$strip>;
+type ContrastTransform = z.infer<typeof contrastTransformSchema>;
+/**
+ * Sharpen transformation parameters.
+ * Applies sharpening to the image.
+ */
+declare const sharpenTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"sharpen">;
+  sigma: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type SharpenTransform = z.infer<typeof sharpenTransformSchema>;
+/**
+ * Position for overlays (watermarks, logos, text).
+ */
+type OverlayPosition = "top-left" | "top-right" | "bottom-left" | "bottom-right" | "center";
+/**
+ * Watermark transformation parameters.
+ * Overlays a watermark image on the main image.
+ */
+declare const watermarkTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"watermark">;
+  imagePath: z.ZodString;
+  position: z.ZodEnum<{
+    "top-left": "top-left";
+    "top-right": "top-right";
+    "bottom-left": "bottom-left";
+    "bottom-right": "bottom-right";
+    center: "center";
+  }>;
+  opacity: z.ZodNumber;
+  offsetX: z.ZodOptional<z.ZodNumber>;
+  offsetY: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type WatermarkTransform = z.infer<typeof watermarkTransformSchema>;
+/**
+ * Logo transformation parameters.
+ * Overlays a logo image on the main image with scaling.
+ */
+declare const logoTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"logo">;
+  imagePath: z.ZodString;
+  position: z.ZodEnum<{
+    "top-left": "top-left";
+    "top-right": "top-right";
+    "bottom-left": "bottom-left";
+    "bottom-right": "bottom-right";
+    center: "center";
+  }>;
+  scale: z.ZodNumber;
+  offsetX: z.ZodOptional<z.ZodNumber>;
+  offsetY: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type LogoTransform = z.infer<typeof logoTransformSchema>;
+/**
+ * Text transformation parameters.
+ * Overlays text on the image.
+ */
+declare const textTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"text">;
+  text: z.ZodString;
+  position: z.ZodEnum<{
+    "top-left": "top-left";
+    "top-right": "top-right";
+    "bottom-left": "bottom-left";
+    "bottom-right": "bottom-right";
+    center: "center";
+  }>;
+  fontSize: z.ZodNumber;
+  color: z.ZodString;
+  fontFamily: z.ZodOptional<z.ZodString>;
+  offsetX: z.ZodOptional<z.ZodNumber>;
+  offsetY: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type TextTransform = z.infer<typeof textTransformSchema>;
+/**
+ * Schema for validating any transformation type.
+ * This is a discriminated union of all transformation schemas.
+ */
+declare const transformationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"resize">;
+  width: z.ZodOptional<z.ZodNumber>;
+  height: z.ZodOptional<z.ZodNumber>;
+  fit: z.ZodEnum<{
+    fill: "fill";
+    contain: "contain";
+    cover: "cover";
+  }>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"blur">;
+  sigma: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"rotate">;
+  angle: z.ZodNumber;
+  background: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"flip">;
+  direction: z.ZodEnum<{
+    horizontal: "horizontal";
+    vertical: "vertical";
+  }>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"grayscale">;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"sepia">;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"brightness">;
+  value: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"contrast">;
+  value: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"sharpen">;
+  sigma: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"watermark">;
+  imagePath: z.ZodString;
+  position: z.ZodEnum<{
+    "top-left": "top-left";
+    "top-right": "top-right";
+    "bottom-left": "bottom-left";
+    "bottom-right": "bottom-right";
+    center: "center";
+  }>;
+  opacity: z.ZodNumber;
+  offsetX: z.ZodOptional<z.ZodNumber>;
+  offsetY: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"logo">;
+  imagePath: z.ZodString;
+  position: z.ZodEnum<{
+    "top-left": "top-left";
+    "top-right": "top-right";
+    "bottom-left": "bottom-left";
+    "bottom-right": "bottom-right";
+    center: "center";
+  }>;
+  scale: z.ZodNumber;
+  offsetX: z.ZodOptional<z.ZodNumber>;
+  offsetY: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"text">;
+  text: z.ZodString;
+  position: z.ZodEnum<{
+    "top-left": "top-left";
+    "top-right": "top-right";
+    "bottom-left": "bottom-left";
+    "bottom-right": "bottom-right";
+    center: "center";
+  }>;
+  fontSize: z.ZodNumber;
+  color: z.ZodString;
+  fontFamily: z.ZodOptional<z.ZodString>;
+  offsetX: z.ZodOptional<z.ZodNumber>;
+  offsetY: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>], "type">;
+/**
+ * A single image transformation operation.
+ * This is a discriminated union type that can represent any transformation.
+ */
+type Transformation = z.infer<typeof transformationSchema>;
+/**
+ * Parameters for the transform image node.
+ * Contains an ordered array of transformations to apply sequentially.
+ */
+declare const transformImageParamsSchema: z.ZodObject<{
+  transformations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"resize">;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    fit: z.ZodEnum<{
+      fill: "fill";
+      contain: "contain";
+      cover: "cover";
+    }>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"blur">;
+    sigma: z.ZodNumber;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"rotate">;
+    angle: z.ZodNumber;
+    background: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"flip">;
+    direction: z.ZodEnum<{
+      horizontal: "horizontal";
+      vertical: "vertical";
+    }>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"grayscale">;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"sepia">;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"brightness">;
+    value: z.ZodNumber;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"contrast">;
+    value: z.ZodNumber;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"sharpen">;
+    sigma: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"watermark">;
+    imagePath: z.ZodString;
+    position: z.ZodEnum<{
+      "top-left": "top-left";
+      "top-right": "top-right";
+      "bottom-left": "bottom-left";
+      "bottom-right": "bottom-right";
+      center: "center";
+    }>;
+    opacity: z.ZodNumber;
+    offsetX: z.ZodOptional<z.ZodNumber>;
+    offsetY: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"logo">;
+    imagePath: z.ZodString;
+    position: z.ZodEnum<{
+      "top-left": "top-left";
+      "top-right": "top-right";
+      "bottom-left": "bottom-left";
+      "bottom-right": "bottom-right";
+      center: "center";
+    }>;
+    scale: z.ZodNumber;
+    offsetX: z.ZodOptional<z.ZodNumber>;
+    offsetY: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+    position: z.ZodEnum<{
+      "top-left": "top-left";
+      "top-right": "top-right";
+      "bottom-left": "bottom-left";
+      "bottom-right": "bottom-right";
+      center: "center";
+    }>;
+    fontSize: z.ZodNumber;
+    color: z.ZodString;
+    fontFamily: z.ZodOptional<z.ZodString>;
+    offsetX: z.ZodOptional<z.ZodNumber>;
+    offsetY: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+/**
+ * Parameters for the transform image node.
+ */
+type TransformImageParams = z.infer<typeof transformImageParamsSchema>;
+//#endregion
 //#region src/flow/plugins/image-plugin.d.ts
 /**
  * Shape definition for the Image Plugin interface.
@@ -3801,6 +4134,41 @@ type ImagePluginShape = {
    * @throws {UploadistaError} When image resizing fails
    */
   resize: (input: Uint8Array, options: ResizeParams) => Effect.Effect<Uint8Array, UploadistaError>;
+  /**
+   * Applies a single transformation to an image.
+   *
+   * This method is used by the transform image node to apply individual transformations
+   * in a chain. Each transformation receives the output of the previous transformation.
+   *
+   * @param input - The input image as a Uint8Array
+   * @param transformation - The transformation to apply (discriminated union)
+   * @returns An Effect that resolves to the transformed image as a Uint8Array
+   * @throws {UploadistaError} When transformation fails or is unsupported by the plugin
+   *
+   * @example
+   * ```typescript
+   * const program = Effect.gen(function* () {
+   *   const imagePlugin = yield* ImagePlugin;
+   *
+   *   // Apply a single transformation
+   *   const blurred = yield* imagePlugin.transform(imageData, {
+   *     type: 'blur',
+   *     sigma: 5.0
+   *   });
+   *
+   *   // Chain multiple transformations
+   *   const resized = yield* imagePlugin.transform(blurred, {
+   *     type: 'resize',
+   *     width: 800,
+   *     height: 600,
+   *     fit: 'cover'
+   *   });
+   *
+   *   return resized;
+   * });
+   * ```
+   */
+  transform: (input: Uint8Array, transformation: Transformation) => Effect.Effect<Uint8Array, UploadistaError>;
 };
 declare const ImagePlugin_base: Context.TagClass<ImagePlugin, "ImagePlugin", ImagePluginShape>;
 /**
@@ -3823,38 +4191,7 @@ declare const ImagePlugin_base: Context.TagClass<ImagePlugin, "ImagePlugin", Ima
  * ```
  */
 declare class ImagePlugin extends ImagePlugin_base {}
-//#endregion
-//#region src/flow/plugins/types/describe-image-node.d.ts
-/**
- * Zod schema for validating describe image node parameters.
- * Defines the structure and validation rules for image description requests.
- */
-declare const describeImageParamsSchema: z.ZodObject<{
-  serviceType: z.ZodOptional<z.ZodEnum<{
-    replicate: "replicate";
-  }>>;
-}, z.core.$strip>;
-/**
- * Parameters for the describe image node.
- * Controls which AI service to use for generating image descriptions.
- */
-type DescribeImageParams = z.infer<typeof describeImageParamsSchema>;
-//#endregion
-//#region src/flow/plugins/types/remove-background-node.d.ts
-/**
- * Zod schema for validating remove background node parameters.
- * Defines the structure and validation rules for background removal requests.
- */
-declare const removeBackgroundParamsSchema: z.ZodObject<{
-  serviceType: z.ZodOptional<z.ZodEnum<{
-    replicate: "replicate";
-  }>>;
-}, z.core.$strip>;
-/**
- * Parameters for the remove background node.
- * Controls which AI service to use for background removal processing.
- */
-type RemoveBackgroundParams = z.infer<typeof removeBackgroundParamsSchema>;
+type ImagePluginLayer = Layer.Layer<ImagePlugin, never, never>;
 //#endregion
 //#region src/flow/plugins/zip-plugin.d.ts
 /**
@@ -3913,17 +4250,348 @@ declare const ZipPlugin_base: Context.TagClass<ZipPlugin, "ZipPlugin", ZipPlugin
  * ```
  */
 declare class ZipPlugin extends ZipPlugin_base {}
+type ZipPluginLayer = Layer.Layer<ZipPlugin, never, never>;
+//#endregion
+//#region src/flow/plugins/plugins.d.ts
+type Plugin = ImagePlugin | ImageAiPlugin | CredentialProvider | ZipPlugin;
+type PluginLayer = ImagePluginLayer | ImageAiPluginLayer | CredentialProviderLayer | ZipPluginLayer;
+//#endregion
+//#region src/flow/plugins/types/describe-image-node.d.ts
+/**
+ * Zod schema for validating describe image node parameters.
+ * Defines the structure and validation rules for image description requests.
+ */
+declare const describeImageParamsSchema: z.ZodObject<{
+  serviceType: z.ZodOptional<z.ZodEnum<{
+    replicate: "replicate";
+  }>>;
+}, z.core.$strip>;
+/**
+ * Parameters for the describe image node.
+ * Controls which AI service to use for generating image descriptions.
+ */
+type DescribeImageParams = z.infer<typeof describeImageParamsSchema>;
+//#endregion
+//#region src/flow/plugins/types/remove-background-node.d.ts
+/**
+ * Zod schema for validating remove background node parameters.
+ * Defines the structure and validation rules for background removal requests.
+ */
+declare const removeBackgroundParamsSchema: z.ZodObject<{
+  serviceType: z.ZodOptional<z.ZodEnum<{
+    replicate: "replicate";
+  }>>;
+}, z.core.$strip>;
+/**
+ * Parameters for the remove background node.
+ * Controls which AI service to use for background removal processing.
+ */
+type RemoveBackgroundParams = z.infer<typeof removeBackgroundParamsSchema>;
+//#endregion
+//#region src/flow/types/flow-file.d.ts
+/**
+ * Conditional execution rules for flow nodes.
+ *
+ * Conditions allow nodes to execute conditionally based on file properties or metadata.
+ * They are evaluated before node execution and can skip nodes that don't match.
+ *
+ * @module flow/types/flow-file
+ * @see {@link FlowNode} for how conditions are used in nodes
+ *
+ * @example
+ * ```typescript
+ * // Only process images larger than 1MB
+ * const condition: FlowCondition = {
+ *   field: "size",
+ *   operator: "greaterThan",
+ *   value: 1024 * 1024
+ * };
+ *
+ * // Only process JPEG images
+ * const jpegCondition: FlowCondition = {
+ *   field: "mimeType",
+ *   operator: "startsWith",
+ *   value: "image/jpeg"
+ * };
+ * ```
+ */
+/**
+ * Represents a conditional rule for node execution.
+ *
+ * @property field - The file property to check
+ * @property operator - The comparison operator to apply
+ * @property value - The value to compare against
+ *
+ * @remarks
+ * - Fields can check file metadata (mimeType, size) or image properties (width, height)
+ * - String operators (contains, startsWith) work with string values
+ * - Numeric operators (greaterThan, lessThan) work with numeric values
+ * - The extension field checks the file extension without the dot
+ */
+type FlowCondition = {
+  field: "mimeType" | "size" | "width" | "height" | "extension";
+  operator: "equals" | "notEquals" | "greaterThan" | "lessThan" | "contains" | "startsWith";
+  value: string | number;
+};
+//#endregion
+//#region src/flow/types/type-utils.d.ts
+/**
+ * Extracts the service type from an Effect Layer.
+ *
+ * Given a Layer that provides a service, this type utility extracts
+ * the service type from the Layer's type signature.
+ *
+ * @template T - The Layer type to extract from
+ * @returns The service type provided by the layer, or never if T is not a Layer
+ *
+ * @example
+ * ```typescript
+ * type MyLayer = Layer.Layer<ServiceA, never, never>;
+ * type Service = ExtractLayerService<MyLayer>;
+ * // Service = ServiceA
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { ImagePluginLayer } from '@uploadista/core';
+ *
+ * type ImageService = ExtractLayerService<ImagePluginLayer>;
+ * // ImageService = ImagePlugin
+ * ```
+ */
+type ExtractLayerService<T, TError$1 = never, TRequirements = never> = T extends Layer.Layer<infer S, TError$1, TRequirements> ? S : never;
+/**
+ * Extracts all service types from a tuple of layers and returns them as a union.
+ *
+ * This type recursively processes a tuple of Layer types and extracts all
+ * the services they provide, combining them into a single union type.
+ *
+ * @template T - A readonly tuple of Layer types
+ * @returns A union of all service types provided by the layers
+ *
+ * @example
+ * ```typescript
+ * type Layers = [
+ *   Layer.Layer<ServiceA, never, never>,
+ *   Layer.Layer<ServiceB, never, never>,
+ *   Layer.Layer<ServiceC, never, never>
+ * ];
+ * type Services = ExtractLayerServices<Layers>;
+ * // Services = ServiceA | ServiceB | ServiceC
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { ImagePluginLayer, ZipPluginLayer } from '@uploadista/core';
+ *
+ * type PluginLayers = [ImagePluginLayer, ZipPluginLayer];
+ * type AllServices = ExtractLayerServices<PluginLayers>;
+ * // AllServices = ImagePlugin | ZipPlugin
+ * ```
+ */
+type ExtractLayerServices<T extends readonly Layer.Layer<any, any, any>[]> = T[number] extends Layer.Layer<infer S, any, any> ? S : never;
+/**
+ * Unwraps an Effect type to extract its success value type.
+ *
+ * If the input type is an Effect, this extracts the success type (first type parameter).
+ * If the input is not an Effect, it returns the type unchanged.
+ *
+ * @template T - The type to resolve, potentially an Effect
+ * @returns The success type if T is an Effect, otherwise T
+ *
+ * @example
+ * ```typescript
+ * type MyEffect = Effect.Effect<string, Error, never>;
+ * type Result = ResolveEffect<MyEffect>;
+ * // Result = string
+ * ```
+ *
+ * @example
+ * ```typescript
+ * type NonEffect = { data: string };
+ * type Result = ResolveEffect<NonEffect>;
+ * // Result = { data: string }
+ * ```
+ */
+type ResolveEffect<T> = T extends Effect.Effect<infer S, any, any> ? S : T;
+/**
+ * Extracts the error type from an Effect.
+ *
+ * Given an Effect type, this utility extracts the error type
+ * (second type parameter) from the Effect's type signature.
+ *
+ * @template T - The Effect type to extract from
+ * @returns The error type of the Effect, or never if T is not an Effect
+ *
+ * @example
+ * ```typescript
+ * type MyEffect = Effect.Effect<string, ValidationError, never>;
+ * type ErrorType = ExtractEffectError<MyEffect>;
+ * // ErrorType = ValidationError
+ * ```
+ *
+ * @example
+ * ```typescript
+ * type SafeEffect = Effect.Effect<number, never, SomeService>;
+ * type ErrorType = ExtractEffectError<SafeEffect>;
+ * // ErrorType = never (no errors possible)
+ * ```
+ */
+type ExtractEffectError<T> = T extends Effect.Effect<any, infer E, any> ? E : never;
+/**
+ * Extracts the requirements (context) type from an Effect.
+ *
+ * Given an Effect type, this utility extracts the requirements type
+ * (third type parameter) from the Effect's type signature. This represents
+ * the services that must be provided for the Effect to run.
+ *
+ * @template T - The Effect type to extract from
+ * @returns The requirements type of the Effect, or never if T is not an Effect
+ *
+ * @example
+ * ```typescript
+ * type MyEffect = Effect.Effect<string, Error, Database | Logger>;
+ * type Requirements = ExtractEffectRequirements<MyEffect>;
+ * // Requirements = Database | Logger
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { ImagePlugin, ZipPlugin } from '@uploadista/core';
+ *
+ * type ProcessEffect = Effect.Effect<
+ *   ProcessedImage,
+ *   ProcessError,
+ *   ImagePlugin | ZipPlugin
+ * >;
+ * type Needed = ExtractEffectRequirements<ProcessEffect>;
+ * // Needed = ImagePlugin | ZipPlugin
+ * ```
+ */
+type ExtractEffectRequirements<T> = T extends Effect.Effect<any, any, infer R> ? R : never;
 //#endregion
 //#region src/flow/typed-flow.d.ts
+/**
+ * Defines a node that can be used in a typed flow.
+ *
+ * A node definition can be either:
+ * - A plain FlowNode object
+ * - An Effect that resolves to a FlowNode (for nodes requiring dependencies)
+ *
+ * @template TNodeError - The error types that the node can produce
+ * @template TNodeRequirements - The services/dependencies the node requires
+ */
 type NodeDefinition<TNodeError = never, TNodeRequirements = never> = FlowNode<any, any, UploadistaError$1> | Effect.Effect<FlowNode<any, any, UploadistaError$1>, TNodeError, TNodeRequirements>;
+/**
+ * A record mapping node IDs to their definitions.
+ *
+ * This is the primary type used for defining the nodes in a typed flow,
+ * allowing TypeScript to infer input/output schemas and requirements.
+ *
+ * @example
+ * ```typescript
+ * const nodes = {
+ *   input: fileInputNode,
+ *   resize: Effect.succeed(imageResizeNode),
+ *   output: s3OutputNode
+ * } satisfies NodeDefinitionsRecord;
+ * ```
+ */
 type NodeDefinitionsRecord = Record<string, NodeDefinition<any, any>>;
+/**
+ * Extracts the error type from a NodeDefinition.
+ *
+ * If the node is an Effect, extracts its error type.
+ * If the node is a plain FlowNode, returns never (no errors).
+ */
 type NodeDefinitionError<T> = T extends Effect.Effect<FlowNode<any, any, UploadistaError$1>, infer TError, any> ? TError : never;
-type NodeDefinitionRequirements<T> = T extends Effect.Effect<FlowNode<any, any, UploadistaError$1>, any, infer TRequirements> ? TRequirements : never;
+/**
+ * Extracts the requirements (dependencies) from a NodeDefinition.
+ *
+ * Uses the shared ExtractEffectRequirements utility for consistency.
+ */
+type NodeDefinitionRequirements<T> = ExtractEffectRequirements<T>;
+/**
+ * Extracts all possible errors from all nodes in a flow as a union.
+ *
+ * This iterates through all nodes in the record and combines their
+ * error types into a single union type.
+ */
 type NodesErrorUnion<TNodes extends NodeDefinitionsRecord> = { [K in keyof TNodes]: NodeDefinitionError<TNodes[K]> }[keyof TNodes];
+/**
+ * Extracts all service requirements from all nodes in a flow as a union.
+ *
+ * This iterates through all nodes in the record and combines their
+ * requirement types into a single union type representing all services
+ * needed by the flow.
+ *
+ * @template TNodes - The record of node definitions
+ *
+ * @example
+ * ```typescript
+ * const nodes = {
+ *   resize: imageResizeNode, // requires ImagePlugin
+ *   zip: zipNode,           // requires ZipPlugin
+ * };
+ * type Requirements = NodesRequirementsUnion<typeof nodes>;
+ * // Requirements = ImagePlugin | ZipPlugin
+ * ```
+ */
 type NodesRequirementsUnion<TNodes extends NodeDefinitionsRecord> = { [K in keyof TNodes]: NodeDefinitionRequirements<TNodes[K]> }[keyof TNodes];
+/**
+ * Extracts all service requirements from a flow's nodes.
+ *
+ * This includes all services required by any node in the flow,
+ * including UploadServer (which is provided by the runtime).
+ *
+ * @template TNodes - The record of node definitions
+ *
+ * @example
+ * ```typescript
+ * const myFlow = createFlow({
+ *   nodes: {
+ *     input: fileInputNode,
+ *     process: imageProcessNode, // requires ImagePlugin
+ *   },
+ *   edges: [...]
+ * });
+ * type AllRequirements = FlowRequirements<typeof myFlow.nodes>;
+ * // AllRequirements = ImagePlugin | UploadServer
+ * ```
+ */
 type FlowRequirements<TNodes extends NodeDefinitionsRecord> = NodesRequirementsUnion<TNodes>;
+/**
+ * Extracts plugin service requirements from a flow, excluding UploadServer.
+ *
+ * This type is useful for determining which plugin layers need to be
+ * provided when creating a server, as UploadServer is automatically
+ * provided by the runtime.
+ *
+ * @template TNodes - The record of node definitions
+ *
+ * @example
+ * ```typescript
+ * const myFlow = createFlow({
+ *   nodes: {
+ *     resize: imageResizeNode, // requires ImagePlugin
+ *     upload: s3OutputNode,   // requires UploadServer
+ *   },
+ *   edges: [...]
+ * });
+ * type PluginRequirements = FlowPluginRequirements<typeof myFlow.nodes>;
+ * // PluginRequirements = ImagePlugin (UploadServer excluded)
+ * ```
+ */
 type FlowPluginRequirements<TNodes extends NodeDefinitionsRecord> = Exclude<FlowRequirements<TNodes>, UploadServer>;
-type InferNode<T> = T extends FlowNode<any, any, UploadistaError$1> ? T : T extends Effect.Effect<infer R, any, any> ? R extends FlowNode<any, any, UploadistaError$1> ? R : never : never;
+/**
+ * Infers the concrete FlowNode type from a NodeDefinition.
+ *
+ * If the definition is already a FlowNode, returns it as-is.
+ * If the definition is an Effect, extracts the FlowNode from the Effect's success type.
+ *
+ * Uses the shared ResolveEffect utility for consistency.
+ */
+type InferNode<T> = T extends FlowNode<any, any, UploadistaError$1> ? T : ResolveEffect<T> extends FlowNode<any, any, UploadistaError$1> ? ResolveEffect<T> : never;
 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"]> };
@@ -3956,6 +4624,40 @@ type TypedFlowConfig<TNodes extends NodeDefinitionsRecord> = {
 declare const typedFlowInputsSymbol: unique symbol;
 declare const typedFlowOutputsSymbol: unique symbol;
 declare const typedFlowPluginsSymbol: unique symbol;
+/**
+ * A type-safe Flow that infers input/output types and requirements from its nodes.
+ *
+ * TypedFlow extends the base Flow type with additional type information that
+ * allows TypeScript to verify inputs, outputs, and plugin requirements at compile time.
+ *
+ * The phantom type properties (using unique symbols) enable type-level metadata
+ * without affecting runtime behavior, allowing other type utilities to extract
+ * this information for validation purposes.
+ *
+ * @template TNodes - Record of node definitions used in the flow
+ * @template TInputSchema - Zod schema for flow inputs (inferred from input nodes)
+ * @template TOutputSchema - Zod schema for flow outputs (inferred from output nodes)
+ *
+ * @example
+ * ```typescript
+ * const myFlow = createFlow({
+ *   nodes: {
+ *     input: fileInputNode,
+ *     resize: imageResizeNode,
+ *     output: s3OutputNode
+ *   },
+ *   edges: [
+ *     { source: 'input', target: 'resize' },
+ *     { source: 'resize', target: 'output' }
+ *   ]
+ * });
+ *
+ * // TypeScript infers:
+ * // - Input types from fileInputNode.inputSchema
+ * // - Output types from s3OutputNode.outputSchema
+ * // - Requirements: ImagePlugin (from resize node)
+ * ```
+ */
 type TypedFlow<TNodes extends NodeDefinitionsRecord, TInputSchema extends z.ZodTypeAny, TOutputSchema extends z.ZodTypeAny> = Flow<TInputSchema, TOutputSchema, FlowRequirements<TNodes>> & {
   run: (args: {
     inputs?: Partial<FlowInputMap<TNodes>>;
@@ -3978,52 +4680,6 @@ type TypedFlow<TNodes extends NodeDefinitionsRecord, TInputSchema extends z.ZodT
 };
 declare function createFlow<TNodes extends NodeDefinitionsRecord>(config: TypedFlowConfig<TNodes>): Effect.Effect<TypedFlow<TNodes, z.ZodType<FlowInputUnion<TNodes>>, z.ZodType<FlowOutputUnion<TNodes>>>, NodesErrorUnion<TNodes> | UploadistaError$1, FlowRequirements<TNodes>>;
 //#endregion
-//#region src/flow/types/flow-file.d.ts
-/**
- * Conditional execution rules for flow nodes.
- *
- * Conditions allow nodes to execute conditionally based on file properties or metadata.
- * They are evaluated before node execution and can skip nodes that don't match.
- *
- * @module flow/types/flow-file
- * @see {@link FlowNode} for how conditions are used in nodes
- *
- * @example
- * ```typescript
- * // Only process images larger than 1MB
- * const condition: FlowCondition = {
- *   field: "size",
- *   operator: "greaterThan",
- *   value: 1024 * 1024
- * };
- *
- * // Only process JPEG images
- * const jpegCondition: FlowCondition = {
- *   field: "mimeType",
- *   operator: "startsWith",
- *   value: "image/jpeg"
- * };
- * ```
- */
-/**
- * Represents a conditional rule for node execution.
- *
- * @property field - The file property to check
- * @property operator - The comparison operator to apply
- * @property value - The value to compare against
- *
- * @remarks
- * - Fields can check file metadata (mimeType, size) or image properties (width, height)
- * - String operators (contains, startsWith) work with string values
- * - Numeric operators (greaterThan, lessThan) work with numeric values
- * - The extension field checks the file extension without the dot
- */
-type FlowCondition = {
-  field: "mimeType" | "size" | "width" | "height" | "extension";
-  operator: "equals" | "notEquals" | "greaterThan" | "lessThan" | "contains" | "startsWith";
-  value: string | number;
-};
-//#endregion
 //#region src/flow/types/run-args.d.ts
 /**
  * Zod schema for validating flow run arguments.
@@ -4064,5 +4720,5 @@ type ResolvedUploadMetadata = {
 };
 declare function resolveUploadMetadata(metadata: FileMetadata): ResolvedUploadMetadata;
 //#endregion
-export { FlowServerShape as $, BaseKvStore as $t, ImageAiContext as A, FlowEventFlowError as An, UploadEventEmitter as At, StorageParams as B, FlowEventNodeStart as Bn, EventBroadcaster as Bt, describeImageParamsSchema as C, TypeCompatibilityChecker as Cn, InputFile as Ct, resizeParamsSchema as D, FlowEvent as Dn, EventEmitter as Dt, ResizeParams as E, EventType as En, BaseEventEmitterService as Et, ExecutionLevel as F, FlowEventNodeEnd as Fn, WebSocketMessage as Ft, createInputNode as G, createFlowNode as Gn, DataStoreConfig as Gt, storageParamsSchema as H, ConditionOperator as Hn, BufferedUploadFileDataStore as Ht, ParallelScheduler as I, FlowEventNodeError as In, webSocketMessageSchema as It, FlowProvider as J, UploadFileDataStores as Jt, inputDataSchema as K, getNodeData as Kn, DataStoreWriteOptions as Kt, ParallelSchedulerConfig as L, FlowEventNodePause as Ln, UploadEvent as Lt, ImageAiPluginShape as M, FlowEventFlowStart as Mn, flowEventEmitter as Mt, CredentialProvider as N, FlowEventJobEnd as Nn, uploadEventEmitter as Nt, OptimizeParams as O, FlowEventFlowCancel as On, FlowEventEmitter as Ot, CredentialProviderShape as P, FlowEventJobStart as Pn, WebSocketConnection as Pt, FlowServerOptions as Q, isDataStore as Qt, TransformNodeConfig as R, FlowEventNodeResponse as Rn, UploadEventType as Rt, DescribeImageParams as S, NodeTypeMap as Sn, MiddlewareServiceLive as St, ImagePluginShape as T, waitingNodeExecution as Tn, BaseEventEmitter as Tt, InputData as U, ConditionValue as Un, DataStore as Ut, createStorageNode as V, ConditionField as Vn, EventBroadcasterService as Vt, InputNodeParams as W, NodeType as Wn, DataStoreCapabilities as Wt, FlowServer as X, UploadStrategy as Xt, FlowProviderShape as Y, UploadFileDataStoresShape as Yt, FlowServerLayer as Z, createDataStoreLayer as Zt, ZipParams as _, FlowConfig as _n, detectMimeType as _t, FlowCondition as a, flowJobKvStore as an, FlowJobStatus as at, RemoveBackgroundParams as b, NodeConnectionValidator as bn, MiddlewareNext as bt, FlowPluginRequirements as c, UploadFile as cn, NegotiatedStrategy as ct, NodeDefinitionsRecord as d, FlowData as dn, UploadServer as dt, BaseKvStoreService as en, FlowWaitUntil as et, TypedFlow as f, FlowExecutionResult as fn, UploadServerOptions as ft, ZipInput as g, createFlowEdge as gn, compareMimeTypes as gt, createFlow as h, FlowEdge as hn, uploadServer as ht, runArgsSchema as i, UploadFileKVStore as in, FlowJob as it, ImageAiPlugin as j, FlowEventFlowPause as jn, eventToMessageSerializer as jt, optimizeParamsSchema as k, FlowEventFlowEnd as kn, TypedEventEmitter as kt, FlowRequirements as l, uploadFileSchema as ln, UploadStrategyNegotiator as lt, TypedFlowEdge as m, getFlowData as mn, createUploadServer as mt, resolveUploadMetadata as n, KvStore as nn, createFlowServer as nt, FlowInputMap as o, jsonSerializer as on, FlowJobTask as ot, TypedFlowConfig as p, createFlowWithSchema as pn, UploadServerShape as pt, inputNodeParamsSchema as q, UploadFileDataStore as qt, RunArgs as r, TypedKvStore as rn, flowServer as rt, FlowOutputMap as s, uploadFileKvStore as sn, FlowJobTaskStatus as st, ResolvedUploadMetadata as t, FlowJobKVStore as tn, WaitUntilCallback as tt, NodeDefinition as u, Flow as un, UploadStrategyOptions as ut, ZipPlugin as v, FlowNode as vn, Middleware as vt, ImagePlugin as w, completeNodeExecution as wn, inputFileSchema as wt, removeBackgroundParamsSchema as x, NodeExecutionResult as xn, MiddlewareService as xt, ZipPluginShape as y, FlowNodeData as yn, MiddlewareContext as yt, createTransformNode as z, FlowEventNodeResume as zn, uploadEventSchema as zt };
-//# sourceMappingURL=index-BQ8Ns-NS.d.mts.map
+export { contrastTransformSchema as $, FlowExecutionResult as $n, UploadServerOptions as $t, ZipPluginLayer as A, DataStore as An, ConditionValue as Ar, InputData as At, LogoTransform as B, BaseKvStore as Bn, FlowServerShape as Bt, DescribeImageParams as C, webSocketMessageSchema as Cn, FlowEventNodeError as Cr, ParallelScheduler as Ct, ZipInput as D, EventBroadcaster as Dn, FlowEventNodeStart as Dr, StorageParams as Dt, PluginLayer as E, uploadEventSchema as En, FlowEventNodeResume as Er, createTransformNode as Et, BlurTransform as F, UploadFileDataStores as Fn, FlowProvider as Ft, SharpenTransform as G, UploadFileKVStore as Gn, FlowJob as Gt, ResizeTransform as H, FlowJobKVStore as Hn, WaitUntilCallback as Ht, BrightnessTransform as I, UploadFileDataStoresShape as In, FlowProviderShape as It, Transformation as J, uploadFileKvStore as Jn, FlowJobTaskStatus as Jt, TextTransform as K, flowJobKvStore as Kn, FlowJobStatus as Kt, ContrastTransform as L, UploadStrategy as Ln, FlowServer as Lt, ImagePlugin as M, DataStoreConfig as Mn, createFlowNode as Mr, createInputNode as Mt, ImagePluginLayer as N, DataStoreWriteOptions as Nn, getNodeData as Nr, inputDataSchema as Nt, ZipParams as O, EventBroadcasterService as On, ConditionField as Or, createStorageNode as Ot, ImagePluginShape as P, UploadFileDataStore as Pn, inputNodeParamsSchema as Pt, brightnessTransformSchema as Q, FlowData as Qn, UploadServer as Qt, FlipTransform as R, createDataStoreLayer as Rn, FlowServerLayer as Rt, removeBackgroundParamsSchema as S, WebSocketMessage as Sn, FlowEventNodeEnd as Sr, ExecutionLevel as St, Plugin as T, UploadEventType as Tn, FlowEventNodeResponse as Tr, TransformNodeConfig as Tt, RotateTransform as U, KvStore as Un, createFlowServer as Ut, OverlayPosition as V, BaseKvStoreService as Vn, FlowWaitUntil as Vt, SepiaTransform as W, TypedKvStore as Wn, flowServer as Wt, WatermarkTransform as X, uploadFileSchema as Xn, UploadStrategyNegotiator as Xt, TransformationType as Y, UploadFile as Yn, NegotiatedStrategy as Yt, blurTransformSchema as Z, Flow as Zn, UploadStrategyOptions as Zt, ExtractLayerService as _, UploadEventEmitter as _n, FlowEventFlowError as _r, ImageAiPluginLayer as _t, FlowInputMap as a, Middleware as an, FlowNode as ar, sepiaTransformSchema as at, FlowCondition as b, uploadEventEmitter as bn, FlowEventJobEnd as br, CredentialProviderLayer as bt, FlowRequirements as c, MiddlewareService as cn, NodeExecutionResult as cr, transformImageParamsSchema as ct, TypedFlow as d, inputFileSchema as dn, completeNodeExecution as dr, ResizeParams as dt, UploadServerShape as en, createFlowWithSchema as er, flipTransformSchema as et, TypedFlowConfig as f, BaseEventEmitter as fn, waitingNodeExecution as fr, resizeParamsSchema as ft, ExtractEffectRequirements as g, TypedEventEmitter as gn, FlowEventFlowEnd as gr, ImageAiPlugin as gt, ExtractEffectError as h, FlowEventEmitter as hn, FlowEventFlowCancel as hr, ImageAiContext as ht, runArgsSchema as i, detectMimeType as in, FlowConfig as ir, rotateTransformSchema as it, ZipPluginShape as j, DataStoreCapabilities as jn, NodeType as jr, InputNodeParams as jt, ZipPlugin as k, BufferedUploadFileDataStore as kn, ConditionOperator as kr, storageParamsSchema as kt, NodeDefinition as l, MiddlewareServiceLive as ln, NodeTypeMap as lr, transformationSchema as lt, createFlow as m, EventEmitter as mn, FlowEvent as mr, optimizeParamsSchema as mt, resolveUploadMetadata as n, uploadServer as nn, FlowEdge as nr, logoTransformSchema as nt, FlowOutputMap as o, MiddlewareContext as on, FlowNodeData as or, sharpenTransformSchema as ot, TypedFlowEdge as p, BaseEventEmitterService as pn, EventType as pr, OptimizeParams as pt, TransformImageParams as q, jsonSerializer as qn, FlowJobTask as qt, RunArgs as r, compareMimeTypes as rn, createFlowEdge as rr, resizeTransformSchema as rt, FlowPluginRequirements as s, MiddlewareNext as sn, NodeConnectionValidator as sr, textTransformSchema as st, ResolvedUploadMetadata as t, createUploadServer as tn, getFlowData as tr, grayscaleTransformSchema as tt, NodeDefinitionsRecord as u, InputFile as un, TypeCompatibilityChecker as ur, watermarkTransformSchema as ut, ExtractLayerServices as v, eventToMessageSerializer as vn, FlowEventFlowPause as vr, ImageAiPluginShape as vt, describeImageParamsSchema as w, UploadEvent as wn, FlowEventNodePause as wr, ParallelSchedulerConfig as wt, RemoveBackgroundParams as x, WebSocketConnection as xn, FlowEventJobStart as xr, CredentialProviderShape as xt, ResolveEffect as y, flowEventEmitter as yn, FlowEventFlowStart as yr, CredentialProvider as yt, GrayscaleTransform as z, isDataStore as zn, FlowServerOptions as zt };
+//# sourceMappingURL=index-DdT18SQi.d.mts.map