@uploadista/core 0.0.2

package/dist/types/event-emitter.d.ts

@@ -0,0 +1,378 @@
+import { Context, Effect, Layer } from "effect";
+import type { UploadistaError } from "../errors";
+import type { FlowEvent } from "../flow/event";
+import type { WebSocketConnection } from "./websocket";
+/**
+ * Base event emitter interface for raw string message broadcasting.
+ *
+ * This is the low-level interface that event broadcasting implementations
+ * (WebSocket, Server-Sent Events, etc.) implement. It emits raw string messages
+ * without type safety or serialization.
+ *
+ * @property subscribe - Registers a WebSocket connection to receive events for a key
+ * @property unsubscribe - Removes subscription for a key
+ * @property emit - Broadcasts a string message to all subscribers of a key
+ *
+ * @example
+ * ```typescript
+ * // Implement BaseEventEmitter with WebSocket broadcast
+ * const websocketEmitter: BaseEventEmitter = {
+ *   subscribe: (key, connection) => Effect.sync(() => {
+ *     connections.set(key, [...(connections.get(key) || []), connection]);
+ *   }),
+ *
+ *   unsubscribe: (key) => Effect.sync(() => {
+ *     connections.delete(key);
+ *   }),
+ *
+ *   emit: (key, event) => Effect.sync(() => {
+ *     const subs = connections.get(key) || [];
+ *     subs.forEach(conn => conn.send(event));
+ *   })
+ * };
+ * ```
+ */
+export interface BaseEventEmitter {
+    readonly subscribe: (key: string, connection: WebSocketConnection) => Effect.Effect<void, UploadistaError>;
+    readonly unsubscribe: (key: string) => Effect.Effect<void, UploadistaError>;
+    readonly emit: (key: string, event: string) => Effect.Effect<void, UploadistaError>;
+}
+/**
+ * Type-safe event emitter interface with automatic serialization.
+ *
+ * This wraps a BaseEventEmitter and handles event serialization to JSON messages,
+ * providing type safety for events and ensuring consistent message format.
+ *
+ * @template TEvent - The type of events emitted by this emitter
+ *
+ * @property subscribe - Registers a WebSocket connection to receive typed events
+ * @property unsubscribe - Removes subscription
+ * @property emit - Serializes and broadcasts a typed event
+ *
+ * @example
+ * ```typescript
+ * // Use a typed event emitter
+ * const uploadEmitter: EventEmitter<UploadEvent> = new TypedEventEmitter(
+ *   baseEmitter,
+ *   (event) => JSON.stringify({ type: 'upload', payload: event })
+ * );
+ *
+ * // Emit type-safe events
+ * const program = Effect.gen(function* () {
+ *   const event: UploadEvent = {
+ *     uploadId: "upload123",
+ *     type: "progress",
+ *     offset: 1024,
+ *     size: 2048
+ *   };
+ *
+ *   // Automatic serialization
+ *   yield* uploadEmitter.emit("upload123", event);
+ * });
+ * ```
+ */
+export type EventEmitter<TEvent> = {
+    readonly subscribe: (key: string, connection: WebSocketConnection) => Effect.Effect<void, UploadistaError>;
+    readonly unsubscribe: (key: string) => Effect.Effect<void, UploadistaError>;
+    readonly emit: (key: string, event: TEvent) => Effect.Effect<void, UploadistaError>;
+};
+/**
+ * Typed wrapper class that adds event serialization to a BaseEventEmitter.
+ *
+ * This class implements the EventEmitter interface by wrapping a BaseEventEmitter
+ * and handling serialization for a specific event type. It converts typed events
+ * to JSON message strings before broadcasting.
+ *
+ * @template TEvent - The type of events to emit
+ *
+ * @example
+ * ```typescript
+ * // Create a typed emitter for UploadEvent
+ * const uploadEmitter = new TypedEventEmitter<UploadEvent>(
+ *   baseEmitter,
+ *   (event) => JSON.stringify({
+ *     type: "upload_event",
+ *     payload: event,
+ *     timestamp: new Date().toISOString()
+ *   })
+ * );
+ *
+ * // Use the emitter
+ * const effect = Effect.gen(function* () {
+ *   // Subscribe a WebSocket connection
+ *   yield* uploadEmitter.subscribe("upload123", websocket);
+ *
+ *   // Emit an event (automatically serialized)
+ *   yield* uploadEmitter.emit("upload123", {
+ *     uploadId: "upload123",
+ *     type: "completed",
+ *     offset: 2048,
+ *     size: 2048
+ *   });
+ *
+ *   // Unsubscribe when done
+ *   yield* uploadEmitter.unsubscribe("upload123");
+ * });
+ *
+ * // Custom message format
+ * const customEmitter = new TypedEventEmitter<MyEvent>(
+ *   baseEmitter,
+ *   (event) => `EVENT:${event.type}:${JSON.stringify(event.data)}`
+ * );
+ * ```
+ */
+export 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>;
+    unsubscribe: (key: string) => Effect.Effect<void, UploadistaError>;
+    emit: (key: string, event: TEvent) => Effect.Effect<void, UploadistaError>;
+}
+/**
+ * Default event-to-message serialization helper.
+ *
+ * Creates a standardized JSON message format with type, payload, and timestamp.
+ * This is the recommended way to serialize events for WebSocket transmission.
+ *
+ * @param messageType - The message type identifier ("upload_event" or "flow_event")
+ * @returns An object with an eventToMessage function
+ *
+ * @example
+ * ```typescript
+ * // Create emitter with standard serialization
+ * const emitter = new TypedEventEmitter<UploadEvent>(
+ *   baseEmitter,
+ *   eventToMessageSerializer("upload_event").eventToMessage
+ * );
+ *
+ * // Messages will be formatted as:
+ * // {
+ * //   "type": "upload_event",
+ * //   "payload": { ...event data... },
+ * //   "timestamp": "2024-01-15T10:30:00.000Z"
+ * // }
+ * ```
+ */
+export declare const eventToMessageSerializer: (messageType: "upload_event" | "flow_event") => {
+    eventToMessage: <T>(event: T) => string;
+};
+declare const BaseEventEmitterService_base: Context.TagClass<BaseEventEmitterService, "BaseEventEmitter", BaseEventEmitter>;
+/**
+ * Effect-TS context tag for the base untyped event emitter.
+ *
+ * This is the low-level emitter that broadcasting implementations provide.
+ * Most application code should use typed emitters like UploadEventEmitter instead.
+ *
+ * @example
+ * ```typescript
+ * // Provide a base emitter implementation
+ * const baseEmitterLayer = Layer.succeed(BaseEventEmitterService, websocketEmitter);
+ *
+ * // Use in an Effect
+ * const effect = Effect.gen(function* () {
+ *   const baseEmitter = yield* BaseEventEmitterService;
+ *   yield* baseEmitter.emit("channel1", "raw message");
+ * });
+ * ```
+ */
+export declare class BaseEventEmitterService extends BaseEventEmitterService_base {
+}
+declare const UploadEventEmitter_base: Context.TagClass<UploadEventEmitter, "UploadEventEmitter", EventEmitter<{
+    type: import("./upload-event").UploadEventType.UPLOAD_STARTED | import("./upload-event").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 | number | boolean> | undefined;
+        creationDate?: string | undefined;
+        url?: string | undefined;
+        sizeIsDeferred?: boolean | undefined;
+        checksum?: string | undefined;
+        checksumAlgorithm?: string | undefined;
+        flow?: {
+            flowId: string;
+            nodeId: string;
+            jobId: string;
+        } | undefined;
+    };
+    flow?: {
+        flowId: string;
+        nodeId: string;
+        jobId: string;
+    } | undefined;
+} | {
+    type: import("./upload-event").UploadEventType.UPLOAD_PROGRESS;
+    data: {
+        id: string;
+        progress: number;
+        total: number;
+    };
+    flow?: {
+        flowId: string;
+        nodeId: string;
+        jobId: string;
+    } | undefined;
+} | {
+    type: import("./upload-event").UploadEventType.UPLOAD_FAILED;
+    data: {
+        id: string;
+        error: string;
+    };
+    flow?: {
+        flowId: string;
+        nodeId: string;
+        jobId: string;
+    } | undefined;
+} | {
+    type: import("./upload-event").UploadEventType.UPLOAD_VALIDATION_SUCCESS;
+    data: {
+        id: string;
+        validationType: "checksum" | "mimetype";
+        algorithm?: string | undefined;
+    };
+    flow?: {
+        flowId: string;
+        nodeId: string;
+        jobId: string;
+    } | undefined;
+} | {
+    type: import("./upload-event").UploadEventType.UPLOAD_VALIDATION_FAILED;
+    data: {
+        id: string;
+        reason: string;
+        expected: string;
+        actual: string;
+    };
+    flow?: {
+        flowId: string;
+        nodeId: string;
+        jobId: string;
+    } | undefined;
+} | {
+    type: import("./upload-event").UploadEventType.UPLOAD_VALIDATION_WARNING;
+    data: {
+        id: string;
+        message: string;
+    };
+    flow?: {
+        flowId: string;
+        nodeId: string;
+        jobId: string;
+    } | undefined;
+}>>;
+/**
+ * Effect-TS context tag for the UploadEvent typed emitter.
+ *
+ * This provides type-safe event emission for upload progress and lifecycle events.
+ * It's the primary way to broadcast upload events to connected clients.
+ *
+ * @example
+ * ```typescript
+ * const uploadEffect = Effect.gen(function* () {
+ *   const emitter = yield* UploadEventEmitter;
+ *
+ *   // Subscribe a client to upload events
+ *   yield* emitter.subscribe("upload123", websocketConnection);
+ *
+ *   // Emit progress event
+ *   yield* emitter.emit("upload123", {
+ *     uploadId: "upload123",
+ *     type: "progress",
+ *     offset: 512000,
+ *     size: 1024000
+ *   });
+ *
+ *   // Emit completion event
+ *   yield* emitter.emit("upload123", {
+ *     uploadId: "upload123",
+ *     type: "completed",
+ *     offset: 1024000,
+ *     size: 1024000
+ *   });
+ * });
+ * ```
+ */
+export declare class UploadEventEmitter extends UploadEventEmitter_base {
+}
+/**
+ * Effect Layer that creates the UploadEventEmitter from a BaseEventEmitter.
+ *
+ * This layer automatically wires up JSON serialization for UploadEvent objects
+ * with the standard "upload_event" message format.
+ *
+ * @example
+ * ```typescript
+ * const program = Effect.gen(function* () {
+ *   const emitter = yield* UploadEventEmitter;
+ *   // Use the emitter...
+ * }).pipe(
+ *   Effect.provide(uploadEventEmitter),
+ *   Effect.provide(baseEmitterLayer)
+ * );
+ * ```
+ */
+export declare const uploadEventEmitter: Layer.Layer<UploadEventEmitter, never, BaseEventEmitterService>;
+declare const FlowEventEmitter_base: Context.TagClass<FlowEventEmitter, "FlowEventEmitter", EventEmitter<FlowEvent>>;
+/**
+ * Effect-TS context tag for the FlowEvent typed emitter.
+ *
+ * This provides type-safe event emission for flow processing lifecycle events.
+ * It's used to broadcast flow execution progress, node completion, and errors.
+ *
+ * @example
+ * ```typescript
+ * const flowEffect = Effect.gen(function* () {
+ *   const emitter = yield* FlowEventEmitter;
+ *
+ *   // Subscribe a client to flow job events
+ *   yield* emitter.subscribe("job123", websocketConnection);
+ *
+ *   // Emit node start event
+ *   yield* emitter.emit("job123", {
+ *     jobId: "job123",
+ *     eventType: "NodeStart",
+ *     flowId: "flow_resize",
+ *     nodeId: "resize_1"
+ *   });
+ *
+ *   // Emit node completion event
+ *   yield* emitter.emit("job123", {
+ *     jobId: "job123",
+ *     eventType: "NodeEnd",
+ *     flowId: "flow_resize",
+ *     nodeId: "resize_1",
+ *     result: { width: 800, height: 600 }
+ *   });
+ * });
+ * ```
+ */
+export declare class FlowEventEmitter extends FlowEventEmitter_base {
+}
+/**
+ * Effect Layer that creates the FlowEventEmitter from a BaseEventEmitter.
+ *
+ * This layer automatically wires up JSON serialization for FlowEvent objects
+ * with the standard "flow_event" message format.
+ *
+ * @example
+ * ```typescript
+ * const program = Effect.gen(function* () {
+ *   const emitter = yield* FlowEventEmitter;
+ *   // Use the emitter...
+ * }).pipe(
+ *   Effect.provide(flowEventEmitter),
+ *   Effect.provide(baseEmitterLayer)
+ * );
+ * ```
+ */
+export declare const flowEventEmitter: Layer.Layer<FlowEventEmitter, never, BaseEventEmitterService>;
+export {};
+//# sourceMappingURL=event-emitter.d.ts.map

package/dist/types/event-emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-emitter.d.ts","sourceRoot":"","sources":["../../src/types/event-emitter.ts"],"names":[],"mappings":"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"}

package/dist/types/event-emitter.js

@@ -0,0 +1,223 @@
+import { Context, Effect, Layer } from "effect";
+/**
+ * Typed wrapper class that adds event serialization to a BaseEventEmitter.
+ *
+ * This class implements the EventEmitter interface by wrapping a BaseEventEmitter
+ * and handling serialization for a specific event type. It converts typed events
+ * to JSON message strings before broadcasting.
+ *
+ * @template TEvent - The type of events to emit
+ *
+ * @example
+ * ```typescript
+ * // Create a typed emitter for UploadEvent
+ * const uploadEmitter = new TypedEventEmitter<UploadEvent>(
+ *   baseEmitter,
+ *   (event) => JSON.stringify({
+ *     type: "upload_event",
+ *     payload: event,
+ *     timestamp: new Date().toISOString()
+ *   })
+ * );
+ *
+ * // Use the emitter
+ * const effect = Effect.gen(function* () {
+ *   // Subscribe a WebSocket connection
+ *   yield* uploadEmitter.subscribe("upload123", websocket);
+ *
+ *   // Emit an event (automatically serialized)
+ *   yield* uploadEmitter.emit("upload123", {
+ *     uploadId: "upload123",
+ *     type: "completed",
+ *     offset: 2048,
+ *     size: 2048
+ *   });
+ *
+ *   // Unsubscribe when done
+ *   yield* uploadEmitter.unsubscribe("upload123");
+ * });
+ *
+ * // Custom message format
+ * const customEmitter = new TypedEventEmitter<MyEvent>(
+ *   baseEmitter,
+ *   (event) => `EVENT:${event.type}:${JSON.stringify(event.data)}`
+ * );
+ * ```
+ */
+export class TypedEventEmitter {
+    baseEmitter;
+    eventToMessage;
+    constructor(baseEmitter, eventToMessage) {
+        this.baseEmitter = baseEmitter;
+        this.eventToMessage = eventToMessage;
+    }
+    subscribe = (key, connection) => this.baseEmitter.subscribe(key, connection);
+    unsubscribe = (key) => this.baseEmitter.unsubscribe(key);
+    emit = (key, event) => {
+        const message = this.eventToMessage(event);
+        return this.baseEmitter.emit(key, message);
+    };
+}
+/**
+ * Default event-to-message serialization helper.
+ *
+ * Creates a standardized JSON message format with type, payload, and timestamp.
+ * This is the recommended way to serialize events for WebSocket transmission.
+ *
+ * @param messageType - The message type identifier ("upload_event" or "flow_event")
+ * @returns An object with an eventToMessage function
+ *
+ * @example
+ * ```typescript
+ * // Create emitter with standard serialization
+ * const emitter = new TypedEventEmitter<UploadEvent>(
+ *   baseEmitter,
+ *   eventToMessageSerializer("upload_event").eventToMessage
+ * );
+ *
+ * // Messages will be formatted as:
+ * // {
+ * //   "type": "upload_event",
+ * //   "payload": { ...event data... },
+ * //   "timestamp": "2024-01-15T10:30:00.000Z"
+ * // }
+ * ```
+ */
+export const eventToMessageSerializer = (messageType) => ({
+    eventToMessage: (event) => JSON.stringify({
+        type: messageType,
+        payload: event,
+        timestamp: new Date().toISOString(),
+    }),
+});
+/**
+ * Effect-TS context tag for the base untyped event emitter.
+ *
+ * This is the low-level emitter that broadcasting implementations provide.
+ * Most application code should use typed emitters like UploadEventEmitter instead.
+ *
+ * @example
+ * ```typescript
+ * // Provide a base emitter implementation
+ * const baseEmitterLayer = Layer.succeed(BaseEventEmitterService, websocketEmitter);
+ *
+ * // Use in an Effect
+ * const effect = Effect.gen(function* () {
+ *   const baseEmitter = yield* BaseEventEmitterService;
+ *   yield* baseEmitter.emit("channel1", "raw message");
+ * });
+ * ```
+ */
+export class BaseEventEmitterService extends Context.Tag("BaseEventEmitter")() {
+}
+/**
+ * Effect-TS context tag for the UploadEvent typed emitter.
+ *
+ * This provides type-safe event emission for upload progress and lifecycle events.
+ * It's the primary way to broadcast upload events to connected clients.
+ *
+ * @example
+ * ```typescript
+ * const uploadEffect = Effect.gen(function* () {
+ *   const emitter = yield* UploadEventEmitter;
+ *
+ *   // Subscribe a client to upload events
+ *   yield* emitter.subscribe("upload123", websocketConnection);
+ *
+ *   // Emit progress event
+ *   yield* emitter.emit("upload123", {
+ *     uploadId: "upload123",
+ *     type: "progress",
+ *     offset: 512000,
+ *     size: 1024000
+ *   });
+ *
+ *   // Emit completion event
+ *   yield* emitter.emit("upload123", {
+ *     uploadId: "upload123",
+ *     type: "completed",
+ *     offset: 1024000,
+ *     size: 1024000
+ *   });
+ * });
+ * ```
+ */
+export class UploadEventEmitter extends Context.Tag("UploadEventEmitter")() {
+}
+/**
+ * Effect Layer that creates the UploadEventEmitter from a BaseEventEmitter.
+ *
+ * This layer automatically wires up JSON serialization for UploadEvent objects
+ * with the standard "upload_event" message format.
+ *
+ * @example
+ * ```typescript
+ * const program = Effect.gen(function* () {
+ *   const emitter = yield* UploadEventEmitter;
+ *   // Use the emitter...
+ * }).pipe(
+ *   Effect.provide(uploadEventEmitter),
+ *   Effect.provide(baseEmitterLayer)
+ * );
+ * ```
+ */
+export const uploadEventEmitter = Layer.effect(UploadEventEmitter, Effect.gen(function* () {
+    const baseEmitter = yield* BaseEventEmitterService;
+    return new TypedEventEmitter(baseEmitter, eventToMessageSerializer("upload_event").eventToMessage);
+}));
+/**
+ * Effect-TS context tag for the FlowEvent typed emitter.
+ *
+ * This provides type-safe event emission for flow processing lifecycle events.
+ * It's used to broadcast flow execution progress, node completion, and errors.
+ *
+ * @example
+ * ```typescript
+ * const flowEffect = Effect.gen(function* () {
+ *   const emitter = yield* FlowEventEmitter;
+ *
+ *   // Subscribe a client to flow job events
+ *   yield* emitter.subscribe("job123", websocketConnection);
+ *
+ *   // Emit node start event
+ *   yield* emitter.emit("job123", {
+ *     jobId: "job123",
+ *     eventType: "NodeStart",
+ *     flowId: "flow_resize",
+ *     nodeId: "resize_1"
+ *   });
+ *
+ *   // Emit node completion event
+ *   yield* emitter.emit("job123", {
+ *     jobId: "job123",
+ *     eventType: "NodeEnd",
+ *     flowId: "flow_resize",
+ *     nodeId: "resize_1",
+ *     result: { width: 800, height: 600 }
+ *   });
+ * });
+ * ```
+ */
+export class FlowEventEmitter extends Context.Tag("FlowEventEmitter")() {
+}
+/**
+ * Effect Layer that creates the FlowEventEmitter from a BaseEventEmitter.
+ *
+ * This layer automatically wires up JSON serialization for FlowEvent objects
+ * with the standard "flow_event" message format.
+ *
+ * @example
+ * ```typescript
+ * const program = Effect.gen(function* () {
+ *   const emitter = yield* FlowEventEmitter;
+ *   // Use the emitter...
+ * }).pipe(
+ *   Effect.provide(flowEventEmitter),
+ *   Effect.provide(baseEmitterLayer)
+ * );
+ * ```
+ */
+export const flowEventEmitter = Layer.effect(FlowEventEmitter, Effect.gen(function* () {
+    const baseEmitter = yield* BaseEventEmitterService;
+    return new TypedEventEmitter(baseEmitter, eventToMessageSerializer("flow_event").eventToMessage);
+}));

package/dist/types/index.cjs

@@ -0,0 +1 @@
+require(`../uploadista-error-BB-Wdiz9.cjs`),require(`../errors-CRm1FHHT.cjs`);const e=require(`../types-BT-cvi7T.cjs`);exports.BaseEventEmitterService=e.BaseEventEmitterService,exports.BaseKvStoreService=e.BaseKvStoreService,exports.BufferedUploadFileDataStore=e.BufferedUploadFileDataStore,exports.DataStoreRegistry=e.DataStoreRegistry,exports.FlowEventEmitter=e.FlowEventEmitter,exports.FlowJobKVStore=e.FlowJobKVStore,exports.MiddlewareService=e.MiddlewareService,exports.MiddlewareServiceLive=e.MiddlewareServiceLive,exports.TypedEventEmitter=e.TypedEventEmitter,exports.TypedKvStore=e.TypedKvStore,exports.UploadEventEmitter=e.UploadEventEmitter,exports.UploadEventType=e.UploadEventType,exports.UploadFileDataStore=e.UploadFileDataStore,exports.UploadFileDataStores=e.UploadFileDataStores,exports.UploadFileKVStore=e.UploadFileKVStore,exports.eventToMessageSerializer=e.eventToMessageSerializer,exports.flowEventEmitter=e.flowEventEmitter,exports.flowJobKvStore=e.flowJobKvStore,exports.inputFileSchema=e.inputFileSchema,exports.jsonSerializer=e.jsonSerializer,exports.uploadEventEmitter=e.uploadEventEmitter,exports.uploadEventSchema=e.uploadEventSchema,exports.uploadFileKvStore=e.uploadFileKvStore,exports.uploadFileSchema=e.uploadFileSchema,exports.webSocketMessageSchema=e.webSocketMessageSchema;

package/dist/types/index.d.cts

@@ -0,0 +1,6 @@
+import "../uploadista-error-kKlhLRhY.cjs";
+import "../index-BtBZHVmz.cjs";
+import { BaseEventEmitter, BaseEventEmitterService, BaseKvStore, BaseKvStoreService, BufferedUploadFileDataStore, DataStore, DataStoreCapabilities, DataStoreRegistry, DataStoreWriteOptions, EventEmitter, FlowEventEmitter, FlowJobKVStore, InputFile, KvStore, Middleware, MiddlewareContext, MiddlewareNext, MiddlewareService, MiddlewareServiceLive, TypedEventEmitter, TypedKvStore, UploadEvent, UploadEventEmitter, UploadEventType, UploadFile, UploadFileDataStore, UploadFileDataStores, UploadFileDataStoresShape, UploadFileKVStore, UploadStrategy, WebSocketConnection, WebSocketMessage, eventToMessageSerializer, flowEventEmitter, flowJobKvStore, inputFileSchema, jsonSerializer, uploadEventEmitter, uploadEventSchema, uploadFileKvStore, uploadFileSchema, webSocketMessageSchema } from "../index-BO8GZlbD.cjs";
+import "../generate-id-LjJRLD6N.cjs";
+import "../semaphore-BHprIjFI.cjs";
+export { BaseEventEmitter, BaseEventEmitterService, BaseKvStore, BaseKvStoreService, BufferedUploadFileDataStore, DataStore, DataStoreCapabilities, DataStoreRegistry, DataStoreWriteOptions, EventEmitter, FlowEventEmitter, FlowJobKVStore, InputFile, KvStore, Middleware, MiddlewareContext, MiddlewareNext, MiddlewareService, MiddlewareServiceLive, TypedEventEmitter, TypedKvStore, UploadEvent, UploadEventEmitter, UploadEventType, UploadFile, UploadFileDataStore, UploadFileDataStores, UploadFileDataStoresShape, UploadFileKVStore, UploadStrategy, WebSocketConnection, WebSocketMessage, eventToMessageSerializer, flowEventEmitter, flowJobKvStore, inputFileSchema, jsonSerializer, uploadEventEmitter, uploadEventSchema, uploadFileKvStore, uploadFileSchema, webSocketMessageSchema };

package/dist/types/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./data-store";
+export * from "./event-broadcaster";
+export * from "./event-emitter";
+export * from "./input-file";
+export * from "./kv-store";
+export * from "./middleware";
+export * from "./upload-event";
+export * from "./upload-file";
+export * from "./websocket";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC"}

package/dist/types/index.js

@@ -0,0 +1,9 @@
+export * from "./data-store";
+export * from "./event-broadcaster";
+export * from "./event-emitter";
+export * from "./input-file";
+export * from "./kv-store";
+export * from "./middleware";
+export * from "./upload-event";
+export * from "./upload-file";
+export * from "./websocket";