@delta-base/core 0.0.3 → 1.1.0

package/dist/index.d.ts

@@ -2,129 +2,1188 @@ import * as hono_hono_base from 'hono/hono-base';
 import * as hono_utils_http_status from 'hono/utils/http-status';
 import * as hono_types from 'hono/types';
 import * as hono from 'hono';
+import { z, OpenAPIHono } from '@hono/zod-openapi';
 import { DurableObject } from 'cloudflare:workers';
-import { OpenAPIHono } from '@hono/zod-openapi';
 
-type Flavour<K, T> = K & {
-    readonly __brand?: T;
-};
-type DefaultRecord = Record<string, unknown>;
-type Event<EventType extends string = string, EventData extends DefaultRecord = DefaultRecord, EventMetaData extends DefaultRecord = DefaultRecord> = Flavour<Readonly<{
-    type: EventType;
-    data: EventData;
-    metadata?: EventMetaData;
-}>, 'Event'>;
-type EventTypeOf<T extends Event> = T['type'];
-type EventDataOf<T extends Event> = T['data'];
-type EventMetaDataOf<T extends Event> = T['metadata'];
-type CreateEventType<EventType extends string, EventData extends DefaultRecord, EventMetaData extends DefaultRecord | undefined> = Readonly<{
-    type: EventType;
-    data: EventData;
-    metadata?: EventMetaData;
-}>;
-type ReadEvent<EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadata = EventMetaDataOf<EventType> & ReadEventMetadata> = CreateEventType<EventTypeOf<EventType>, EventDataOf<EventType>, EventMetaDataType> & EventType & {
-    metadata: EventMetaDataType;
-};
-type ReadEventMetadata = Readonly<{
-    eventId: string;
-    streamPosition: number;
-    streamName: string;
-}>;
-type ReadEventMetadataWithGlobalPosition = ReadEventMetadata & {
-    globalPosition: number;
-};
-type ExpectedStreamVersion<VersionType = DefaultStreamVersionType> = ExpectedStreamVersionWithValue<VersionType> | ExpectedStreamVersionGeneral;
-type ExpectedStreamVersionWithValue<VersionType = DefaultStreamVersionType> = Flavour<VersionType, 'StreamVersion'>;
-type ExpectedStreamVersionGeneral = Flavour<'STREAM_EXISTS' | 'STREAM_DOES_NOT_EXIST' | 'NO_CONCURRENCY_CHECK', 'StreamVersion'>;
-interface EventStore<StreamVersion = DefaultStreamVersionType, ReadEventMetadataType extends ReadEventMetadata = ReadEventMetadata> {
-    aggregateStream<State, EventType extends Event>(streamName: string, options: AggregateStreamOptions<State, EventType, StreamVersion, ReadEventMetadataType>): Promise<AggregateStreamResult<State, StreamVersion> | null>;
-    readStream<EventType extends Event>(streamName: string, options?: ReadStreamOptions<StreamVersion>): Promise<ReadStreamResult<EventType, StreamVersion, ReadEventMetadataType>>;
-    appendToStream<EventType extends Event>(streamName: string, events: EventType[], options?: AppendToStreamOptions<StreamVersion>): Promise<AppendToStreamResult<StreamVersion>>;
+declare namespace ManagementAPI {
+    const EventStoreSchema: z.ZodObject<{
+        eventStoreID: z.ZodString;
+        eventStoreName: z.ZodString;
+        eventStoreDurableObjectID: z.ZodString;
+        eventBusDurableObjectID: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        settings: z.ZodOptional<z.ZodObject<{
+            retentionPeriodDays: z.ZodOptional<z.ZodNumber>;
+            maxStreamSizeBytes: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            retentionPeriodDays?: number | undefined;
+            maxStreamSizeBytes?: number | undefined;
+        }, {
+            retentionPeriodDays?: number | undefined;
+            maxStreamSizeBytes?: number | undefined;
+        }>>;
+        created: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        created: string;
+        eventStoreID: string;
+        eventStoreName: string;
+        eventStoreDurableObjectID: string;
+        eventBusDurableObjectID: string;
+        description?: string | undefined;
+        settings?: {
+            retentionPeriodDays?: number | undefined;
+            maxStreamSizeBytes?: number | undefined;
+        } | undefined;
+    }, {
+        created: string;
+        eventStoreID: string;
+        eventStoreName: string;
+        eventStoreDurableObjectID: string;
+        eventBusDurableObjectID: string;
+        description?: string | undefined;
+        settings?: {
+            retentionPeriodDays?: number | undefined;
+            maxStreamSizeBytes?: number | undefined;
+        } | undefined;
+    }>;
+    const CreateEventStoreRequestSchema: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        settings: z.ZodOptional<z.ZodObject<{
+            retentionPeriodDays: z.ZodOptional<z.ZodNumber>;
+            maxStreamSizeBytes: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            retentionPeriodDays?: number | undefined;
+            maxStreamSizeBytes?: number | undefined;
+        }, {
+            retentionPeriodDays?: number | undefined;
+            maxStreamSizeBytes?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description?: string | undefined;
+        settings?: {
+            retentionPeriodDays?: number | undefined;
+            maxStreamSizeBytes?: number | undefined;
+        } | undefined;
+    }, {
+        name: string;
+        description?: string | undefined;
+        settings?: {
+            retentionPeriodDays?: number | undefined;
+            maxStreamSizeBytes?: number | undefined;
+        } | undefined;
+    }>;
+    const EventStoreListResponseSchema: z.ZodObject<{
+        eventStores: z.ZodArray<z.ZodObject<{
+            eventStoreID: z.ZodString;
+            eventStoreName: z.ZodString;
+            eventStoreDurableObjectID: z.ZodString;
+            eventBusDurableObjectID: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            settings: z.ZodOptional<z.ZodObject<{
+                retentionPeriodDays: z.ZodOptional<z.ZodNumber>;
+                maxStreamSizeBytes: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                retentionPeriodDays?: number | undefined;
+                maxStreamSizeBytes?: number | undefined;
+            }, {
+                retentionPeriodDays?: number | undefined;
+                maxStreamSizeBytes?: number | undefined;
+            }>>;
+            created: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            created: string;
+            eventStoreID: string;
+            eventStoreName: string;
+            eventStoreDurableObjectID: string;
+            eventBusDurableObjectID: string;
+            description?: string | undefined;
+            settings?: {
+                retentionPeriodDays?: number | undefined;
+                maxStreamSizeBytes?: number | undefined;
+            } | undefined;
+        }, {
+            created: string;
+            eventStoreID: string;
+            eventStoreName: string;
+            eventStoreDurableObjectID: string;
+            eventBusDurableObjectID: string;
+            description?: string | undefined;
+            settings?: {
+                retentionPeriodDays?: number | undefined;
+                maxStreamSizeBytes?: number | undefined;
+            } | undefined;
+        }>, "many">;
+        totalCount: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        totalCount: number;
+        eventStores: {
+            created: string;
+            eventStoreID: string;
+            eventStoreName: string;
+            eventStoreDurableObjectID: string;
+            eventBusDurableObjectID: string;
+            description?: string | undefined;
+            settings?: {
+                retentionPeriodDays?: number | undefined;
+                maxStreamSizeBytes?: number | undefined;
+            } | undefined;
+        }[];
+    }, {
+        totalCount: number;
+        eventStores: {
+            created: string;
+            eventStoreID: string;
+            eventStoreName: string;
+            eventStoreDurableObjectID: string;
+            eventBusDurableObjectID: string;
+            description?: string | undefined;
+            settings?: {
+                retentionPeriodDays?: number | undefined;
+                maxStreamSizeBytes?: number | undefined;
+            } | undefined;
+        }[];
+    }>;
+    const EventStoreDatabaseSizesSchema: z.ZodObject<{
+        eventStoreDatabaseSize: z.ZodNumber;
+        eventBusDatabaseSize: z.ZodNumber;
+        totalSize: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        eventStoreDatabaseSize: number;
+        eventBusDatabaseSize: number;
+        totalSize: number;
+    }, {
+        eventStoreDatabaseSize: number;
+        eventBusDatabaseSize: number;
+        totalSize: number;
+    }>;
+    const EventStoreDetailsResponseSchema: z.ZodObject<z.objectUtil.extendShape<{
+        eventStoreID: z.ZodString;
+        eventStoreName: z.ZodString;
+        eventStoreDurableObjectID: z.ZodString;
+        eventBusDurableObjectID: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        settings: z.ZodOptional<z.ZodObject<{
+            retentionPeriodDays: z.ZodOptional<z.ZodNumber>;
+            maxStreamSizeBytes: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            retentionPeriodDays?: number | undefined;
+            maxStreamSizeBytes?: number | undefined;
+        }, {
+            retentionPeriodDays?: number | undefined;
+            maxStreamSizeBytes?: number | undefined;
+        }>>;
+        created: z.ZodString;
+    }, {
+        streams: z.ZodOptional<z.ZodObject<{
+            count: z.ZodNumber;
+            totalEvents: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            count: number;
+            totalEvents: number;
+        }, {
+            count: number;
+            totalEvents: number;
+        }>>;
+        databaseSizes: z.ZodOptional<z.ZodObject<{
+            eventStoreDatabaseSize: z.ZodNumber;
+            eventBusDatabaseSize: z.ZodNumber;
+            totalSize: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            eventStoreDatabaseSize: number;
+            eventBusDatabaseSize: number;
+            totalSize: number;
+        }, {
+            eventStoreDatabaseSize: number;
+            eventBusDatabaseSize: number;
+            totalSize: number;
+        }>>;
+    }>, "strip", z.ZodTypeAny, {
+        created: string;
+        eventStoreID: string;
+        eventStoreName: string;
+        eventStoreDurableObjectID: string;
+        eventBusDurableObjectID: string;
+        description?: string | undefined;
+        settings?: {
+            retentionPeriodDays?: number | undefined;
+            maxStreamSizeBytes?: number | undefined;
+        } | undefined;
+        streams?: {
+            count: number;
+            totalEvents: number;
+        } | undefined;
+        databaseSizes?: {
+            eventStoreDatabaseSize: number;
+            eventBusDatabaseSize: number;
+            totalSize: number;
+        } | undefined;
+    }, {
+        created: string;
+        eventStoreID: string;
+        eventStoreName: string;
+        eventStoreDurableObjectID: string;
+        eventBusDurableObjectID: string;
+        description?: string | undefined;
+        settings?: {
+            retentionPeriodDays?: number | undefined;
+            maxStreamSizeBytes?: number | undefined;
+        } | undefined;
+        streams?: {
+            count: number;
+            totalEvents: number;
+        } | undefined;
+        databaseSizes?: {
+            eventStoreDatabaseSize: number;
+            eventBusDatabaseSize: number;
+            totalSize: number;
+        } | undefined;
+    }>;
+    const ErrorResponseSchema: z.ZodObject<{
+        error: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        error: string;
+        message: string;
+        details?: Record<string, any> | undefined;
+    }, {
+        error: string;
+        message: string;
+        details?: Record<string, any> | undefined;
+    }>;
+    const routes: OpenAPIHono<{
+        Bindings: Env;
+    }, {}, "/">;
 }
-type DefaultStreamVersionType = number;
-type ReadStreamOptions<StreamVersion = DefaultStreamVersionType> = ({
-    from: StreamVersion;
-} | {
-    to: StreamVersion;
-} | {
-    from: StreamVersion;
-    maxCount?: DefaultStreamVersionType;
-} | {
-    expectedStreamVersion: ExpectedStreamVersion<StreamVersion>;
-}) & {
-    expectedStreamVersion?: ExpectedStreamVersion<StreamVersion>;
-};
-type ReadStreamResult<EventType extends Event, StreamVersion = DefaultStreamVersionType, ReadEventMetadataType extends ReadEventMetadata = ReadEventMetadata> = {
-    currentStreamVersion: StreamVersion;
-    events: ReadEvent<EventType, ReadEventMetadataType>[];
-} | null;
-type Evolve<State, EventType extends Event, ReadEventMetadataType extends ReadEventMetadata = ReadEventMetadata> = ((currentState: State, event: EventType) => State) | ((currentState: State, event: ReadEvent<EventType, ReadEventMetadataType>) => State) | ((currentState: State, event: ReadEvent<EventType>) => State);
-type AggregateStreamOptions<State, EventType extends Event, StreamVersion = DefaultStreamVersionType, ReadEventMetadataType extends ReadEventMetadata = ReadEventMetadata> = {
-    evolve: Evolve<State, EventType, ReadEventMetadataType>;
-    initialState: () => State;
-    read?: ReadStreamOptions<StreamVersion>;
-};
-type AggregateStreamResult<State, StreamVersion = DefaultStreamVersionType> = {
-    currentStreamVersion: StreamVersion;
-    state: State;
-};
-type AppendToStreamOptions<StreamVersion = DefaultStreamVersionType> = {
-    expectedStreamVersion?: ExpectedStreamVersion<StreamVersion>;
-};
-type AppendToStreamResult<StreamVersion = DefaultStreamVersionType> = {
-    nextExpectedStreamVersion: StreamVersion;
-};
 
-type EventStoreOutboxEvent = {
-    stream_position: number;
-    global_position: number;
-    event_id: string;
-    event_type: string;
-    event_data: string;
-    event_metadata: string;
-    event_schema_version: string;
-    transaction_id: string;
-    stream_id: string;
-    phase: number;
-    created: string;
-    processing_started_at: string;
-    processed_at: string;
-};
-declare class EventStoreDurableObject extends DurableObject<Env> {
-    sql: SqlStorage;
-    constructor(ctx: DurableObjectState, env: Env);
-    private initializeTables;
-    initialize(eventStoreId: string): void;
-    getEventStoreId(): string;
-    appendToStream(streamId: string, events: Event[], options?: AppendToStreamOptions<number>): Promise<AppendToStreamResult<number>>;
-    private getStreamVersion;
-    private getGlobalPosition;
-    private scheduleAsyncWork;
-    private storeEventsToStream;
-    alarm(_alarmInfo: AlarmInvocationInfo): Promise<void>;
-    queryEvents(options: {
-        afterPosition?: number;
-        limit?: number;
-        streamId?: string;
-        eventType?: string;
-    }): Promise<{
-        events: EventStoreOutboxEvent[];
-        hasMore: boolean;
-        nextPosition: number;
+declare namespace EventStoreAPI {
+    const AppendEventsRequestSchema: z.ZodObject<{
+        events: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            data: z.ZodRecord<z.ZodString, z.ZodAny>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            data: Record<string, any>;
+            metadata?: Record<string, any> | undefined;
+        }, {
+            type: string;
+            data: Record<string, any>;
+            metadata?: Record<string, any> | undefined;
+        }>, "many">;
+        options: z.ZodOptional<z.ZodObject<{
+            expectedStreamVersion: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            expectedStreamVersion?: number | undefined;
+        }, {
+            expectedStreamVersion?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        events: {
+            type: string;
+            data: Record<string, any>;
+            metadata?: Record<string, any> | undefined;
+        }[];
+        options?: {
+            expectedStreamVersion?: number | undefined;
+        } | undefined;
+    }, {
+        events: {
+            type: string;
+            data: Record<string, any>;
+            metadata?: Record<string, any> | undefined;
+        }[];
+        options?: {
+            expectedStreamVersion?: number | undefined;
+        } | undefined;
     }>;
-    getDatabaseSize(): number;
-    readStream<EventType extends Event>(streamId: string, options?: ReadStreamOptions & {
-        consistencyLevel?: 'eventual' | 'strong';
-    }): Promise<ReadStreamResult<EventType, DefaultStreamVersionType, ReadEventMetadataWithGlobalPosition> & {
-        consistency: 'eventual' | 'strong';
+    const AppendEventsResponseSchema: z.ZodObject<{
+        success: z.ZodBoolean;
+        nextExpectedStreamVersion: z.ZodNumber;
+        eventsWritten: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        success: boolean;
+        nextExpectedStreamVersion: number;
+        eventsWritten: number;
+    }, {
+        success: boolean;
+        nextExpectedStreamVersion: number;
+        eventsWritten: number;
+    }>;
+    const VersionConflictErrorSchema: z.ZodObject<{
+        error: z.ZodLiteral<"Version conflict">;
+        details: z.ZodString;
+        currentVersion: z.ZodNumber;
+        expectedVersion: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        error: "Version conflict";
+        details: string;
+        currentVersion: number;
+        expectedVersion: number;
+    }, {
+        error: "Version conflict";
+        details: string;
+        currentVersion: number;
+        expectedVersion: number;
+    }>;
+    const ValidationErrorSchema: z.ZodObject<{
+        error: z.ZodLiteral<"Invalid request body">;
+        details: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            path: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            code: string;
+            path: (string | number)[];
+        }, {
+            message: string;
+            code: string;
+            path: (string | number)[];
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        error: "Invalid request body";
+        details: {
+            message: string;
+            code: string;
+            path: (string | number)[];
+        }[];
+    }, {
+        error: "Invalid request body";
+        details: {
+            message: string;
+            code: string;
+            path: (string | number)[];
+        }[];
+    }>;
+    const AppendEventsErrorSchema: z.ZodDiscriminatedUnion<"error", [z.ZodObject<{
+        error: z.ZodLiteral<"Version conflict">;
+        details: z.ZodString;
+        currentVersion: z.ZodNumber;
+        expectedVersion: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        error: "Version conflict";
+        details: string;
+        currentVersion: number;
+        expectedVersion: number;
+    }, {
+        error: "Version conflict";
+        details: string;
+        currentVersion: number;
+        expectedVersion: number;
+    }>, z.ZodObject<{
+        error: z.ZodLiteral<"Invalid request body">;
+        details: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            path: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            code: string;
+            path: (string | number)[];
+        }, {
+            message: string;
+            code: string;
+            path: (string | number)[];
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        error: "Invalid request body";
+        details: {
+            message: string;
+            code: string;
+            path: (string | number)[];
+        }[];
+    }, {
+        error: "Invalid request body";
+        details: {
+            message: string;
+            code: string;
+            path: (string | number)[];
+        }[];
+    }>]>;
+    const ReadStreamOptionsSchema: z.ZodObject<{
+        consistencyLevel: z.ZodOptional<z.ZodEnum<["eventual", "strong"]>>;
+        expectedStreamVersion: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        expectedStreamVersion?: number | undefined;
+        consistencyLevel?: "eventual" | "strong" | undefined;
+    }, {
+        expectedStreamVersion?: number | undefined;
+        consistencyLevel?: "eventual" | "strong" | undefined;
+    }>;
+    const EventWithMetadataSchema: z.ZodObject<z.objectUtil.extendShape<{
+        type: z.ZodString;
+        data: z.ZodRecord<z.ZodString, z.ZodAny>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, {
+        metadata: z.ZodOptional<z.ZodObject<{
+            eventId: z.ZodString;
+            streamPosition: z.ZodNumber;
+            streamName: z.ZodString;
+            globalPosition: z.ZodNumber;
+            schemaVersion: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            eventId: string;
+            streamPosition: number;
+            streamName: string;
+            globalPosition: number;
+            schemaVersion: string;
+        }, {
+            eventId: string;
+            streamPosition: number;
+            streamName: string;
+            globalPosition: number;
+            schemaVersion: string;
+        }>>;
+    }>, "strip", z.ZodTypeAny, {
+        type: string;
+        data: Record<string, any>;
+        metadata?: {
+            eventId: string;
+            streamPosition: number;
+            streamName: string;
+            globalPosition: number;
+            schemaVersion: string;
+        } | undefined;
+    }, {
+        type: string;
+        data: Record<string, any>;
+        metadata?: {
+            eventId: string;
+            streamPosition: number;
+            streamName: string;
+            globalPosition: number;
+            schemaVersion: string;
+        } | undefined;
+    }>;
+    const ReadStreamResponseSchema: z.ZodObject<{
+        events: z.ZodArray<z.ZodObject<z.objectUtil.extendShape<{
+            type: z.ZodString;
+            data: z.ZodRecord<z.ZodString, z.ZodAny>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, {
+            metadata: z.ZodOptional<z.ZodObject<{
+                eventId: z.ZodString;
+                streamPosition: z.ZodNumber;
+                streamName: z.ZodString;
+                globalPosition: z.ZodNumber;
+                schemaVersion: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                eventId: string;
+                streamPosition: number;
+                streamName: string;
+                globalPosition: number;
+                schemaVersion: string;
+            }, {
+                eventId: string;
+                streamPosition: number;
+                streamName: string;
+                globalPosition: number;
+                schemaVersion: string;
+            }>>;
+        }>, "strip", z.ZodTypeAny, {
+            type: string;
+            data: Record<string, any>;
+            metadata?: {
+                eventId: string;
+                streamPosition: number;
+                streamName: string;
+                globalPosition: number;
+                schemaVersion: string;
+            } | undefined;
+        }, {
+            type: string;
+            data: Record<string, any>;
+            metadata?: {
+                eventId: string;
+                streamPosition: number;
+                streamName: string;
+                globalPosition: number;
+                schemaVersion: string;
+            } | undefined;
+        }>, "many">;
+        currentStreamVersion: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        events: {
+            type: string;
+            data: Record<string, any>;
+            metadata?: {
+                eventId: string;
+                streamPosition: number;
+                streamName: string;
+                globalPosition: number;
+                schemaVersion: string;
+            } | undefined;
+        }[];
+        currentStreamVersion: number;
+    }, {
+        events: {
+            type: string;
+            data: Record<string, any>;
+            metadata?: {
+                eventId: string;
+                streamPosition: number;
+                streamName: string;
+                globalPosition: number;
+                schemaVersion: string;
+            } | undefined;
+        }[];
+        currentStreamVersion: number;
+    }>;
+    const routes: OpenAPIHono<{
+        Bindings: Env;
+    }, {}, "/">;
+}
+
+declare namespace EventBusAPI {
+    const routes: OpenAPIHono<{
+        Bindings: Env;
+    }, {}, "/">;
+    const SubscriberTypeEnum: z.ZodEnum<["durable_object", "webhook", "queue", "cloudflare_workflow", "websocket"]>;
+    const SubscriptionStatusEnum: z.ZodEnum<["ACTIVE", "SUSPENDED", "ERROR", "INITIALIZING", "DELETED"]>;
+    const SubscriptionRequestSchema: z.ZodObject<{
+        eventFilter: z.ZodUnion<[z.ZodUnion<[z.ZodLiteral<"*">, z.ZodString, z.ZodString, z.ZodString]>, z.ZodArray<z.ZodUnion<[z.ZodLiteral<"*">, z.ZodString, z.ZodString, z.ZodString]>, "many">]>;
+        subscriberId: z.ZodOptional<z.ZodString>;
+        subscriber: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"durable_object">;
+            config: z.ZodObject<z.objectUtil.extendShape<{
+                retryPolicy: z.ZodOptional<z.ZodObject<{
+                    maxAttempts: z.ZodNumber;
+                    backoffMinutes: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                }, {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                }>>;
+            }, {
+                namespace: z.ZodString;
+                id: z.ZodString;
+            }>, "strip", z.ZodTypeAny, {
+                namespace: string;
+                id: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+            }, {
+                namespace: string;
+                id: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            type: "durable_object";
+            config: {
+                namespace: string;
+                id: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+            };
+        }, {
+            type: "durable_object";
+            config: {
+                namespace: string;
+                id: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+            };
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"webhook">;
+            config: z.ZodObject<z.objectUtil.extendShape<{
+                retryPolicy: z.ZodOptional<z.ZodObject<{
+                    maxAttempts: z.ZodNumber;
+                    backoffMinutes: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                }, {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                }>>;
+            }, {
+                url: z.ZodString;
+                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                timeoutMs: z.ZodOptional<z.ZodNumber>;
+            }>, "strip", z.ZodTypeAny, {
+                url: string;
+                headers?: Record<string, string> | undefined;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+                timeoutMs?: number | undefined;
+            }, {
+                url: string;
+                headers?: Record<string, string> | undefined;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+                timeoutMs?: number | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            type: "webhook";
+            config: {
+                url: string;
+                headers?: Record<string, string> | undefined;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+                timeoutMs?: number | undefined;
+            };
+        }, {
+            type: "webhook";
+            config: {
+                url: string;
+                headers?: Record<string, string> | undefined;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+                timeoutMs?: number | undefined;
+            };
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"queue">;
+            config: z.ZodObject<z.objectUtil.extendShape<{
+                retryPolicy: z.ZodOptional<z.ZodObject<{
+                    maxAttempts: z.ZodNumber;
+                    backoffMinutes: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                }, {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                }>>;
+            }, {
+                queueName: z.ZodString;
+                region: z.ZodOptional<z.ZodString>;
+                batchSize: z.ZodOptional<z.ZodNumber>;
+            }>, "strip", z.ZodTypeAny, {
+                queueName: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+                region?: string | undefined;
+                batchSize?: number | undefined;
+            }, {
+                queueName: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+                region?: string | undefined;
+                batchSize?: number | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            type: "queue";
+            config: {
+                queueName: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+                region?: string | undefined;
+                batchSize?: number | undefined;
+            };
+        }, {
+            type: "queue";
+            config: {
+                queueName: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+                region?: string | undefined;
+                batchSize?: number | undefined;
+            };
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"cloudflare_workflow">;
+            config: z.ZodObject<z.objectUtil.extendShape<{
+                retryPolicy: z.ZodOptional<z.ZodObject<{
+                    maxAttempts: z.ZodNumber;
+                    backoffMinutes: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                }, {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                }>>;
+            }, {
+                bindingName: z.ZodString;
+            }>, "strip", z.ZodTypeAny, {
+                bindingName: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+            }, {
+                bindingName: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            type: "cloudflare_workflow";
+            config: {
+                bindingName: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+            };
+        }, {
+            type: "cloudflare_workflow";
+            config: {
+                bindingName: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+            };
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"websocket">;
+            config: z.ZodObject<z.objectUtil.extendShape<{
+                retryPolicy: z.ZodOptional<z.ZodObject<{
+                    maxAttempts: z.ZodNumber;
+                    backoffMinutes: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                }, {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                }>>;
+            }, {
+                managerId: z.ZodString;
+            }>, "strip", z.ZodTypeAny, {
+                managerId: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+            }, {
+                managerId: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            type: "websocket";
+            config: {
+                managerId: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+            };
+        }, {
+            type: "websocket";
+            config: {
+                managerId: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+            };
+        }>]>;
+        initialPosition: z.ZodDefault<z.ZodOptional<z.ZodEnum<["latest", "earliest"]>>>;
+    }, "strip", z.ZodTypeAny, {
+        eventFilter: string | string[];
+        subscriber: {
+            type: "durable_object";
+            config: {
+                namespace: string;
+                id: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+            };
+        } | {
+            type: "webhook";
+            config: {
+                url: string;
+                headers?: Record<string, string> | undefined;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+                timeoutMs?: number | undefined;
+            };
+        } | {
+            type: "queue";
+            config: {
+                queueName: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+                region?: string | undefined;
+                batchSize?: number | undefined;
+            };
+        } | {
+            type: "cloudflare_workflow";
+            config: {
+                bindingName: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+            };
+        } | {
+            type: "websocket";
+            config: {
+                managerId: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+            };
+        };
+        initialPosition: "latest" | "earliest";
+        subscriberId?: string | undefined;
+    }, {
+        eventFilter: string | string[];
+        subscriber: {
+            type: "durable_object";
+            config: {
+                namespace: string;
+                id: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+            };
+        } | {
+            type: "webhook";
+            config: {
+                url: string;
+                headers?: Record<string, string> | undefined;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+                timeoutMs?: number | undefined;
+            };
+        } | {
+            type: "queue";
+            config: {
+                queueName: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+                region?: string | undefined;
+                batchSize?: number | undefined;
+            };
+        } | {
+            type: "cloudflare_workflow";
+            config: {
+                bindingName: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+            };
+        } | {
+            type: "websocket";
+            config: {
+                managerId: string;
+                retryPolicy?: {
+                    maxAttempts: number;
+                    backoffMinutes: number;
+                } | undefined;
+            };
+        };
+        subscriberId?: string | undefined;
+        initialPosition?: "latest" | "earliest" | undefined;
+    }>;
+    const SubscriptionResponseSchema: z.ZodObject<{
+        subscriptionId: z.ZodString;
+        status: z.ZodEnum<["ACTIVE", "SUSPENDED", "ERROR", "INITIALIZING", "DELETED"]>;
+        statusDetails: z.ZodOptional<z.ZodObject<{
+            lastError: z.ZodOptional<z.ZodString>;
+            lastErrorAt: z.ZodOptional<z.ZodString>;
+            retryCount: z.ZodOptional<z.ZodNumber>;
+            nextRetryAt: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            lastError?: string | undefined;
+            retryCount?: number | undefined;
+            lastErrorAt?: string | undefined;
+            nextRetryAt?: string | undefined;
+        }, {
+            lastError?: string | undefined;
+            retryCount?: number | undefined;
+            lastErrorAt?: string | undefined;
+            nextRetryAt?: string | undefined;
+        }>>;
+        eventStoreId: z.ZodString;
+        eventFilter: z.ZodString;
+        subscriberId: z.ZodString;
+        subscriberType: z.ZodEnum<["durable_object", "webhook", "queue", "cloudflare_workflow", "websocket"]>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        lastProcessedEventGlobalPosition: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        status: "ACTIVE" | "SUSPENDED" | "ERROR" | "INITIALIZING" | "DELETED";
+        eventStoreId: string;
+        subscriberType: "websocket" | "durable_object" | "webhook" | "queue" | "cloudflare_workflow";
+        eventFilter: string;
+        subscriberId: string;
+        createdAt: string;
+        updatedAt: string;
+        subscriptionId: string;
+        statusDetails?: {
+            lastError?: string | undefined;
+            retryCount?: number | undefined;
+            lastErrorAt?: string | undefined;
+            nextRetryAt?: string | undefined;
+        } | undefined;
+        lastProcessedEventGlobalPosition?: number | undefined;
+    }, {
+        status: "ACTIVE" | "SUSPENDED" | "ERROR" | "INITIALIZING" | "DELETED";
+        eventStoreId: string;
+        subscriberType: "websocket" | "durable_object" | "webhook" | "queue" | "cloudflare_workflow";
+        eventFilter: string;
+        subscriberId: string;
+        createdAt: string;
+        updatedAt: string;
+        subscriptionId: string;
+        statusDetails?: {
+            lastError?: string | undefined;
+            retryCount?: number | undefined;
+            lastErrorAt?: string | undefined;
+            nextRetryAt?: string | undefined;
+        } | undefined;
+        lastProcessedEventGlobalPosition?: number | undefined;
+    }>;
+    const SubscriptionListResponseSchema: z.ZodObject<{
+        subscriptions: z.ZodArray<z.ZodObject<{
+            subscriptionId: z.ZodString;
+            status: z.ZodEnum<["ACTIVE", "SUSPENDED", "ERROR", "INITIALIZING", "DELETED"]>;
+            statusDetails: z.ZodOptional<z.ZodObject<{
+                lastError: z.ZodOptional<z.ZodString>;
+                lastErrorAt: z.ZodOptional<z.ZodString>;
+                retryCount: z.ZodOptional<z.ZodNumber>;
+                nextRetryAt: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                lastError?: string | undefined;
+                retryCount?: number | undefined;
+                lastErrorAt?: string | undefined;
+                nextRetryAt?: string | undefined;
+            }, {
+                lastError?: string | undefined;
+                retryCount?: number | undefined;
+                lastErrorAt?: string | undefined;
+                nextRetryAt?: string | undefined;
+            }>>;
+            eventStoreId: z.ZodString;
+            eventFilter: z.ZodString;
+            subscriberId: z.ZodString;
+            subscriberType: z.ZodEnum<["durable_object", "webhook", "queue", "cloudflare_workflow", "websocket"]>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+            lastProcessedEventGlobalPosition: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            status: "ACTIVE" | "SUSPENDED" | "ERROR" | "INITIALIZING" | "DELETED";
+            eventStoreId: string;
+            subscriberType: "websocket" | "durable_object" | "webhook" | "queue" | "cloudflare_workflow";
+            eventFilter: string;
+            subscriberId: string;
+            createdAt: string;
+            updatedAt: string;
+            subscriptionId: string;
+            statusDetails?: {
+                lastError?: string | undefined;
+                retryCount?: number | undefined;
+                lastErrorAt?: string | undefined;
+                nextRetryAt?: string | undefined;
+            } | undefined;
+            lastProcessedEventGlobalPosition?: number | undefined;
+        }, {
+            status: "ACTIVE" | "SUSPENDED" | "ERROR" | "INITIALIZING" | "DELETED";
+            eventStoreId: string;
+            subscriberType: "websocket" | "durable_object" | "webhook" | "queue" | "cloudflare_workflow";
+            eventFilter: string;
+            subscriberId: string;
+            createdAt: string;
+            updatedAt: string;
+            subscriptionId: string;
+            statusDetails?: {
+                lastError?: string | undefined;
+                retryCount?: number | undefined;
+                lastErrorAt?: string | undefined;
+                nextRetryAt?: string | undefined;
+            } | undefined;
+            lastProcessedEventGlobalPosition?: number | undefined;
+        }>, "many">;
+        totalCount: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        totalCount: number;
+        subscriptions: {
+            status: "ACTIVE" | "SUSPENDED" | "ERROR" | "INITIALIZING" | "DELETED";
+            eventStoreId: string;
+            subscriberType: "websocket" | "durable_object" | "webhook" | "queue" | "cloudflare_workflow";
+            eventFilter: string;
+            subscriberId: string;
+            createdAt: string;
+            updatedAt: string;
+            subscriptionId: string;
+            statusDetails?: {
+                lastError?: string | undefined;
+                retryCount?: number | undefined;
+                lastErrorAt?: string | undefined;
+                nextRetryAt?: string | undefined;
+            } | undefined;
+            lastProcessedEventGlobalPosition?: number | undefined;
+        }[];
+    }, {
+        totalCount: number;
+        subscriptions: {
+            status: "ACTIVE" | "SUSPENDED" | "ERROR" | "INITIALIZING" | "DELETED";
+            eventStoreId: string;
+            subscriberType: "websocket" | "durable_object" | "webhook" | "queue" | "cloudflare_workflow";
+            eventFilter: string;
+            subscriberId: string;
+            createdAt: string;
+            updatedAt: string;
+            subscriptionId: string;
+            statusDetails?: {
+                lastError?: string | undefined;
+                retryCount?: number | undefined;
+                lastErrorAt?: string | undefined;
+                nextRetryAt?: string | undefined;
+            } | undefined;
+            lastProcessedEventGlobalPosition?: number | undefined;
+        }[];
+    }>;
+    const SubscriptionErrorSchema: z.ZodObject<{
+        error: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        error: string;
+        message: string;
+        details?: Record<string, any> | undefined;
+    }, {
+        error: string;
+        message: string;
+        details?: Record<string, any> | undefined;
+    }>;
+}
+
+declare namespace WebSocketsAPI {
+    const WebSocketConnectionSchema: z.ZodObject<{
+        connectionId: z.ZodString;
+        clientId: z.ZodString;
+        connectedAt: z.ZodString;
+        ipAddress: z.ZodOptional<z.ZodString>;
+        userAgent: z.ZodOptional<z.ZodString>;
+        filter: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        clientId: string;
+        connectionId: string;
+        connectedAt: string;
+        filter?: string | undefined;
+        ipAddress?: string | undefined;
+        userAgent?: string | undefined;
+    }, {
+        clientId: string;
+        connectionId: string;
+        connectedAt: string;
+        filter?: string | undefined;
+        ipAddress?: string | undefined;
+        userAgent?: string | undefined;
+    }>;
+    const WebSocketConnectionListResponseSchema: z.ZodObject<{
+        connections: z.ZodArray<z.ZodObject<{
+            connectionId: z.ZodString;
+            clientId: z.ZodString;
+            connectedAt: z.ZodString;
+            ipAddress: z.ZodOptional<z.ZodString>;
+            userAgent: z.ZodOptional<z.ZodString>;
+            filter: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            clientId: string;
+            connectionId: string;
+            connectedAt: string;
+            filter?: string | undefined;
+            ipAddress?: string | undefined;
+            userAgent?: string | undefined;
+        }, {
+            clientId: string;
+            connectionId: string;
+            connectedAt: string;
+            filter?: string | undefined;
+            ipAddress?: string | undefined;
+            userAgent?: string | undefined;
+        }>, "many">;
+        totalCount: z.ZodNumber;
+        eventStoreId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        connections: {
+            clientId: string;
+            connectionId: string;
+            connectedAt: string;
+            filter?: string | undefined;
+            ipAddress?: string | undefined;
+            userAgent?: string | undefined;
+        }[];
+        totalCount: number;
+        eventStoreId: string;
+    }, {
+        connections: {
+            clientId: string;
+            connectionId: string;
+            connectedAt: string;
+            filter?: string | undefined;
+            ipAddress?: string | undefined;
+            userAgent?: string | undefined;
+        }[];
+        totalCount: number;
+        eventStoreId: string;
+    }>;
+    const ErrorResponseSchema: z.ZodObject<{
+        error: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        error: string;
+        message: string;
+        details?: Record<string, any> | undefined;
+    }, {
+        error: string;
+        message: string;
+        details?: Record<string, any> | undefined;
     }>;
-    private waitForStreamVersion;
-    private mergeAndDeduplicateEvents;
+    const routes: OpenAPIHono<{
+        Bindings: Env;
+    }, {}, "/">;
 }
 
 type WildcardPattern = '*' | `${string}.*` | `*.${string}` | `${string}.*${string}`;
 type EventType = string;
 type EventFilter = EventType | EventType[] | WildcardPattern;
+declare enum InitialPosition {
+    LATEST = "latest",
+    EARLIEST = "earliest"
+}
 interface BaseSubscriberConfig {
     retryPolicy?: {
         maxAttempts: number;
@@ -189,24 +1248,64 @@ interface EventMessage {
     transaction_id: string;
     created: string;
 }
+interface SubscriptionListOptions {
+    subscriberType?: SubscriberType;
+    eventFilter?: string;
+    limit?: number;
+    offset?: number;
+}
+declare enum SubscriptionStatus {
+    ACTIVE = "ACTIVE",
+    SUSPENDED = "SUSPENDED",
+    ERROR = "ERROR",
+    INITIALIZING = "INITIALIZING",
+    DELETED = "DELETED"
+}
+interface StatusDetails {
+    lastError?: string;
+    lastErrorAt?: string;
+    retryCount?: number;
+    nextRetryAt?: string;
+    reason?: string;
+}
+interface Subscription {
+    id: string;
+    eventFilter: string;
+    subscriberId: string;
+    subscriberType: SubscriberType;
+    subscriberConfig: string;
+    status: SubscriptionStatus;
+    statusDetails?: StatusDetails;
+    lastProcessedEventGlobalPosition: number;
+    createdAt: string;
+    updatedAt: string;
+}
 declare class EventBusDurableObject extends DurableObject<Env$1> {
     private readonly BATCH_SIZE;
     private readonly RETRY_DELAY_HOURS;
     sql: SqlStorage;
     constructor(state: DurableObjectState, env: Env$1);
     private initializeTables;
-    subscribe(eventFilter: EventFilter, subscriberId: string, subscription: SubscriberTypeConfig): Promise<void>;
-    unsubscribe(eventFilter: EventFilter, subscriberId: string): Promise<void>;
-    getSubscriptions(): Promise<{
-        id: string;
-        eventFilter: string;
-        subscriberId: string;
-        subscriberType: SubscriberType;
-        subscriberConfig: string;
-        lastProcessedEventGlobalPosition: number;
-        createdAt: string;
-    }[]>;
-    publish(events: EventStoreOutboxEvent[]): Promise<void>;
+    initialize(eventStoreID: string): void;
+    subscribe(eventFilter: EventFilter, subscriberId: string, subscription: SubscriberTypeConfig, initialPosition?: InitialPosition): Promise<void>;
+    private validateSubscriberConfig;
+    private updateSubscriptionStatus;
+    unsubscribe(subscriberId: string): Promise<void>;
+    getSubscriptions(options?: SubscriptionListOptions): Promise<Subscription[]>;
+    getSubscriptionsCount(options?: Omit<SubscriptionListOptions, 'limit' | 'offset'>): Promise<number>;
+    getSubscription(id: string): Promise<Subscription | null>;
+    publish(events: {
+        event_id: string;
+        event_type: string;
+        event_data: Record<string, unknown>;
+        event_metadata: Record<string, unknown>;
+        stream_id: string;
+        stream_position: number;
+        global_position: number;
+        event_schema_version: string;
+        transaction_id: string;
+        created: string;
+    }[]): Promise<void>;
     private getMatchingSubscriptions;
     private scheduleDelivery;
     private processOutboxBatch;
@@ -215,6 +1314,7 @@ declare class EventBusDurableObject extends DurableObject<Env$1> {
     private parseSubscription;
     private markMessageAsProcessed;
     private markMessageAsFailed;
+    private markDeliveryAttempt;
     private deliverEvent;
     private logProcessingMetrics;
     alarm(alarmInfo: AlarmInvocationInfo): Promise<void>;
@@ -222,165 +1322,434 @@ declare class EventBusDurableObject extends DurableObject<Env$1> {
     private validateEventFilter;
 }
 
-declare class WebSocketManagerDurableObject extends DurableObject<Env> {
-    fetch(request: Request): Promise<Response>;
-    private findWebSocketsByClientId;
-    deliverEventToClient(clientId: string, event: EventMessage): Promise<void>;
-    broadcastEvent(event: EventMessage): Promise<void>;
-    closeConnection(clientId: string): Promise<void>;
-    webSocketClose(ws: WebSocket, _code: number, reason: string, _wasClean: boolean): Promise<void>;
-}
-
-declare class EventStreamDurableObject extends DurableObject<Env> {
-    sql: SqlStorage;
-    private isProcessing;
-    private static ALARM_DELAY;
-    constructor(ctx: DurableObjectState, env: Env);
-    private initializeTables;
-    initializeStream(streamId: string, eventStoreId: string): void;
-    private getStreamId;
-    private getEventStoreId;
-    appendToStream(events: EventStoreOutboxEvent[]): Promise<void>;
-    getStreamEvents<EventType extends Event>(streamId: string, options?: ReadStreamOptions<number>): ReadStreamResult<EventType, number, ReadEventMetadataWithGlobalPosition>;
-    getEventsByEventIds(eventIds: string[]): Promise<ReadEvent[]>;
-    private checkUnprocessedEvents;
-    private scheduleAsyncWork;
-    private publishEventsToEventBus;
-    private storeEventsToGlobalIndex;
-    alarm(_alarmInfo: AlarmInvocationInfo): Promise<void>;
-}
+type Flavour<K, T> = K & {
+    readonly __brand?: T;
+};
+type DefaultRecord = Record<string, unknown>;
+type Event<EventType extends string = string, EventData extends DefaultRecord = DefaultRecord, EventMetaData extends DefaultRecord = DefaultRecord> = Flavour<Readonly<{
+    type: EventType;
+    data: EventData;
+    metadata?: EventMetaData;
+}>, 'Event'>;
+type EventTypeOf<T extends Event> = T['type'];
+type EventDataOf<T extends Event> = T['data'];
+type EventMetaDataOf<T extends Event> = T['metadata'];
+type CreateEventType<EventType extends string, EventData extends DefaultRecord, EventMetaData extends DefaultRecord | undefined> = Readonly<{
+    type: EventType;
+    data: EventData;
+    metadata?: EventMetaData;
+}>;
+type ReadEvent<EventType extends Event = Event, EventMetaDataType extends EventMetaDataOf<EventType> & ReadEventMetadata = EventMetaDataOf<EventType> & ReadEventMetadata> = CreateEventType<EventTypeOf<EventType>, EventDataOf<EventType>, EventMetaDataType> & EventType & {
+    metadata: EventMetaDataType;
+};
+type ReadEventMetadata = Readonly<{
+    eventId: string;
+    streamPosition: number;
+    streamName: string;
+}>;
+type ExpectedStreamVersion<VersionType = DefaultStreamVersionType> = ExpectedStreamVersionWithValue<VersionType> | ExpectedStreamVersionGeneral;
+type ExpectedStreamVersionWithValue<VersionType = DefaultStreamVersionType> = Flavour<VersionType, 'StreamVersion'>;
+type ExpectedStreamVersionGeneral = Flavour<'STREAM_EXISTS' | 'STREAM_DOES_NOT_EXIST' | 'NO_CONCURRENCY_CHECK', 'StreamVersion'>;
+type DefaultStreamVersionType = number;
+type ReadStreamOptions<StreamVersion = DefaultStreamVersionType> = ({
+    from: StreamVersion;
+} | {
+    to: StreamVersion;
+} | {
+    from: StreamVersion;
+    maxCount?: DefaultStreamVersionType;
+} | {
+    expectedStreamVersion: ExpectedStreamVersion<StreamVersion>;
+}) & {
+    expectedStreamVersion?: ExpectedStreamVersion<StreamVersion>;
+};
+type AppendToStreamOptions<StreamVersion = DefaultStreamVersionType> = {
+    expectedStreamVersion?: ExpectedStreamVersion<StreamVersion>;
+};
 
-declare class EventGlobalIndexDurableObject extends DurableObject<Env> {
+/**
+ * A durable object implementation of an event store.
+ * Handles event persistence, archiving, and event bus integration.
+ */
+declare class EventStoreDurableObject extends DurableObject<Env> {
     sql: SqlStorage;
+    /** Soft limit for database size (90% of 10GB) */
+    private readonly SIZE_SOFT_LIMIT_MB;
+    /** Hard limit for database size (95% of 10GB) */
+    private readonly SIZE_HARD_LIMIT_MB;
+    /** Emergency limit for database size (95% of 10GB) */
+    private readonly SIZE_EMERGENCY_MB;
+    /** Conversion factor from MB to bytes */
+    private readonly MB_TO_BYTES;
+    /** Number of events to store in each archive chunk */
+    private readonly EVENTS_PER_ARCHIVE_CHUNK;
+    /** Maximum batch size for emergency operations */
+    private readonly MAX_EMERGENCY_BATCH_SIZE;
+    /**
+     * Creates a new instance of the EventStoreDurableObject
+     * @param ctx - The durable object state
+     * @param env - Environment variables and bindings
+     */
     constructor(ctx: DurableObjectState, env: Env);
+    /**
+     * Initializes the database tables required for the event store
+     * @private
+     */
     private initializeTables;
-    appendToIndex(events: EventStoreOutboxEvent[]): Promise<void>;
-    getEventsByType(eventType: string, options?: {
-        fromPosition?: number;
-        limit?: number;
-        streamId?: string;
-    }): Promise<Record<string, SqlStorageValue>[]>;
-    getEventsPaginated(options: {
-        afterPosition?: number;
-        limit?: number;
-        streamId?: string;
-        eventType?: string;
-    }): Promise<{
-        events: Record<string, SqlStorageValue>[];
-        hasMore: boolean;
-        nextPosition: SqlStorageValue | undefined;
+    /**
+     * Initializes the event store with a name
+     * @param eventStoreID - The ID to assign to this event store
+     */
+    initialize(eventStoreID: string): void;
+    /**
+     * Appends events to a stream with optimistic concurrency control
+     * @param streamId - The unique identifier for the stream
+     * @param events - Array of events to append
+     * @param options - Optional parameters for append operation
+     * @returns Promise resolving to the next expected version and last global position
+     * @throws Error if stream id is missing or events array is empty
+     */
+    appendToStream(streamId: string, events: Event[], options?: AppendToStreamOptions<number>): Promise<{
+        nextExpectedStreamVersion: number;
+        lastGlobalPosition: number;
     }>;
-    getEventsByTransactionId(transactionId: string): Promise<Record<string, SqlStorageValue>[]>;
-    getEventCounts(): Promise<Record<string, SqlStorageValue>[]>;
-    getEventTypeDistribution(streamId?: string): Promise<Record<string, SqlStorageValue>[]>;
-    getEventsInTimeAndPositionRange(options: {
-        startTime?: Date;
-        endTime?: Date;
-        minPosition?: number;
-        maxPosition?: number;
-        streamId?: string;
-        limit?: number;
-    }): Promise<Record<string, SqlStorageValue>[]>;
-    getEventStatistics(windowStart: Date, windowEnd: Date): Promise<Record<string, SqlStorageValue>>;
-    getEventsAfterPosition(position: number, limit?: number): Promise<Record<string, SqlStorageValue>[]>;
-    getStreamEvents(streamId: string, options?: {
-        fromPosition?: number;
-        toPosition?: number;
-        limit?: number;
-    }): Promise<Record<string, SqlStorageValue>[]>;
-    getEventsByTimeRange(startTime: Date, endTime: Date, limit?: number): Promise<Record<string, SqlStorageValue>[]>;
-    getLatestEvents(limit?: number): Promise<Record<string, SqlStorageValue>[]>;
-    getStreamPositionRange(streamId: string): Promise<Record<string, SqlStorageValue>>;
-    getDatabaseSize(): number;
+    /**
+     * Reads events from a stream
+     * @param streamId - The unique identifier for the stream
+     * @param options - Optional parameters for read operation
+     * @returns Promise resolving to the stream's events and metadata
+     * @throws Error if stream id is missing
+     */
+    readStream(streamId: string, options?: ReadStreamOptions): Promise<{
+        currentStreamVersion: number;
+        events: ReadEvent[];
+        streamExists: boolean;
+    }>;
+    /**
+     * Gets the id of this event store instance
+     * @returns The configured id of the event store
+     */
+    getEventStoreId(): string;
+    /**
+     * Maps a database row to an event object
+     * @param row - The database row containing event data
+     * @returns A properly formatted event object
+     * @private
+     */
+    private mapRowToEvent;
+    /**
+     * Gets the current version of a stream
+     * @param streamId - The stream to get the version for
+     * @returns The current version number of the stream
+     * @private
+     */
+    private getStreamVersion;
+    /**
+     * Gets information about a stream
+     * @param streamId - The stream to get information for
+     * @returns Stream metadata and state information
+     * @private
+     */
+    private getStreamInfo;
+    /**
+     * Gets the type of a stream from its ID or metadata
+     * @param streamId - The stream to get the type for
+     * @returns The determined stream type
+     * @private
+     */
+    private getStreamType;
+    /**
+     * Creates an event record for storage
+     * @param event - The event to create a record for
+     * @param streamId - The stream the event belongs to
+     * @param position - The position in the stream
+     * @returns A formatted event record
+     * @private
+     */
+    private createEventRecord;
+    /**
+     * Inserts events into the database
+     * @param events - The events to insert
+     * @returns The last global position after insertion
+     * @private
+     */
+    private insertEvents;
+    /**
+     * Reads archived events from R2 storage
+     * @param streamId - The stream to read archived events from
+     * @param fromPosition - Starting position to read from
+     * @param toPosition - Ending position to read to
+     * @returns Array of archived events
+     * @private
+     */
+    private readArchivedEvents;
+    /**
+     * Queues events for processing by the event bus
+     * @param streamId - The stream the events belong to
+     * @param events - The events to queue
+     * @private
+     */
+    private queueEventsForEventBus;
+    /**
+     * Processes events that are pending publication to the event bus
+     * @private
+     */
+    private processPendingEventBusMessages;
+    private getDatabaseSizeInMB;
+    private getStoragePressureLevel;
+    private checkDatabaseSize;
+    private getNextCheckDelay;
+    private checkStreamsForArchiving;
+    /**
+     * Gets archiving parameters based on storage pressure level
+     * @param pressureLevel - Current storage pressure level
+     * @returns Parameters for archiving operations
+     * @private
+     */
+    private getArchivingParameters;
+    /**
+     * Calculates the batch size for archiving based on pressure level
+     * @param availableEvents - Number of events available for archiving
+     * @param pressureLevel - Current storage pressure level
+     * @returns Number of events to archive in this batch
+     * @private
+     */
+    private calculateBatchSize;
+    /**
+     * Archives a stream from fromPosition to toPosition
+     * @param streamId - The stream to archive
+     * @param fromPosition - Starting position to archive from
+     * @param toPosition - Ending position to archive to
+     * @private
+     */
+    private archiveStream;
+    /**
+     * Reads events for archiving from the database
+     * @param streamId - The stream to read events from
+     * @param fromPosition - Starting position to read from
+     * @param toPosition - Ending position to read to
+     * @param limit - Maximum number of events to read
+     * @returns Array of events to archive
+     * @private
+     */
+    private readEventsForArchiving;
+    /**
+     * Updates stream metadata with archive information
+     * @param streamId - The stream being archived
+     * @param fromPosition - Starting position of the archive
+     * @param toPosition - Ending position of the archive
+     * @param archiveKey - Key where the archive is stored
+     * @private
+     */
+    private updateStreamArchiveMetadata;
+    /**
+     * Prunes archived events that have been safely stored in R2
+     * @param isEmergency - Whether this is an emergency pruning operation
+     * @private
+     */
+    private pruneArchivedEvents;
+    /**
+     * Emergency pruning of oldest events regardless of archive status
+     * @private
+     */
+    private emergencyPruneOldestEvents;
+    /**
+     * Emergency archive method - simplified for speed
+     * @param streamId - The stream to archive
+     * @param fromPosition - Starting position to archive from
+     * @param toPosition - Ending position to archive to
+     * @private
+     */
+    private emergencyArchiveEvents;
+    /**
+     * Notifies subscribers when a stream is archived
+     * @param streamId - The archived stream
+     * @param fromPosition - Starting position of the archive
+     * @param toPosition - Ending position of the archive
+     * @param archiveKey - Key where the archive is stored
+     * @private
+     */
+    private notifyStreamArchived;
+    /**
+     * Gets current metrics for this event store
+     * @returns Current metrics including size, pressure, and event counts
+     */
+    getMetrics(): Promise<{
+        database_size_mb: number;
+        pressure_level: string;
+        total_streams: number;
+        total_events: number;
+        archived_events: number;
+        pending_events: number;
+    }>;
+    /**
+     * Enhanced alarm handler for processing async work
+     */
+    alarm(): Promise<void>;
+    /**
+     * Schedules asynchronous work based on current system state
+     * @private
+     */
+    private scheduleAsyncWork;
+    /**
+     * Checks if there is any non-event-bus related work to be done
+     * @returns Whether there is other work pending
+     * @private
+     */
+    private hasOtherWorkToDo;
 }
 
 declare class EventStoreManagerDurableObject extends DurableObject<Env> {
     sql: SqlStorage;
     constructor(ctx: DurableObjectState, env: Env);
+    private scheduleMetricsCollection;
     private initializeTables;
-    createEventStore(eventStoreName: string): Promise<{
+    createEventStore(eventStoreName: string, description?: string, settings?: {
+        retentionPeriodDays?: number;
+        maxStreamSizeBytes?: number;
+    }): Promise<{
         eventStoreID: string;
         eventStoreName: string;
         eventStoreDurableObjectID: string;
         eventBusDurableObjectID: string;
-        eventGlobalIndexDurableObjectID: string;
+        description?: string;
+        settings?: {
+            retentionPeriodDays?: number;
+            maxStreamSizeBytes?: number;
+        };
+        created: string;
     }>;
-    getEventStoreInfo(eventStoreName: string): {
+    getEventStoreInfo(eventStoreId: string, options?: {
+        includeDeleted?: boolean;
+    }): {
         eventStoreID: string;
         eventStoreName: string;
         eventStoreDurableObjectID: string;
         eventBusDurableObjectID: string;
-        eventGlobalIndexDurableObjectID: string;
-    };
-    getEventStoreDatabaseSizes(eventStoreName: string): Promise<{
+        description?: string;
+        settings?: {
+            retentionPeriodDays?: number;
+            maxStreamSizeBytes?: number;
+        };
+        created: string;
+    } | null;
+    listEventStores(options: {
+        limit?: number;
+        offset?: number;
+        namePrefix?: string;
+    }): Promise<{
+        eventStores: Array<{
+            eventStoreID: string;
+            eventStoreName: string;
+            eventStoreDurableObjectID: string;
+            eventBusDurableObjectID: string;
+            description?: string;
+            settings?: {
+                retentionPeriodDays?: number;
+                maxStreamSizeBytes?: number;
+            };
+            created: string;
+        }>;
+        totalCount: number;
+    }>;
+    getStreamStats(eventStoreId: string): Promise<{
+        count: number;
+        totalEvents: number;
+    }>;
+    getDatabaseSizes(eventStoreId: string): Promise<{
         eventStoreDatabaseSize: number;
         eventBusDatabaseSize: number;
-        eventGlobalIndexDatabaseSize: number;
+        totalSize: number;
     }>;
-}
-
-// Generated by Wrangler by running `wrangler types`
-
-interface Env {
-  EVENT_STORE_MANAGER_DO: DurableObjectNamespace<
-    EventStoreManagerDurableObject
-  >;
-  EVENT_STORE_DO: DurableObjectNamespace<
-    EventStoreDurableObject
-  >;
-  EVENT_BUS_DO: DurableObjectNamespace<
-    EventBusDurableObject
-  >;
-  EVENT_GLOBAL_INDEX_DO: DurableObjectNamespace<
-    EventGlobalIndexDurableObject
-  >;
-  EVENT_STREAM_DO: DurableObjectNamespace<
-    EventStreamDurableObject
-  >;
-  WS_MANAGER_DO: DurableObjectNamespace<
-    WebSocketManagerDurableObject
-  >;
-}
-
-declare const getDOEventStoreManagement: (environmentName: string, env: Env) => {
-    createEventStore: (eventStoreName: string) => Promise<{
-        eventStoreID: string;
-        eventStoreName: string;
-        eventStoreDurableObjectID: string;
-        eventBusDurableObjectID: string;
-        eventGlobalIndexDurableObjectID: string;
-    } & Disposable>;
-    getEventStoreInfo: (eventStoreName: string) => Promise<{
+    fetch(request: Request): Promise<Response>;
+    private handleArchiveCandidates;
+    private handleStorageStats;
+    private handleRunArchive;
+    private handleArchiveStatus;
+    /**
+     * Helper method to get or create event store stats table
+     */
+    private initEventStoreStats;
+    /**
+     * Update stats for a specific event store
+     */
+    updateEventStoreStats(eventStoreName: string, stats: {
+        databaseSizeMB: number;
+        totalEvents: number;
+        archivedEvents: number;
+        lastEventTimestamp?: string;
+    }): Promise<void>;
+    /**
+     * Record an archive operation
+     */
+    recordArchiveOperation(eventStoreName: string, operation: {
+        archivedCount: number;
+        fromPosition: number;
+        toPosition: number;
+        isEmergency: boolean;
+    }): Promise<void>;
+    /**
+     * Periodic alarm handler that collects metrics from all event stores
+     */
+    alarm(): Promise<void>;
+    softDeleteEventStore(eventStoreId: string): Promise<void>;
+    updateEventStoreSettings(eventStoreId: string, updates: {
+        description?: string;
+        settings?: {
+            retentionPeriodDays?: number;
+            maxStreamSizeBytes?: number;
+        };
+    }): Promise<{
         eventStoreID: string;
         eventStoreName: string;
         eventStoreDurableObjectID: string;
         eventBusDurableObjectID: string;
-        eventGlobalIndexDurableObjectID: string;
-    } & Disposable>;
-    getEventStoreDatabaseSizes: (eventStoreName: string) => Promise<{
-        eventStoreDatabaseSize: number;
-        eventBusDatabaseSize: number;
-        eventGlobalIndexDatabaseSize: number;
-    } & Disposable>;
-};
-
-declare const getDOEventStore: (eventStoreId: string, env: Env) => EventStore;
-
-declare const getDOEventBus: (eventBusId: string, env: Env) => {
-    subscribe: (eventFilter: EventFilter, subscriberId: string, subscription: SubscriberTypeConfig) => Promise<void>;
-    unsubscribe: (eventFilter: EventFilter, subscriberId: string) => Promise<void>;
-};
+        description?: string;
+        settings?: {
+            retentionPeriodDays?: number;
+            maxStreamSizeBytes?: number;
+        };
+        created: string;
+    }>;
+}
 
-interface EventStoreWebSocketRouteConfig {
-    managerId: string;
-    path?: string;
+interface ConnectionListOptions {
+    limit?: number;
+    offset?: number;
+    clientId?: string;
+}
+interface ConnectionListResult {
+    connections: Array<{
+        connectionId: string;
+        clientId: string;
+        connectedAt: string;
+        ipAddress?: string;
+        userAgent?: string;
+        filter?: string;
+    }>;
+    totalCount: number;
+    eventStoreId: string;
+}
+interface CloseConnectionResult {
+    success: boolean;
+    message: string;
+    connectionsClosedCount: number;
+}
+declare class WebSocketManagerDurableObject extends DurableObject<Env> {
+    sql: SqlStorage;
+    constructor(ctx: DurableObjectState, env: Env);
+    private initializeTables;
+    initialize(eventStoreID: string): Promise<void>;
+    private subscribeToEventStore;
+    fetch(request: Request): Promise<Response>;
+    private findWebSocketsByClientId;
+    listConnections(options?: ConnectionListOptions): Promise<ConnectionListResult>;
+    closeClientConnections(clientId: string, reason?: string): Promise<CloseConnectionResult>;
+    private matchEventWithFilter;
+    deliverEventToClient(clientId: string, event: EventMessage): Promise<void>;
+    broadcastEvent(event: EventMessage): Promise<void>;
+    webSocketClose(ws: WebSocket, _code: number, reason: string, _wasClean: boolean): Promise<void>;
 }
-declare function createEventStoreWebSocketRoute(config: EventStoreWebSocketRouteConfig): {
-    app: OpenAPIHono<{
-        Bindings: Env;
-    }, {}, "/">;
-    getManagerId: () => string;
-};
 
 declare const routes: hono_hono_base.HonoBase<hono.Env, hono_types.MergeSchemaPath<{}, "/api"> & {
     docs: {
@@ -405,8 +1774,21 @@ declare const routes: hono_hono_base.HonoBase<hono.Env, hono_types.MergeSchemaPa
             status: hono_utils_http_status.StatusCode;
         };
     };
+} & {
+    "/api/webhook-test": {
+        $post: {
+            input: {};
+            output: {
+                status: string;
+                received_at: string;
+                event: any;
+            };
+            outputFormat: "json";
+            status: hono_utils_http_status.ContentfulStatusCode;
+        };
+    };
 }, "/api">;
 
 type AppType = typeof routes;
 
-export { type AppType, type BaseSubscriberConfig, type CloudflareWorkflowConfig, type DurableObjectConfig, EventBusDurableObject, type EventFilter, EventGlobalIndexDurableObject, EventStoreDurableObject, type Env as EventStoreEnv, EventStoreManagerDurableObject, EventStreamDurableObject, type EventType, type QueueConfig, SubscriberType, WebSocketManagerDurableObject, type WebhookConfig, type WildcardPattern, createEventStoreWebSocketRoute, routes as default, getDOEventBus, getDOEventStore, getDOEventStoreManagement };
+export { type AppType, type BaseSubscriberConfig, type CloudflareWorkflowConfig, type DurableObjectConfig, EventBusAPI, EventBusDurableObject, type EventFilter, EventStoreAPI, EventStoreDurableObject, EventStoreManagerDurableObject, type EventType, ManagementAPI, type QueueConfig, SubscriberType, WebSocketManagerDurableObject, WebSocketsAPI, type WebhookConfig, type WildcardPattern, routes as default };