@uploadista/core 0.0.2

package/dist/index-D-CoVpkZ.d.ts

@@ -0,0 +1,1004 @@
+import { UploadistaError as UploadistaError$1 } from "./uploadista-error-CwxYs4EB.js";
+import { GenerateId, GenerateIdShape } from "./generate-id-Dm-Vboxq.js";
+import { Semaphore } from "./semaphore-DThupBkc.js";
+import { Context, Effect, Layer, Stream } from "effect";
+import z$1, { z } from "zod";
+import { UploadistaError } from "@uploadista/core/errors";
+
+//#region src/flow/node.d.ts
+declare enum NodeType {
+  input = "input",
+  process = "process",
+  output = "output",
+  conditional = "conditional",
+  multiplex = "multiplex",
+  merge = "merge",
+}
+type ConditionField = "mimeType" | "size" | "width" | "height" | "extension";
+type ConditionOperator = "equals" | "notEquals" | "greaterThan" | "lessThan" | "contains" | "startsWith";
+type ConditionValue = string | number;
+declare function createFlowNode<Input, Output, Requirements = never>({
+  id,
+  name,
+  description,
+  type,
+  inputSchema,
+  outputSchema,
+  run,
+  condition,
+  multiInput,
+  multiOutput,
+  pausable
+}: {
+  id: string;
+  name: string;
+  description: string;
+  type: NodeType;
+  inputSchema: z.ZodSchema<Input>;
+  outputSchema: z.ZodSchema<Output>;
+  run: (args: {
+    data: Input;
+    runId: string;
+    storageId: string;
+    flowId: string;
+  }) => Effect.Effect<NodeExecutionResult<Output>, UploadistaError$1, Requirements>;
+  condition?: {
+    field: ConditionField;
+    operator: ConditionOperator;
+    value: ConditionValue;
+  };
+  multiInput?: boolean;
+  multiOutput?: boolean;
+  pausable?: boolean;
+}): Effect.Effect<FlowNode<Input, Output, UploadistaError$1, Requirements>, UploadistaError$1>;
+declare const getNodeData: <Requirements>(node: FlowNode<any, any, UploadistaError$1, Requirements>) => FlowNodeData;
+//#endregion
+//#region src/flow/event.d.ts
+declare enum EventType {
+  JobStart = "job-start",
+  JobEnd = "job-end",
+  FlowStart = "flow-start",
+  FlowEnd = "flow-end",
+  NodeStart = "node-start",
+  NodeEnd = "node-end",
+  NodeError = "node-error",
+  NodeStream = "node-stream",
+  NodeResponse = "node-response",
+}
+type FlowEventJobStart = {
+  jobId: string;
+  eventType: EventType.JobStart;
+};
+type FlowEventJobEnd = {
+  eventId: string;
+  jobId: string;
+  eventType: EventType.JobEnd;
+};
+type FlowEventFlowStart = {
+  jobId: string;
+  flowId: string;
+  eventType: EventType.FlowStart;
+};
+type FlowEventFlowEnd = {
+  eventId: string;
+  jobId: string;
+  flowId: string;
+  eventType: EventType.FlowEnd;
+};
+type FlowEventNodeStart = {
+  jobId: string;
+  flowId: string;
+  nodeId: string;
+  eventType: EventType.NodeStart;
+  nodeName: string;
+  nodeType: NodeType;
+};
+type FlowEventNodeError = {
+  eventId: string;
+  jobId: string;
+  flowId: string;
+  nodeId: string;
+  nodeName: string;
+  eventType: EventType.NodeError;
+  error: string;
+};
+type FlowEventNodeEnd = {
+  eventId: string;
+  jobId: string;
+  flowId: string;
+  nodeId: string;
+  eventType: EventType.NodeEnd;
+  nodeName: string;
+};
+type FlowEventNodeResponse = {
+  jobId: string;
+  flowId: string;
+  nodeId: string;
+  eventType: EventType.NodeResponse;
+  nodeName: string;
+  data: unknown;
+};
+type FlowEvent = FlowEventJobStart | FlowEventJobEnd | FlowEventFlowStart | FlowEventFlowEnd | FlowEventNodeStart | FlowEventNodeEnd | FlowEventNodeError;
+//#endregion
+//#region src/flow/types/flow-types.d.ts
+type NodeTypeMap = Record<string, {
+  input: unknown;
+  output: unknown;
+}>;
+type FlowNodeData = {
+  id: string;
+  name: string;
+  description: string;
+  type: NodeType;
+};
+type NodeExecutionResult<TOutput> = {
+  type: "complete";
+  data: TOutput;
+} | {
+  type: "waiting";
+  partialData?: unknown;
+};
+declare const completeNodeExecution: <TOutput>(data: TOutput) => {
+  type: "complete";
+  data: TOutput;
+};
+declare const waitingNodeExecution: (partialData?: unknown) => {
+  type: "waiting";
+  partialData: unknown;
+};
+type FlowNode<TInput = unknown, TOutput = unknown, TError = UploadistaError$1, TRequirements = never> = FlowNodeData & {
+  inputSchema: z.ZodSchema<TInput>;
+  outputSchema: z.ZodSchema<TOutput>;
+  run: (args: {
+    data: TInput;
+    runId: string;
+    storageId: string;
+    flowId: string;
+    inputs?: Record<string, unknown>;
+  }) => Effect.Effect<NodeExecutionResult<TOutput>, TError, TRequirements>;
+  condition?: {
+    field: string;
+    operator: string;
+    value: unknown;
+  };
+  multiInput?: boolean;
+  multiOutput?: boolean;
+  pausable?: boolean;
+};
+type FlowEdge$1 = {
+  source: string;
+  target: string;
+  sourcePort?: string;
+  targetPort?: string;
+};
+type TypeCompatibilityChecker = (from: z.ZodSchema<any>, to: z.ZodSchema<any>) => boolean;
+type NodeConnectionValidator = {
+  validateConnection: (sourceNode: FlowNode<any, any>, targetNode: FlowNode<any, any>, edge: FlowEdge$1) => boolean;
+  getCompatibleTypes: (sourceSchema: z.ZodSchema<any>, targetSchema: z.ZodSchema<any>) => boolean;
+};
+type FlowConfig<TFlowInputSchema extends z.ZodSchema<any>, TFlowOutputSchema extends z.ZodSchema<any>, TRequirements> = {
+  flowId: string;
+  name: string;
+  nodes: Array<FlowNode<any, any, UploadistaError$1, TRequirements>>;
+  edges: FlowEdge$1[];
+  inputSchema: TFlowInputSchema;
+  outputSchema: TFlowOutputSchema;
+  typeChecker?: TypeCompatibilityChecker;
+  onEvent?: (event: FlowEvent) => Effect.Effect<{
+    eventId: string | null;
+  }, UploadistaError$1>;
+  parallelExecution?: {
+    enabled?: boolean;
+    maxConcurrency?: number;
+  };
+};
+type FlowExecutionContext = {
+  runId: string;
+  flowId: string;
+  nodeResults: Map<string, unknown>;
+  nodeInputs: Map<string, Record<string, unknown>>;
+};
+//#endregion
+//#region src/flow/edge.d.ts
+type FlowEdge = FlowEdge$1;
+declare function createFlowEdge({
+  source,
+  target,
+  sourcePort,
+  targetPort
+}: {
+  source: string;
+  target: string;
+  sourcePort?: string;
+  targetPort?: string;
+}): FlowEdge;
+//#endregion
+//#region src/flow/flow.d.ts
+type FlowData = {
+  id: string;
+  name: string;
+  nodes: FlowNodeData[];
+  edges: FlowEdge[];
+};
+declare const getFlowData: <TRequirements>(flow: Flow<any, any, TRequirements>) => FlowData;
+type FlowExecutionResult<TOutput> = {
+  type: "completed";
+  result: TOutput;
+} | {
+  type: "paused";
+  nodeId: string;
+  executionState: {
+    nodeResults: Record<string, unknown>;
+    executionOrder: string[];
+    currentIndex: number;
+    inputs: Record<string, unknown>;
+  };
+};
+type Flow<TFlowInputSchema extends z.ZodSchema<any>, TFlowOutputSchema extends z.ZodSchema<any>, TRequirements> = {
+  id: string;
+  name: string;
+  nodes: FlowNode<any, any, UploadistaError$1, TRequirements>[];
+  edges: FlowEdge[];
+  inputSchema: TFlowInputSchema;
+  outputSchema: TFlowOutputSchema;
+  run: (args: {
+    inputs?: Record<string, z.infer<TFlowInputSchema>>;
+    storageId: string;
+    jobId: string;
+  }) => Effect.Effect<FlowExecutionResult<z.infer<TFlowOutputSchema>>, UploadistaError$1, TRequirements>;
+  resume: (args: {
+    jobId: string;
+    storageId: string;
+    executionState: {
+      nodeResults: Record<string, unknown>;
+      executionOrder: string[];
+      currentIndex: number;
+      inputs: Record<string, z.infer<TFlowInputSchema>>;
+    };
+  }) => Effect.Effect<FlowExecutionResult<z.infer<TFlowOutputSchema>>, UploadistaError$1, TRequirements>;
+  validateTypes: () => {
+    isValid: boolean;
+    errors: string[];
+  };
+  validateInputs: (inputs: unknown) => {
+    isValid: boolean;
+    errors: string[];
+  };
+  validateOutputs: (outputs: unknown) => {
+    isValid: boolean;
+    errors: string[];
+  };
+};
+declare function createFlow<TFlowInputSchema extends z.ZodSchema<any>, TFlowOutputSchema extends z.ZodSchema<any>, TRequirements>({
+  flowId,
+  name,
+  onEvent,
+  edges,
+  nodes,
+  inputSchema,
+  outputSchema,
+  typeChecker
+}: FlowConfig<TFlowInputSchema, TFlowOutputSchema, TRequirements>): Flow<TFlowInputSchema, TFlowOutputSchema, TRequirements>;
+//#endregion
+//#region src/types/upload-file.d.ts
+declare const uploadFileSchema: z.ZodObject<{
+  id: z.ZodString;
+  size: z.ZodOptional<z.ZodNumber>;
+  offset: z.ZodNumber;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  creationDate: z.ZodOptional<z.ZodString>;
+  url: z.ZodOptional<z.ZodString>;
+  sizeIsDeferred: z.ZodOptional<z.ZodBoolean>;
+  storage: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    uploadId: z.ZodOptional<z.ZodString>;
+    bucket: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type UploadFile = {
+  id: string;
+  offset: number;
+  storage: {
+    id: string;
+    isBuffer?: boolean;
+    type: string;
+    path?: string | undefined;
+    uploadId?: string | undefined;
+    bucket?: string | undefined;
+  };
+  size?: number | undefined;
+  metadata?: Record<string, string> | undefined;
+  creationDate?: string | undefined;
+  url?: string | undefined;
+  sizeIsDeferred?: boolean | undefined;
+};
+//#endregion
+//#region src/types/data-store.d.ts
+type DataStoreWriteOptions = {
+  file_id: string;
+  stream: Stream.Stream<Uint8Array, UploadistaError$1>;
+  offset: number;
+};
+type UploadStrategy = "single" | "parallel";
+type DataStoreCapabilities = {
+  supportsParallelUploads: boolean;
+  supportsConcatenation: boolean;
+  supportsDeferredLength: boolean;
+  supportsResumableUploads: boolean;
+  supportsTransactionalUploads: boolean;
+  maxConcurrentUploads?: number;
+  minChunkSize?: number;
+  maxChunkSize?: number;
+  maxParts?: number;
+  optimalChunkSize?: number;
+  requiresOrderedChunks: boolean;
+};
+type DataStore<TData = unknown> = {
+  readonly bucket?: string;
+  readonly path?: string;
+  readonly create: (file: TData) => Effect.Effect<TData, UploadistaError$1>;
+  readonly remove: (file_id: string) => Effect.Effect<void, UploadistaError$1>;
+  readonly read: (file_id: string) => Effect.Effect<Uint8Array, UploadistaError$1>;
+  readonly write: (options: DataStoreWriteOptions, dependencies: {
+    onProgress?: (chunkSize: number) => void;
+  }) => Effect.Effect<number, UploadistaError$1>;
+  readonly deleteExpired?: Effect.Effect<number, UploadistaError$1>;
+  readonly getCapabilities: () => DataStoreCapabilities;
+  readonly validateUploadStrategy: (strategy: UploadStrategy) => Effect.Effect<boolean, never>;
+};
+declare const UploadFileDataStore_base: Context.TagClass<UploadFileDataStore, "UploadFileDataStore", DataStore<UploadFile>>;
+declare class UploadFileDataStore extends UploadFileDataStore_base {}
+declare const BufferedUploadFileDataStore_base: Context.TagClass<BufferedUploadFileDataStore, "BufferedUploadFileDataStore", DataStore<UploadFile>>;
+declare class BufferedUploadFileDataStore extends BufferedUploadFileDataStore_base {}
+type UploadFileDataStoresShape = {
+  getDataStore: (storageId: string, isBuffer?: boolean) => Effect.Effect<DataStore<UploadFile>, UploadistaError$1>;
+};
+declare const UploadFileDataStores_base: Context.TagClass<UploadFileDataStores, "UploadFileDataStores", UploadFileDataStoresShape>;
+declare class UploadFileDataStores extends UploadFileDataStores_base {}
+//#endregion
+//#region src/types/data-store-registry.d.ts
+declare const DataStoreRegistry_base: Context.TagClass<DataStoreRegistry, "DataStoreRegistry", {
+  readonly register: <T extends DataStore<UploadFile>>(id: string, store: Effect.Effect<T, UploadistaError$1>) => Effect.Effect<void, never>;
+  readonly get: (id: string) => Effect.Effect<DataStore<UploadFile>, UploadistaError$1>;
+  readonly list: () => Effect.Effect<Array<string>, never>;
+}>;
+declare class DataStoreRegistry extends DataStoreRegistry_base {}
+//#endregion
+//#region src/types/upload-event.d.ts
+declare enum UploadEventType {
+  UPLOAD_STARTED = "upload-started",
+  UPLOAD_PROGRESS = "upload-progress",
+  UPLOAD_COMPLETE = "upload-complete",
+  UPLOAD_FAILED = "upload-failed",
+}
+declare const uploadEventSchema: z.ZodUnion<readonly [z.ZodObject<{
+  type: z.ZodUnion<readonly [z.ZodLiteral<UploadEventType.UPLOAD_STARTED>, z.ZodLiteral<UploadEventType.UPLOAD_COMPLETE>]>;
+  data: z.ZodObject<{
+    id: z.ZodString;
+    size: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodNumber;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    creationDate: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    sizeIsDeferred: z.ZodOptional<z.ZodBoolean>;
+    storage: z.ZodObject<{
+      id: z.ZodString;
+      type: z.ZodString;
+      path: z.ZodOptional<z.ZodString>;
+      uploadId: z.ZodOptional<z.ZodString>;
+      bucket: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<UploadEventType.UPLOAD_PROGRESS>;
+  data: z.ZodObject<{
+    id: z.ZodString;
+    progress: z.ZodNumber;
+    total: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<UploadEventType.UPLOAD_FAILED>;
+  data: z.ZodObject<{
+    id: z.ZodString;
+    error: z.ZodString;
+  }, z.core.$strip>;
+}, z.core.$strip>]>;
+type UploadEvent = z.infer<typeof uploadEventSchema>;
+//#endregion
+//#region src/types/websocket.d.ts
+/**
+ * Platform-agnostic WebSocket connection interface
+ */
+interface WebSocketConnection {
+  send(data: string): void;
+  close(code?: number, reason?: string): void;
+  readonly readyState: number;
+  readonly id: string;
+}
+/**
+ * WebSocket message that can be sent/received
+ */
+declare const webSocketMessageSchema: z$1.ZodUnion<readonly [z$1.ZodObject<{
+  type: z$1.ZodLiteral<"upload_event">;
+  payload: z$1.ZodUnion<readonly [z$1.ZodObject<{
+    type: z$1.ZodUnion<readonly [z$1.ZodLiteral<UploadEventType.UPLOAD_STARTED>, z$1.ZodLiteral<UploadEventType.UPLOAD_COMPLETE>]>;
+    data: z$1.ZodObject<{
+      id: z$1.ZodString;
+      size: z$1.ZodOptional<z$1.ZodNumber>;
+      offset: z$1.ZodNumber;
+      metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodString>>;
+      creationDate: z$1.ZodOptional<z$1.ZodString>;
+      url: z$1.ZodOptional<z$1.ZodString>;
+      sizeIsDeferred: z$1.ZodOptional<z$1.ZodBoolean>;
+      storage: z$1.ZodObject<{
+        id: z$1.ZodString;
+        type: z$1.ZodString;
+        path: z$1.ZodOptional<z$1.ZodString>;
+        uploadId: z$1.ZodOptional<z$1.ZodString>;
+        bucket: z$1.ZodOptional<z$1.ZodString>;
+      }, z$1.core.$strip>;
+    }, z$1.core.$strip>;
+  }, z$1.core.$strip>, z$1.ZodObject<{
+    type: z$1.ZodLiteral<UploadEventType.UPLOAD_PROGRESS>;
+    data: z$1.ZodObject<{
+      id: z$1.ZodString;
+      progress: z$1.ZodNumber;
+      total: z$1.ZodNumber;
+    }, z$1.core.$strip>;
+  }, z$1.core.$strip>, z$1.ZodObject<{
+    type: z$1.ZodLiteral<UploadEventType.UPLOAD_FAILED>;
+    data: z$1.ZodObject<{
+      id: z$1.ZodString;
+      error: z$1.ZodString;
+    }, z$1.core.$strip>;
+  }, z$1.core.$strip>]>;
+  timestamp: z$1.ZodOptional<z$1.ZodString>;
+}, z$1.core.$strip>, z$1.ZodObject<{
+  type: z$1.ZodLiteral<"flow_event">;
+  payload: z$1.ZodAny;
+  timestamp: z$1.ZodOptional<z$1.ZodString>;
+}, z$1.core.$strip>, z$1.ZodObject<{
+  type: z$1.ZodLiteral<"subscribed">;
+  payload: z$1.ZodObject<{
+    uploadId: z$1.ZodString;
+  }, z$1.core.$strip>;
+  timestamp: z$1.ZodOptional<z$1.ZodString>;
+}, z$1.core.$strip>, z$1.ZodObject<{
+  type: z$1.ZodLiteral<"error">;
+  message: z$1.ZodOptional<z$1.ZodString>;
+}, z$1.core.$strip>, z$1.ZodObject<{
+  type: z$1.ZodLiteral<"pong">;
+  timestamp: z$1.ZodOptional<z$1.ZodString>;
+}, z$1.core.$strip>, z$1.ZodObject<{
+  type: z$1.ZodLiteral<"ping">;
+  timestamp: z$1.ZodOptional<z$1.ZodString>;
+}, z$1.core.$strip>, z$1.ZodObject<{
+  type: z$1.ZodLiteral<"connection">;
+  message: z$1.ZodOptional<z$1.ZodString>;
+  uploadId: z$1.ZodOptional<z$1.ZodString>;
+  timestamp: z$1.ZodOptional<z$1.ZodString>;
+}, z$1.core.$strip>]>;
+type WebSocketMessage<TEvent = unknown> = z$1.infer<typeof webSocketMessageSchema> | {
+  type: "upload_event";
+  payload: TEvent;
+  timestamp?: string;
+} | {
+  type: "flow_event";
+  payload: TEvent;
+  timestamp?: string;
+};
+//#endregion
+//#region src/types/event-emitter.d.ts
+interface BaseEventEmitter {
+  readonly subscribe: (key: string, connection: WebSocketConnection) => Effect.Effect<void, UploadistaError$1>;
+  readonly unsubscribe: (key: string) => Effect.Effect<void, UploadistaError$1>;
+  readonly emit: (key: string, event: string) => Effect.Effect<void, UploadistaError$1>;
+}
+type EventEmitter<TEvent> = {
+  readonly subscribe: (key: string, connection: WebSocketConnection) => Effect.Effect<void, UploadistaError$1>;
+  readonly unsubscribe: (key: string) => Effect.Effect<void, UploadistaError$1>;
+  readonly emit: (key: string, event: TEvent) => Effect.Effect<void, UploadistaError$1>;
+};
+declare class TypedEventEmitter<TEvent> implements EventEmitter<TEvent> {
+  private baseEmitter;
+  private eventToMessage;
+  constructor(baseEmitter: BaseEventEmitter, eventToMessage: (event: TEvent) => string);
+  subscribe: (key: string, connection: WebSocketConnection) => Effect.Effect<void, UploadistaError$1>;
+  unsubscribe: (key: string) => Effect.Effect<void, UploadistaError$1>;
+  emit: (key: string, event: TEvent) => Effect.Effect<void, UploadistaError$1>;
+}
+declare const eventToMessageSerializer: (messageType: "upload_event" | "flow_event") => {
+  eventToMessage: <T>(event: T) => string;
+};
+declare const BaseEventEmitterService_base: Context.TagClass<BaseEventEmitterService, "BaseEventEmitter", BaseEventEmitter>;
+declare class BaseEventEmitterService extends BaseEventEmitterService_base {}
+declare const UploadEventEmitter_base: Context.TagClass<UploadEventEmitter, "UploadEventEmitter", EventEmitter<{
+  type: UploadEventType.UPLOAD_STARTED | UploadEventType.UPLOAD_COMPLETE;
+  data: {
+    id: string;
+    offset: number;
+    storage: {
+      id: string;
+      type: string;
+      path?: string | undefined;
+      uploadId?: string | undefined;
+      bucket?: string | undefined;
+    };
+    size?: number | undefined;
+    metadata?: Record<string, string> | undefined;
+    creationDate?: string | undefined;
+    url?: string | undefined;
+    sizeIsDeferred?: boolean | undefined;
+  };
+} | {
+  type: UploadEventType.UPLOAD_PROGRESS;
+  data: {
+    id: string;
+    progress: number;
+    total: number;
+  };
+} | {
+  type: UploadEventType.UPLOAD_FAILED;
+  data: {
+    id: string;
+    error: string;
+  };
+}>>;
+declare class UploadEventEmitter extends UploadEventEmitter_base {}
+declare const uploadEventEmitter: Layer.Layer<UploadEventEmitter, never, BaseEventEmitterService>;
+declare const FlowEventEmitter_base: Context.TagClass<FlowEventEmitter, "FlowEventEmitter", EventEmitter<FlowEvent>>;
+declare class FlowEventEmitter extends FlowEventEmitter_base {}
+declare const flowEventEmitter: Layer.Layer<FlowEventEmitter, never, BaseEventEmitterService>;
+//#endregion
+//#region src/types/input-file.d.ts
+declare const inputFileSchema: z.ZodObject<{
+  uploadLengthDeferred: z.ZodOptional<z.ZodBoolean>;
+  storageId: z.ZodString;
+  size: z.ZodNumber;
+  type: z.ZodString;
+  fileName: z.ZodOptional<z.ZodString>;
+  lastModified: z.ZodOptional<z.ZodNumber>;
+  metadata: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type InputFile = z.infer<typeof inputFileSchema>;
+//#endregion
+//#region src/types/kv-store.d.ts
+interface BaseKvStore {
+  readonly get: (key: string) => Effect.Effect<string | null, UploadistaError$1>;
+  readonly set: (key: string, value: string) => Effect.Effect<void, UploadistaError$1>;
+  readonly delete: (key: string) => Effect.Effect<void, UploadistaError$1>;
+  readonly list?: () => Effect.Effect<Array<string>, UploadistaError$1>;
+}
+type KvStore<TData> = {
+  readonly get: (key: string) => Effect.Effect<TData, UploadistaError$1>;
+  readonly set: (key: string, value: TData) => Effect.Effect<void, UploadistaError$1>;
+  readonly delete: (key: string) => Effect.Effect<void, UploadistaError$1>;
+  readonly list?: () => Effect.Effect<Array<string>, UploadistaError$1>;
+};
+declare class TypedKvStore<TData> implements KvStore<TData> {
+  private baseStore;
+  private serialize;
+  private deserialize;
+  constructor(baseStore: BaseKvStore, serialize: (data: TData) => string, deserialize: (str: string) => TData);
+  get: (key: string) => Effect.Effect<TData, UploadistaError$1>;
+  set: (key: string, value: TData) => Effect.Effect<void, UploadistaError$1>;
+  delete: (key: string) => Effect.Effect<void, UploadistaError$1>;
+  list: () => Effect.Effect<Array<string>, UploadistaError$1>;
+}
+declare const jsonSerializer: {
+  serialize: <T>(data: T) => string;
+  deserialize: <T>(str: string) => T;
+};
+declare const BaseKvStoreService_base: Context.TagClass<BaseKvStoreService, "BaseKvStore", BaseKvStore>;
+declare class BaseKvStoreService extends BaseKvStoreService_base {}
+declare const UploadFileKVStore_base: Context.TagClass<UploadFileKVStore, "UploadFileKVStore", KvStore<UploadFile>>;
+declare class UploadFileKVStore extends UploadFileKVStore_base {}
+declare const uploadFileKvStore: Layer.Layer<UploadFileKVStore, never, BaseKvStoreService>;
+declare const FlowJobKVStore_base: Context.TagClass<FlowJobKVStore, "FlowJobKVStore", KvStore<FlowJob>>;
+declare class FlowJobKVStore extends FlowJobKVStore_base {}
+declare const flowJobKvStore: Layer.Layer<FlowJobKVStore, never, BaseKvStoreService>;
+//#endregion
+//#region src/types/middleware.d.ts
+type MiddlewareContext = {
+  request: Request;
+  uploadId?: string;
+  metadata?: Record<string, string>;
+};
+type MiddlewareNext = () => Promise<Response>;
+type Middleware = (context: MiddlewareContext, next: MiddlewareNext) => Promise<Response>;
+declare const MiddlewareService_base: Context.TagClass<MiddlewareService, "MiddlewareService", {
+  readonly execute: (middlewares: Middleware[], context: MiddlewareContext, handler: MiddlewareNext) => Effect.Effect<Response, UploadistaError$1>;
+}>;
+declare class MiddlewareService extends MiddlewareService_base {}
+declare const MiddlewareServiceLive: Layer.Layer<MiddlewareService, never, never>;
+//#endregion
+//#region src/flow/types/flow-job.d.ts
+type FlowJobTaskStatus = "started" | "pending" | "running" | "completed" | "failed";
+type FlowJobTask = {
+  nodeId: string;
+  status: FlowJobTaskStatus;
+  createdAt: Date;
+  updatedAt: Date;
+};
+type FlowJob = {
+  id: string;
+  flowId: string;
+  storageId: string;
+  status: FlowJobStatus;
+  createdAt: Date;
+  updatedAt: Date;
+  tasks: FlowJobTask[];
+  error?: string;
+  endedAt?: Date;
+  pausedAt?: string;
+  executionState?: {
+    nodeResults: Record<string, unknown>;
+    executionOrder: string[];
+    currentIndex: number;
+    inputs: Record<string, unknown>;
+  };
+};
+type FlowJobStatus = "pending" | "running" | "completed" | "failed" | "started" | "paused";
+//#endregion
+//#region src/flow/flow-server.d.ts
+type FlowProviderShape<TRequirements = any> = {
+  getFlow: (flowId: string) => Effect.Effect<Flow<any, any, TRequirements>, UploadistaError$1>;
+};
+declare const FlowProvider_base: Context.TagClass<FlowProvider, "FlowProvider", FlowProviderShape<any>>;
+declare class FlowProvider extends FlowProvider_base {}
+type FlowServerShape = {
+  getFlow: <TRequirements>(flowId: string) => Effect.Effect<Flow<any, any, TRequirements>, UploadistaError$1>;
+  getFlowData: (flowId: string) => Effect.Effect<FlowData, UploadistaError$1>;
+  runFlow: <TRequirements>(flowId: string, storageId: string, inputs: any) => Effect.Effect<FlowJob, UploadistaError$1, TRequirements>;
+  continueFlow: <TRequirements>(jobId: string, nodeId: string, newData: unknown) => Effect.Effect<FlowJob, UploadistaError$1, TRequirements>;
+  getJobStatus: (jobId: string) => Effect.Effect<FlowJob, UploadistaError$1>;
+  subscribeToFlowEvents: (jobId: string, connection: WebSocketConnection) => Effect.Effect<void, UploadistaError$1>;
+  unsubscribeFromFlowEvents: (jobId: string) => Effect.Effect<void, UploadistaError$1>;
+};
+declare const FlowServer_base: Context.TagClass<FlowServer, "FlowServer", FlowServerShape>;
+declare class FlowServer extends FlowServer_base {}
+type FlowServerOptions = {
+  getFlow: <TRequirements>({
+    flowId,
+    storageId
+  }: {
+    flowId: string;
+    storageId: string;
+  }) => Promise<Flow<any, any, TRequirements>>;
+  kvStore: KvStore<FlowJob>;
+};
+declare function createFlowServer(): Effect.Effect<{
+  getFlow: <TRequirements>(flowId: string) => Effect.Effect<Flow<any, any, any>, UploadistaError$1, never>;
+  getFlowData: (flowId: string) => Effect.Effect<FlowData, UploadistaError$1, never>;
+  runFlow: (flowId: string, storageId: string, inputs: unknown) => Effect.Effect<FlowJob, UploadistaError$1, any>;
+  getJobStatus: (jobId: string) => Effect.Effect<FlowJob, UploadistaError$1, never>;
+  continueFlow: (jobId: string, nodeId: string, newData: unknown) => Effect.Effect<FlowJob, UploadistaError$1, any>;
+  subscribeToFlowEvents: (jobId: string, connection: WebSocketConnection) => Effect.Effect<void, UploadistaError$1, never>;
+  unsubscribeFromFlowEvents: (jobId: string) => Effect.Effect<void, UploadistaError$1, never>;
+}, never, FlowProvider | FlowJobKVStore | FlowEventEmitter>;
+declare const flowServer: Layer.Layer<FlowServer, never, FlowProvider | FlowJobKVStore | FlowEventEmitter>;
+type FlowServerLayer = typeof flowServer;
+//#endregion
+//#region src/flow/nodes/input-node.d.ts
+declare function createInputNode(id: string, prepareFile?: (fileId: string) => Effect.Effect<string>): Effect.Effect<FlowNode<{
+  fileId: string;
+}, {
+  path: string;
+  inputBytes: Uint8Array<ArrayBufferLike>;
+  metadata: {
+    mimeType: string;
+    size: number;
+    width?: number | undefined;
+    height?: number | undefined;
+    format?: string | undefined;
+    originalName?: string | undefined;
+    extension?: string | undefined;
+  };
+}, UploadistaError$1, never>, UploadistaError$1, never>;
+//#endregion
+//#region src/upload/mime.d.ts
+declare const detectMimeType: (buffer: Uint8Array, filename?: string) => string;
+//#endregion
+//#region src/upload/upload-server.d.ts
+type UploadServerOptions = {
+  dataStore: ((storageId: string) => Promise<DataStore<UploadFile>>) | DataStore<UploadFile>;
+  kvStore: KvStore<UploadFile>;
+  eventEmitter: EventEmitter<UploadEvent>;
+  generateId?: GenerateIdShape;
+  middlewares?: Middleware[];
+  withTracing?: boolean;
+};
+type UploadServerShape = {
+  createUpload: (inputFile: InputFile, isBuffer?: boolean) => Effect.Effect<UploadFile, UploadistaError$1>;
+  uploadChunk: (uploadId: string, chunk: ReadableStream, isBuffer?: boolean) => Effect.Effect<UploadFile, UploadistaError$1>;
+  getCapabilities: (storageId: string) => Effect.Effect<DataStoreCapabilities, UploadistaError$1>;
+  upload: (file: InputFile, stream: ReadableStream) => Effect.Effect<UploadFile, UploadistaError$1>;
+  getUpload: (uploadId: string) => Effect.Effect<UploadFile, UploadistaError$1>;
+  read: (uploadId: string) => Effect.Effect<Uint8Array, UploadistaError$1>;
+  subscribeToUploadEvents: (uploadId: string, connection: WebSocketConnection) => Effect.Effect<void, UploadistaError$1>;
+  unsubscribeFromUploadEvents: (uploadId: string) => Effect.Effect<void, UploadistaError$1>;
+};
+declare const UploadServer_base: Context.TagClass<UploadServer, "UploadServer", UploadServerShape>;
+declare class UploadServer extends UploadServer_base {}
+declare function createUploadServer(): Effect.Effect<{
+  upload: (inputFile: InputFile, stream: ReadableStream) => Effect.Effect<UploadFile, UploadistaError$1, never>;
+  createUpload: (inputFile: InputFile) => Effect.Effect<UploadFile, UploadistaError$1, never>;
+  uploadChunk: (uploadId: string, chunk: ReadableStream) => Effect.Effect<UploadFile, UploadistaError$1, never>;
+  getUpload: (uploadId: string) => Effect.Effect<UploadFile, UploadistaError$1, never>;
+  read: (uploadId: string) => Effect.Effect<Uint8Array<ArrayBufferLike>, UploadistaError$1, never>;
+  getCapabilities: (storageId: string) => 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, GenerateId | UploadFileDataStores | UploadFileKVStore | UploadEventEmitter>;
+declare const uploadServer: Layer.Layer<UploadServer, never, GenerateId | UploadFileDataStores | UploadFileKVStore | UploadEventEmitter>;
+//#endregion
+//#region src/upload/upload-strategy-negotiator.d.ts
+type UploadStrategyOptions = {
+  fileSize: number;
+  preferredStrategy?: UploadStrategy;
+  preferredChunkSize?: number;
+  parallelUploads?: number;
+  minChunkSizeForParallel?: number;
+};
+type NegotiatedStrategy = {
+  strategy: UploadStrategy;
+  chunkSize: number;
+  parallelUploads: number;
+  reasoning: string[];
+  warnings: string[];
+};
+declare class UploadStrategyNegotiator {
+  private capabilities;
+  private validateUploadStrategy;
+  constructor(capabilities: DataStoreCapabilities, validateUploadStrategy: (strategy: UploadStrategy) => boolean);
+  negotiateStrategy(options: UploadStrategyOptions): NegotiatedStrategy;
+  getDataStoreCapabilities(): DataStoreCapabilities;
+  validateConfiguration(options: UploadStrategyOptions): {
+    valid: boolean;
+    errors: string[];
+  };
+}
+//#endregion
+//#region src/flow/nodes/storage-node.d.ts
+declare const storageParamsSchema: z.ZodObject<{}, z.core.$strip>;
+type StorageParams = z.infer<typeof storageParamsSchema>;
+declare function createStorageNode(id: string): Effect.Effect<FlowNode<{
+  id: string;
+  offset: number;
+  storage: {
+    id: string;
+    type: string;
+    path?: string | undefined;
+    uploadId?: string | undefined;
+    bucket?: string | undefined;
+  };
+  size?: number | undefined;
+  metadata?: Record<string, string> | undefined;
+  creationDate?: string | undefined;
+  url?: string | undefined;
+  sizeIsDeferred?: boolean | undefined;
+}, {
+  id: string;
+  offset: number;
+  storage: {
+    id: string;
+    type: string;
+    path?: string | undefined;
+    uploadId?: string | undefined;
+    bucket?: string | undefined;
+  };
+  size?: number | undefined;
+  metadata?: Record<string, string> | undefined;
+  creationDate?: string | undefined;
+  url?: string | undefined;
+  sizeIsDeferred?: boolean | undefined;
+}, UploadistaError$1, never>, UploadistaError$1, UploadServer>;
+//#endregion
+//#region src/flow/nodes/streaming-input-node.d.ts
+declare function createStreamingInputNode(id: string): Effect.Effect<FlowNode<{
+  operation: "init";
+  storageId: string;
+  metadata?: {
+    originalName?: string | undefined;
+    mimeType?: string | undefined;
+    size?: number | undefined;
+    extension?: string | undefined;
+  } | undefined;
+} | {
+  operation: "finalize";
+  uploadId: string;
+}, {
+  id: string;
+  offset: number;
+  storage: {
+    id: string;
+    type: string;
+    path?: string | undefined;
+    uploadId?: string | undefined;
+    bucket?: string | undefined;
+  };
+  size?: number | undefined;
+  metadata?: Record<string, string> | undefined;
+  creationDate?: string | undefined;
+  url?: string | undefined;
+  sizeIsDeferred?: boolean | undefined;
+}, UploadistaError$1, never>, UploadistaError$1, UploadServer>;
+//#endregion
+//#region src/flow/parallel-scheduler.d.ts
+interface ExecutionLevel {
+  level: number;
+  nodes: string[];
+}
+interface ParallelSchedulerConfig {
+  maxConcurrency?: number;
+  resourceSemaphore?: Semaphore;
+}
+declare class ParallelScheduler {
+  private maxConcurrency;
+  private resourceSemaphore;
+  constructor(config?: ParallelSchedulerConfig);
+  /**
+   * Groups nodes into execution levels where nodes in the same level can run in parallel
+   * @param nodes Array of flow nodes
+   * @param edges Array of flow edges
+   * @returns Array of execution levels
+   */
+  groupNodesByExecutionLevel(nodes: FlowNode<unknown, unknown>[], edges: Array<{
+    source: string;
+    target: string;
+  }>): ExecutionLevel[];
+  /**
+   * Executes a batch of nodes in parallel with resource management
+   * @param nodeExecutors Array of async functions that execute individual nodes
+   * @returns Promise that resolves when all nodes complete
+   */
+  executeNodesInParallel<T>(nodeExecutors: Array<() => Promise<T>>): Promise<T[]>;
+  /**
+   * Determines if nodes can be safely executed in parallel
+   * @param nodes Nodes to check
+   * @param nodeResults Current execution results
+   * @returns true if all nodes have their dependencies satisfied
+   */
+  canExecuteInParallel(nodeIds: string[], nodeResults: Map<string, unknown>, reverseGraph: Record<string, string[]>): boolean;
+  /**
+   * Gets execution statistics for monitoring
+   */
+  getStats(): {
+    maxConcurrency: number;
+  };
+}
+//#endregion
+//#region src/flow/plugins/types/optimize-node.d.ts
+declare const optimizeParamsSchema: z.ZodObject<{
+  quality: z.ZodNumber;
+  format: z.ZodEnum<{
+    jpeg: "jpeg";
+  }>;
+}, z.core.$strip>;
+type OptimizeParams = z.infer<typeof optimizeParamsSchema>;
+//#endregion
+//#region src/flow/plugins/types/resize-node.d.ts
+declare const resizeParamsSchema: z.ZodObject<{
+  width: z.ZodOptional<z.ZodNumber>;
+  height: z.ZodOptional<z.ZodNumber>;
+  fit: z.ZodEnum<{
+    fill: "fill";
+    contain: "contain";
+    cover: "cover";
+  }>;
+}, z.core.$strip>;
+type ResizeParams = z.infer<typeof resizeParamsSchema>;
+//#endregion
+//#region src/flow/plugins/image-plugin.d.ts
+type ImagePluginShape = {
+  optimize: (input: Uint8Array, options: OptimizeParams) => Effect.Effect<Uint8Array, UploadistaError>;
+  resize: (input: Uint8Array, options: ResizeParams) => Effect.Effect<Uint8Array, UploadistaError>;
+};
+declare const ImagePlugin_base: Context.TagClass<ImagePlugin, "ImagePlugin", ImagePluginShape>;
+declare class ImagePlugin extends ImagePlugin_base {}
+//#endregion
+//#region src/flow/types/flow-file.d.ts
+type FlowFile = {
+  path: string;
+  inputBytes: Uint8Array<ArrayBufferLike>;
+  metadata: {
+    size: number;
+    mimeType: string;
+    width?: number;
+    height?: number;
+    format?: string;
+    originalName?: string;
+    extension?: string;
+  };
+};
+declare const flowFileSchema: z.ZodObject<{
+  path: z.ZodString;
+  inputBytes: z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
+  metadata: z.ZodObject<{
+    mimeType: z.ZodString;
+    size: z.ZodNumber;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    format: z.ZodOptional<z.ZodString>;
+    originalName: z.ZodOptional<z.ZodString>;
+    extension: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type FlowFileBatch = {
+  files: FlowFile[];
+  metadata?: {
+    batchId: string;
+    totalSize: number;
+    fileCount: number;
+  };
+};
+declare const flowFileBatchSchema: z.ZodObject<{
+  files: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    inputBytes: z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
+    metadata: z.ZodObject<{
+      mimeType: z.ZodString;
+      size: z.ZodNumber;
+      width: z.ZodOptional<z.ZodNumber>;
+      height: z.ZodOptional<z.ZodNumber>;
+      format: z.ZodOptional<z.ZodString>;
+      originalName: z.ZodOptional<z.ZodString>;
+      extension: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>;
+  metadata: z.ZodOptional<z.ZodObject<{
+    batchId: z.ZodString;
+    totalSize: z.ZodNumber;
+    fileCount: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type FlowFileData = FlowFile | FlowFileBatch;
+declare function isFlowFile(data: FlowFileData): data is FlowFile;
+declare const flowDataSchema: z.ZodUnion<readonly [z.ZodObject<{
+  path: z.ZodString;
+  inputBytes: z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
+  metadata: z.ZodObject<{
+    mimeType: z.ZodString;
+    size: z.ZodNumber;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    format: z.ZodOptional<z.ZodString>;
+    originalName: z.ZodOptional<z.ZodString>;
+    extension: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  files: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    inputBytes: z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
+    metadata: z.ZodObject<{
+      mimeType: z.ZodString;
+      size: z.ZodNumber;
+      width: z.ZodOptional<z.ZodNumber>;
+      height: z.ZodOptional<z.ZodNumber>;
+      format: z.ZodOptional<z.ZodString>;
+      originalName: z.ZodOptional<z.ZodString>;
+      extension: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>;
+  metadata: z.ZodOptional<z.ZodObject<{
+    batchId: z.ZodString;
+    totalSize: z.ZodNumber;
+    fileCount: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>]>;
+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
+declare const runArgsSchema: z.ZodObject<{
+  inputs: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, z.core.$strip>;
+type RunArgs = z.infer<typeof runArgsSchema>;
+//#endregion
+export { BaseEventEmitter, BaseEventEmitterService, BaseKvStore, BaseKvStoreService, BufferedUploadFileDataStore, ConditionField, ConditionOperator, ConditionValue, DataStore, DataStoreCapabilities, DataStoreRegistry, DataStoreWriteOptions, EventEmitter, EventType, ExecutionLevel, type Flow, FlowCondition, FlowConfig, type FlowData, type FlowEdge, type FlowEvent, FlowEventEmitter, type FlowEventFlowEnd, type FlowEventFlowStart, FlowEventJobEnd, FlowEventJobStart, FlowEventNodeEnd, FlowEventNodeError, FlowEventNodeResponse, FlowEventNodeStart, FlowExecutionContext, FlowExecutionResult, FlowFile, FlowFileBatch, FlowFileData, FlowJob, FlowJobKVStore, FlowJobStatus, FlowJobTask, FlowJobTaskStatus, FlowNode, FlowNodeData, FlowProvider, FlowProviderShape, FlowServer, FlowServerLayer, FlowServerOptions, FlowServerShape, ImagePlugin, ImagePluginShape, InputFile, KvStore, Middleware, MiddlewareContext, MiddlewareNext, MiddlewareService, MiddlewareServiceLive, NegotiatedStrategy, NodeConnectionValidator, NodeExecutionResult, NodeType, NodeTypeMap, OptimizeParams, ParallelScheduler, ParallelSchedulerConfig, ResizeParams, RunArgs, StorageParams, TypeCompatibilityChecker, TypedEventEmitter, TypedKvStore, UploadEvent, UploadEventEmitter, UploadEventType, UploadFile, UploadFileDataStore, UploadFileDataStores, UploadFileDataStoresShape, UploadFileKVStore, UploadServer, UploadServerOptions, UploadServerShape, UploadStrategy, UploadStrategyNegotiator, UploadStrategyOptions, WebSocketConnection, WebSocketMessage, completeNodeExecution, createFlow, createFlowEdge, createFlowNode, createFlowServer, createInputNode, createStorageNode, createStreamingInputNode, createUploadServer, detectMimeType, eventToMessageSerializer, flowDataSchema, flowEventEmitter, flowFileBatchSchema, flowFileSchema, flowJobKvStore, flowServer, getFlowData, getNodeData, inputFileSchema, isFlowFile, jsonSerializer, optimizeParamsSchema, resizeParamsSchema, runArgsSchema, storageParamsSchema, uploadEventEmitter, uploadEventSchema, uploadFileKvStore, uploadFileSchema, uploadServer, waitingNodeExecution, webSocketMessageSchema };
+//# sourceMappingURL=index-D-CoVpkZ.d.ts.map