@delta-base/core 1.3.5 → 1.4.0

package/dist/index.d.ts

@@ -81,8 +81,28 @@ declare namespace EventBusAPI {
             earliest: "earliest";
         }>>>;
     }, z.core.$strip>;
+    const UpdateSubscriptionRequestSchema: z.ZodObject<{
+        eventFilter: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodString, z.ZodString, z.ZodString]>, z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodString, z.ZodString, z.ZodString]>>]>>;
+        subscriberConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        retryPolicy: z.ZodOptional<z.ZodObject<{
+            strategy: z.ZodEnum<{
+                fixed: "fixed";
+                exponential: "exponential";
+                linear: "linear";
+            }>;
+            maxAttempts: z.ZodNumber;
+            initialDelayMs: z.ZodNumber;
+            maxDelayMs: z.ZodNumber;
+            multiplier: z.ZodOptional<z.ZodNumber>;
+            jitterPercent: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        status: z.ZodOptional<z.ZodEnum<{
+            ACTIVE: "ACTIVE";
+            SUSPENDED: "SUSPENDED";
+        }>>;
+    }, z.core.$strip>;
     const SubscriptionResponseSchema: z.ZodObject<{
-        subscriptionId: z.ZodString;
+        subscriberId: z.ZodString;
         status: z.ZodEnum<{
             ACTIVE: "ACTIVE";
             SUSPENDED: "SUSPENDED";
@@ -98,7 +118,6 @@ declare namespace EventBusAPI {
         }, z.core.$strip>>;
         eventStoreName: z.ZodString;
         eventFilter: z.ZodString;
-        subscriberId: z.ZodString;
         subscriberType: z.ZodEnum<{
             durable_object: "durable_object";
             webhook: "webhook";
@@ -106,6 +125,7 @@ declare namespace EventBusAPI {
             cloudflare_workflow: "cloudflare_workflow";
             websocket: "websocket";
         }>;
+        subscriberConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
         createdAt: z.ZodString;
         updatedAt: z.ZodString;
         lastProcessedEventGlobalPosition: z.ZodOptional<z.ZodNumber>;
@@ -114,7 +134,7 @@ declare namespace EventBusAPI {
     }, z.core.$strip>;
     const SubscriptionListResponseSchema: z.ZodObject<{
         subscriptions: z.ZodArray<z.ZodObject<{
-            subscriptionId: z.ZodString;
+            subscriberId: z.ZodString;
             status: z.ZodEnum<{
                 ACTIVE: "ACTIVE";
                 SUSPENDED: "SUSPENDED";
@@ -130,7 +150,6 @@ declare namespace EventBusAPI {
             }, z.core.$strip>>;
             eventStoreName: z.ZodString;
             eventFilter: z.ZodString;
-            subscriberId: z.ZodString;
             subscriberType: z.ZodEnum<{
                 durable_object: "durable_object";
                 webhook: "webhook";
@@ -138,6 +157,7 @@ declare namespace EventBusAPI {
                 cloudflare_workflow: "cloudflare_workflow";
                 websocket: "websocket";
             }>;
+            subscriberConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
             createdAt: z.ZodString;
             updatedAt: z.ZodString;
             lastProcessedEventGlobalPosition: z.ZodOptional<z.ZodNumber>;
@@ -222,11 +242,10 @@ declare namespace EventBusAPI {
                     };
                 };
                 output: {
-                    subscriptionId: string;
+                    subscriberId: string;
                     status: "ACTIVE" | "SUSPENDED" | "ERROR" | "INITIALIZING" | "DELETED";
                     eventStoreName: string;
                     eventFilter: string;
-                    subscriberId: string;
                     subscriberType: "durable_object" | "webhook" | "queue" | "cloudflare_workflow" | "websocket";
                     createdAt: string;
                     updatedAt: string;
@@ -236,6 +255,9 @@ declare namespace EventBusAPI {
                         retryCount?: number | undefined;
                         nextRetryAt?: string | undefined;
                     } | undefined;
+                    subscriberConfig?: {
+                        [x: string]: any;
+                    } | undefined;
                     lastProcessedEventGlobalPosition?: number | undefined;
                     isExistingSubscription?: boolean | undefined;
                     message?: string | undefined;
@@ -533,12 +555,12 @@ declare namespace EventBusAPI {
             };
         };
     } & {
-        "/event-stores/:eventStoreName/subscriptions/:subscriptionId": {
+        "/event-stores/:eventStoreName/subscriptions/:subscriberId": {
             $delete: {
                 input: {
                     param: {
                         eventStoreName: string;
-                        subscriptionId: string;
+                        subscriberId: string;
                     };
                 };
                 output: {
@@ -554,7 +576,7 @@ declare namespace EventBusAPI {
                 input: {
                     param: {
                         eventStoreName: string;
-                        subscriptionId: string;
+                        subscriberId: string;
                     };
                 };
                 output: {
@@ -570,7 +592,7 @@ declare namespace EventBusAPI {
                 input: {
                     param: {
                         eventStoreName: string;
-                        subscriptionId: string;
+                        subscriberId: string;
                     };
                 };
                 output: {
@@ -586,7 +608,7 @@ declare namespace EventBusAPI {
                 input: {
                     param: {
                         eventStoreName: string;
-                        subscriptionId: string;
+                        subscriberId: string;
                     };
                 };
                 output: {
@@ -680,11 +702,10 @@ declare namespace EventBusAPI {
                 };
                 output: {
                     subscriptions: {
-                        subscriptionId: string;
+                        subscriberId: string;
                         status: "ACTIVE" | "SUSPENDED" | "ERROR" | "INITIALIZING" | "DELETED";
                         eventStoreName: string;
                         eventFilter: string;
-                        subscriberId: string;
                         subscriberType: "durable_object" | "webhook" | "queue" | "cloudflare_workflow" | "websocket";
                         createdAt: string;
                         updatedAt: string;
@@ -694,6 +715,9 @@ declare namespace EventBusAPI {
                             retryCount?: number | undefined;
                             nextRetryAt?: string | undefined;
                         } | undefined;
+                        subscriberConfig?: {
+                            [x: string]: any;
+                        } | undefined;
                         lastProcessedEventGlobalPosition?: number | undefined;
                         isExistingSubscription?: boolean | undefined;
                         message?: string | undefined;
@@ -705,20 +729,115 @@ declare namespace EventBusAPI {
             };
         };
     } & {
-        "/event-stores/:eventStoreName/subscriptions/:subscriptionId": {
+        "/event-stores/:eventStoreName/subscriptions/:subscriberId": {
             $get: {
                 input: {
                     param: {
                         eventStoreName: string;
-                        subscriptionId: string;
+                        subscriberId: string;
                     };
                 };
                 output: {
-                    subscriptionId: string;
+                    subscriberId: string;
                     status: "ACTIVE" | "SUSPENDED" | "ERROR" | "INITIALIZING" | "DELETED";
                     eventStoreName: string;
                     eventFilter: string;
+                    subscriberType: "durable_object" | "webhook" | "queue" | "cloudflare_workflow" | "websocket";
+                    createdAt: string;
+                    updatedAt: string;
+                    statusDetails?: {
+                        lastError?: string | undefined;
+                        lastErrorAt?: string | undefined;
+                        retryCount?: number | undefined;
+                        nextRetryAt?: string | undefined;
+                    } | undefined;
+                    subscriberConfig?: {
+                        [x: string]: any;
+                    } | undefined;
+                    lastProcessedEventGlobalPosition?: number | undefined;
+                    isExistingSubscription?: boolean | undefined;
+                    message?: string | undefined;
+                };
+                outputFormat: "json";
+                status: 200;
+            } | {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        subscriberId: string;
+                    };
+                };
+                output: {
+                    error: string;
+                    message: string;
+                    details?: {
+                        [x: string]: any;
+                    } | undefined;
+                };
+                outputFormat: "json";
+                status: 401;
+            } | {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        subscriberId: string;
+                    };
+                };
+                output: {
+                    error: string;
+                    message: string;
+                    details?: {
+                        [x: string]: any;
+                    } | undefined;
+                };
+                outputFormat: "json";
+                status: 404;
+            } | {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        subscriberId: string;
+                    };
+                };
+                output: {
+                    error: string;
+                    message: string;
+                    details?: {
+                        [x: string]: any;
+                    } | undefined;
+                };
+                outputFormat: "json";
+                status: 500;
+            };
+        };
+    } & {
+        "/event-stores/:eventStoreName/subscriptions/:subscriberId": {
+            $patch: {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        subscriberId: string;
+                    };
+                } & {
+                    json: {
+                        eventFilter?: string | string[] | undefined;
+                        subscriberConfig?: Record<string, unknown> | undefined;
+                        retryPolicy?: {
+                            strategy: "fixed" | "exponential" | "linear";
+                            maxAttempts: number;
+                            initialDelayMs: number;
+                            maxDelayMs: number;
+                            multiplier?: number | undefined;
+                            jitterPercent?: number | undefined;
+                        } | undefined;
+                        status?: "ACTIVE" | "SUSPENDED" | undefined;
+                    };
+                };
+                output: {
                     subscriberId: string;
+                    status: "ACTIVE" | "SUSPENDED" | "ERROR" | "INITIALIZING" | "DELETED";
+                    eventStoreName: string;
+                    eventFilter: string;
                     subscriberType: "durable_object" | "webhook" | "queue" | "cloudflare_workflow" | "websocket";
                     createdAt: string;
                     updatedAt: string;
@@ -728,6 +847,9 @@ declare namespace EventBusAPI {
                         retryCount?: number | undefined;
                         nextRetryAt?: string | undefined;
                     } | undefined;
+                    subscriberConfig?: {
+                        [x: string]: any;
+                    } | undefined;
                     lastProcessedEventGlobalPosition?: number | undefined;
                     isExistingSubscription?: boolean | undefined;
                     message?: string | undefined;
@@ -738,7 +860,51 @@ declare namespace EventBusAPI {
                 input: {
                     param: {
                         eventStoreName: string;
-                        subscriptionId: string;
+                        subscriberId: string;
+                    };
+                } & {
+                    json: {
+                        eventFilter?: string | string[] | undefined;
+                        subscriberConfig?: Record<string, unknown> | undefined;
+                        retryPolicy?: {
+                            strategy: "fixed" | "exponential" | "linear";
+                            maxAttempts: number;
+                            initialDelayMs: number;
+                            maxDelayMs: number;
+                            multiplier?: number | undefined;
+                            jitterPercent?: number | undefined;
+                        } | undefined;
+                        status?: "ACTIVE" | "SUSPENDED" | undefined;
+                    };
+                };
+                output: {
+                    error: string;
+                    message: string;
+                    details?: {
+                        [x: string]: any;
+                    } | undefined;
+                };
+                outputFormat: "json";
+                status: 400;
+            } | {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        subscriberId: string;
+                    };
+                } & {
+                    json: {
+                        eventFilter?: string | string[] | undefined;
+                        subscriberConfig?: Record<string, unknown> | undefined;
+                        retryPolicy?: {
+                            strategy: "fixed" | "exponential" | "linear";
+                            maxAttempts: number;
+                            initialDelayMs: number;
+                            maxDelayMs: number;
+                            multiplier?: number | undefined;
+                            jitterPercent?: number | undefined;
+                        } | undefined;
+                        status?: "ACTIVE" | "SUSPENDED" | undefined;
                     };
                 };
                 output: {
@@ -754,7 +920,21 @@ declare namespace EventBusAPI {
                 input: {
                     param: {
                         eventStoreName: string;
-                        subscriptionId: string;
+                        subscriberId: string;
+                    };
+                } & {
+                    json: {
+                        eventFilter?: string | string[] | undefined;
+                        subscriberConfig?: Record<string, unknown> | undefined;
+                        retryPolicy?: {
+                            strategy: "fixed" | "exponential" | "linear";
+                            maxAttempts: number;
+                            initialDelayMs: number;
+                            maxDelayMs: number;
+                            multiplier?: number | undefined;
+                            jitterPercent?: number | undefined;
+                        } | undefined;
+                        status?: "ACTIVE" | "SUSPENDED" | undefined;
                     };
                 };
                 output: {
@@ -770,7 +950,21 @@ declare namespace EventBusAPI {
                 input: {
                     param: {
                         eventStoreName: string;
-                        subscriptionId: string;
+                        subscriberId: string;
+                    };
+                } & {
+                    json: {
+                        eventFilter?: string | string[] | undefined;
+                        subscriberConfig?: Record<string, unknown> | undefined;
+                        retryPolicy?: {
+                            strategy: "fixed" | "exponential" | "linear";
+                            maxAttempts: number;
+                            initialDelayMs: number;
+                            maxDelayMs: number;
+                            multiplier?: number | undefined;
+                            jitterPercent?: number | undefined;
+                        } | undefined;
+                        status?: "ACTIVE" | "SUSPENDED" | undefined;
                     };
                 };
                 output: {
@@ -782,6 +976,36 @@ declare namespace EventBusAPI {
                 };
                 outputFormat: "json";
                 status: 500;
+            } | {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        subscriberId: string;
+                    };
+                } & {
+                    json: {
+                        eventFilter?: string | string[] | undefined;
+                        subscriberConfig?: Record<string, unknown> | undefined;
+                        retryPolicy?: {
+                            strategy: "fixed" | "exponential" | "linear";
+                            maxAttempts: number;
+                            initialDelayMs: number;
+                            maxDelayMs: number;
+                            multiplier?: number | undefined;
+                            jitterPercent?: number | undefined;
+                        } | undefined;
+                        status?: "ACTIVE" | "SUSPENDED" | undefined;
+                    };
+                };
+                output: {
+                    error: string;
+                    message: string;
+                    details?: {
+                        [x: string]: any;
+                    } | undefined;
+                };
+                outputFormat: "json";
+                status: 409;
             };
         };
     }, "/">;
@@ -871,7 +1095,7 @@ declare namespace EventStoreAPI {
         transactionId: z.ZodOptional<z.ZodString>;
         fromPosition: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
         toPosition: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
-        fromDate: z.ZodOptional<z.ZodString>;
+        fromDate: z.ZodOptional<z.ZodISODateTime>;
         toDate: z.ZodOptional<z.ZodString>;
         phase: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
         includeArchived: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<boolean, string>>, z.ZodBoolean>>;
@@ -894,8 +1118,8 @@ declare namespace EventStoreAPI {
         streamIdPattern: z.ZodOptional<z.ZodString>;
         minPosition: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
         maxPosition: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
-        fromDate: z.ZodOptional<z.ZodString>;
-        toDate: z.ZodOptional<z.ZodString>;
+        fromDate: z.ZodOptional<z.ZodISODateTime>;
+        toDate: z.ZodOptional<z.ZodISODateTime>;
         includeArchived: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<boolean, string>>, z.ZodBoolean>>;
         includeMetadata: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<boolean, string>>, z.ZodBoolean>>;
         limit: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
@@ -966,6 +1190,58 @@ declare namespace EventStoreAPI {
             hasMore: z.ZodBoolean;
         }, z.core.$strip>;
     }, z.core.$strip>;
+    export const OutboxDlqEntrySchema: z.ZodObject<{
+        id: z.ZodNumber;
+        streamId: z.ZodString;
+        streamPosition: z.ZodNumber;
+        globalPosition: z.ZodNumber;
+        messageId: z.ZodString;
+        messageType: z.ZodString;
+        messageData: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        messageMetadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        messageSchemaVersion: z.ZodString;
+        transactionId: z.ZodString;
+        totalAttempts: z.ZodNumber;
+        lastError: z.ZodNullable<z.ZodString>;
+        dlqReason: z.ZodEnum<{
+            max_publish_retries: "max_publish_retries";
+            eventbus_unreachable: "eventbus_unreachable";
+            manual: "manual";
+            subscriber_deleted: "subscriber_deleted";
+        }>;
+        originalCreatedAt: z.ZodString;
+        movedToDlqAt: z.ZodString;
+    }, z.core.$strip>;
+    export const OutboxDlqListResponseSchema: z.ZodObject<{
+        entries: z.ZodArray<z.ZodObject<{
+            id: z.ZodNumber;
+            streamId: z.ZodString;
+            streamPosition: z.ZodNumber;
+            globalPosition: z.ZodNumber;
+            messageId: z.ZodString;
+            messageType: z.ZodString;
+            messageData: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            messageMetadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            messageSchemaVersion: z.ZodString;
+            transactionId: z.ZodString;
+            totalAttempts: z.ZodNumber;
+            lastError: z.ZodNullable<z.ZodString>;
+            dlqReason: z.ZodEnum<{
+                max_publish_retries: "max_publish_retries";
+                eventbus_unreachable: "eventbus_unreachable";
+                manual: "manual";
+                subscriber_deleted: "subscriber_deleted";
+            }>;
+            originalCreatedAt: z.ZodString;
+            movedToDlqAt: z.ZodString;
+        }, z.core.$strip>>;
+        pagination: z.ZodObject<{
+            limit: z.ZodNumber;
+            offset: z.ZodNumber;
+            total: z.ZodOptional<z.ZodNumber>;
+            hasMore: z.ZodBoolean;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
     export type QueryEventsParams = z.infer<typeof QueryEventsParamsSchema>;
     export type QueryStreamsParams = z.infer<typeof QueryStreamsParamsSchema>;
     export type QueryEventsResponse = {
@@ -975,6 +1251,7 @@ declare namespace EventStoreAPI {
     export type QueryStreamsResponse = z.infer<typeof QueryStreamsResponseSchema>;
     export type Stream = z.infer<typeof StreamSchema>;
     export type ReadEvent = z.infer<typeof EventSchema>;
+    export type OutboxDlqListResponse = z.infer<typeof OutboxDlqListResponseSchema>;
     export const routes: OpenAPIHono<{
         Bindings: Env;
         Variables: {
@@ -1617,79 +1894,251 @@ declare namespace EventStoreAPI {
                 status: 200;
             };
         };
-    }, "/">;
-    export {  };
-}
-
-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>;
-        }, z.core.$strip>>;
-        created: z.ZodString;
-    }, z.core.$strip>;
-    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>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-    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>;
-            }, z.core.$strip>>;
-            created: z.ZodString;
-        }, z.core.$strip>>;
-        totalCount: z.ZodNumber;
-    }, z.core.$strip>;
-    const EventStoreDatabaseSizesSchema: z.ZodObject<{
-        eventStoreDatabaseSize: z.ZodNumber;
-        eventBusDatabaseSize: z.ZodNumber;
-        totalSize: z.ZodNumber;
-    }, z.core.$strip>;
-    const EventStoreDetailsResponseSchema: 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>;
-        }, z.core.$strip>>;
-        created: z.ZodString;
-        streams: z.ZodOptional<z.ZodObject<{
-            count: z.ZodNumber;
-            totalEvents: z.ZodNumber;
-        }, z.core.$strip>>;
-        databaseSizes: z.ZodOptional<z.ZodObject<{
-            eventStoreDatabaseSize: z.ZodNumber;
-            eventBusDatabaseSize: z.ZodNumber;
-            totalSize: z.ZodNumber;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-    const ErrorResponseSchema: z.ZodObject<{
-        error: z.ZodString;
-        message: z.ZodString;
-        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    }, z.core.$strip>;
-    const routes: OpenAPIHono<{
-        Bindings: Env;
+    } & {
+        "/event-stores/:eventStoreName/outbox-dlq": {
+            $get: {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                    };
+                } & {
+                    query: {
+                        limit?: string | undefined;
+                        offset?: string | undefined;
+                    };
+                };
+                output: {
+                    error: "UNAUTHORIZED";
+                    message: "Unauthorized: Organization ID not found in authentication context";
+                };
+                outputFormat: "json";
+                status: 401;
+            } | {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                    };
+                } & {
+                    query: {
+                        limit?: string | undefined;
+                        offset?: string | undefined;
+                    };
+                };
+                output: {
+                    entries: {
+                        id: number;
+                        streamId: string;
+                        streamPosition: number;
+                        globalPosition: number;
+                        messageId: string;
+                        messageType: string;
+                        messageData: {
+                            [x: string]: hono_utils_types.JSONValue;
+                        };
+                        messageMetadata: {
+                            [x: string]: hono_utils_types.JSONValue;
+                        };
+                        messageSchemaVersion: string;
+                        transactionId: string;
+                        totalAttempts: number;
+                        lastError: string | null;
+                        dlqReason: "max_publish_retries" | "eventbus_unreachable" | "manual" | "subscriber_deleted";
+                        originalCreatedAt: string;
+                        movedToDlqAt: string;
+                    }[];
+                    pagination: {
+                        limit: number;
+                        offset: number;
+                        hasMore: boolean;
+                        total?: number | undefined;
+                    };
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        };
+    } & {
+        "/event-stores/:eventStoreName/outbox-dlq/:entryId/retry": {
+            $post: {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        entryId: string;
+                    };
+                };
+                output: {
+                    error: "UNAUTHORIZED";
+                    message: "Unauthorized: Organization ID not found in authentication context";
+                };
+                outputFormat: "json";
+                status: 401;
+            } | {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        entryId: string;
+                    };
+                };
+                output: {
+                    success: boolean;
+                    entryId: number;
+                };
+                outputFormat: "json";
+                status: 200;
+            } | {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        entryId: string;
+                    };
+                };
+                output: {
+                    error: "Not found";
+                };
+                outputFormat: "json";
+                status: 404;
+            };
+        };
+    } & {
+        "/event-stores/:eventStoreName/outbox-dlq/retry-all": {
+            $post: {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                    };
+                };
+                output: {
+                    error: "UNAUTHORIZED";
+                    message: "Unauthorized: Organization ID not found in authentication context";
+                };
+                outputFormat: "json";
+                status: 401;
+            } | {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                    };
+                };
+                output: {
+                    success: boolean;
+                    count: number;
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        };
+    } & {
+        "/event-stores/:eventStoreName/outbox-dlq/:entryId": {
+            $delete: {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        entryId: string;
+                    };
+                };
+                output: {};
+                outputFormat: string;
+                status: 204;
+            } | {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        entryId: string;
+                    };
+                };
+                output: {
+                    error: "UNAUTHORIZED";
+                    message: "Unauthorized: Organization ID not found in authentication context";
+                };
+                outputFormat: "json";
+                status: 401;
+            } | {
+                input: {
+                    param: {
+                        eventStoreName: string;
+                        entryId: string;
+                    };
+                };
+                output: {
+                    error: "Not found";
+                };
+                outputFormat: "json";
+                status: 404;
+            };
+        };
+    }, "/">;
+    export {  };
+}
+
+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>;
+        }, z.core.$strip>>;
+        created: z.ZodString;
+    }, z.core.$strip>;
+    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>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    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>;
+            }, z.core.$strip>>;
+            created: z.ZodString;
+        }, z.core.$strip>>;
+        totalCount: z.ZodNumber;
+    }, z.core.$strip>;
+    const EventStoreDatabaseSizesSchema: z.ZodObject<{
+        eventStoreDatabaseSize: z.ZodNumber;
+        eventBusDatabaseSize: z.ZodNumber;
+        totalSize: z.ZodNumber;
+    }, z.core.$strip>;
+    const EventStoreDetailsResponseSchema: 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>;
+        }, z.core.$strip>>;
+        created: z.ZodString;
+        streams: z.ZodOptional<z.ZodObject<{
+            count: z.ZodNumber;
+            totalEvents: z.ZodNumber;
+        }, z.core.$strip>>;
+        databaseSizes: z.ZodOptional<z.ZodObject<{
+            eventStoreDatabaseSize: z.ZodNumber;
+            eventBusDatabaseSize: z.ZodNumber;
+            totalSize: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    const ErrorResponseSchema: z.ZodObject<{
+        error: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>;
+    const routes: OpenAPIHono<{
+        Bindings: Env;
         Variables: {
             orgId: string;
         };
@@ -2340,6 +2789,16 @@ declare namespace WebSocketsAPI {
     }, "/">;
 }
 
+type RetryStrategy = 'exponential' | 'linear' | 'fixed';
+interface RetryPolicy {
+    strategy: RetryStrategy;
+    maxAttempts: number;
+    initialDelayMs: number;
+    maxDelayMs: number;
+    multiplier?: number;
+    jitterPercent?: number;
+}
+
 type WildcardPattern = '*' | `${string}.*` | `*.${string}` | `${string}.*${string}`;
 type EventType = string;
 type EventFilter = EventType | EventType[] | WildcardPattern;
@@ -2396,9 +2855,6 @@ type SubscriberTypeConfig = {
     type: SubscriberType.WebSocket;
     config: WebSocketConfig;
 };
-interface Env$1 {
-    [key: string]: DurableObjectNamespace | Workflow;
-}
 interface EventMessage {
     event_id: string;
     event_type: string;
@@ -2416,6 +2872,8 @@ interface SubscriptionListOptions {
     eventFilter?: string;
     limit?: number;
     offset?: number;
+    /** When true (default), hides platform-internal subscriptions (e.g. ws-manager). */
+    hideInternal?: boolean;
 }
 declare enum SubscriptionStatus {
     ACTIVE = "ACTIVE",
@@ -2440,11 +2898,11 @@ interface StatusDetails {
     };
 }
 interface Subscription {
-    id: string;
-    eventFilter: string;
     subscriberId: string;
+    eventFilter: string;
     subscriberType: SubscriberType;
     subscriberConfig: string;
+    subscriberDoId?: string | null;
     status: SubscriptionStatus;
     statusDetails?: StatusDetails;
     lastProcessedEventGlobalPosition: number;
@@ -2456,7 +2914,7 @@ interface SubscriptionResult {
     isExistingSubscription: boolean;
     message: string;
 }
-declare class EventBusDurableObject extends DurableObject<Env$1> {
+declare class EventBusDurableObject extends DurableObject<Env> {
     private readonly BATCH_SIZE;
     private readonly RETRY_DELAY_HOURS;
     /** Maximum messages to process per subscriber per batch (for round-robin fairness) */
@@ -2477,9 +2935,26 @@ declare class EventBusDurableObject extends DurableObject<Env$1> {
      * @private
      */
     private formatDateToISO;
-    constructor(state: DurableObjectState, env: Env$1);
+    constructor(state: DurableObjectState, env: Env);
     private initializeTables;
+    private ensureSubscriberDoColumn;
+    /**
+     * Migrates old subscriptions table schema (id INTEGER PK + UNIQUE(event_filter, subscriber_id))
+     * to new schema (subscriber_id TEXT PK). This is needed because ON CONFLICT(subscriber_id)
+     * requires subscriber_id to be a PK or have a UNIQUE constraint on its own.
+     *
+     * Old DOs created before this migration have the old schema due to CREATE TABLE IF NOT EXISTS
+     * being a no-op when the table already exists.
+     */
+    private migrateSubscriptionsPrimaryKey;
     initialize(eventStoreID: string): void;
+    /**
+     * Ensures the event bus has been initialized
+     * @throws NotFoundError if not initialized
+     * @private
+     */
+    private ensureInitialized;
+    private getEventStoreId;
     /**
      * Check if a webhook subscription with the same configuration already exists
      * @param eventFilter - The event filter pattern to match
@@ -2499,10 +2974,17 @@ declare class EventBusDurableObject extends DurableObject<Env$1> {
     subscribe(eventFilter: EventFilter, subscriberId: string, subscription: SubscriberTypeConfig, initialPosition?: InitialPosition): Promise<SubscriptionResult>;
     private validateSubscriberConfig;
     private updateSubscriptionStatus;
+    private initializeSubscriberDurableObject;
     unsubscribe(subscriberId: string): Promise<void>;
+    updateSubscription(subscriberId: string, updates: {
+        eventFilter?: string;
+        subscriberConfig?: Record<string, unknown>;
+        retryPolicy?: RetryPolicy;
+        status?: 'ACTIVE' | 'SUSPENDED';
+    }): Promise<Subscription>;
     getSubscriptions(options?: SubscriptionListOptions): Promise<Subscription[]>;
     getSubscriptionsCount(options?: Omit<SubscriptionListOptions, 'limit' | 'offset'>): Promise<number>;
-    getSubscription(id: string): Promise<Subscription | null>;
+    getSubscription(subscriberId: string): Promise<Subscription | null>;
     publish(events: {
         event_id: string;
         event_type: string;
@@ -2564,6 +3046,48 @@ declare class EventBusDurableObject extends DurableObject<Env$1> {
         pending_messages: number;
     };
     private validateEventFilter;
+    /**
+     * Validates the subscriber ID format.
+     * Must be 1-128 characters, alphanumeric with hyphens and underscores only.
+     * This is compatible with nanoid() default output (A-Za-z0-9_-) and
+     * is URL-safe (no percent-encoding needed in path segments).
+     * @param subscriberId - The subscriber ID to validate
+     * @throws ValidationError if the subscriber ID is invalid
+     * @private
+     */
+    private validateSubscriberId;
+    /**
+     * Checks that the subscriber ID is not already in use with a different event filter.
+     * Enforces subscriber ID uniqueness within an event bus — each subscriber ID
+     * maps to exactly one subscription. Re-subscribing with the same (subscriberId, eventFilter)
+     * pair is allowed (idempotent upsert).
+     * @param subscriberId - The subscriber ID to check
+     * @param eventFilter - The event filter for the new subscription
+     * @throws ValidationError if the subscriber ID is already in use with a different event filter
+     * @private
+     */
+    private ensureSubscriberIdUnique;
+    /**
+     * Migrates all unmigrated subscriptions to SubscriberDOs.
+     * This method is idempotent - running it multiple times is safe.
+     */
+    migrateAllSubscriptions(): Promise<{
+        subscriptionsMigrated: number;
+        outboxEntriesMoved: number;
+    }>;
+    /**
+     * Gets migration status for this EventBusDO
+     */
+    getMigrationStatus(): Promise<{
+        totalSubscriptions: number;
+        migratedCount: number;
+        legacyCount: number;
+        legacyOutboxCount: number;
+    }>;
+    /**
+     * Reconstructs an EventMessage from a subscriptions_outbox row
+     */
+    private reconstructEventFromOutbox;
 }
 
 /**
@@ -2638,6 +3162,32 @@ type QueryStreamsResult = {
         hasMore: boolean;
     };
 };
+type OutboxDlqEntry = {
+    id: number;
+    streamId: string;
+    streamPosition: number;
+    globalPosition: number;
+    messageId: string;
+    messageType: string;
+    messageData: Record<string, unknown>;
+    messageMetadata: Record<string, unknown>;
+    messageSchemaVersion: string;
+    transactionId: string;
+    totalAttempts: number;
+    lastError: string | null;
+    dlqReason: 'max_publish_retries' | 'eventbus_unreachable' | 'manual' | 'subscriber_deleted';
+    originalCreatedAt: string;
+    movedToDlqAt: string;
+};
+type OutboxDlqResult = {
+    entries: OutboxDlqEntry[];
+    pagination: {
+        limit: number;
+        offset: number;
+        total: number;
+        hasMore: boolean;
+    };
+};
 /**
  * A durable object implementation of an event store.
  * Handles event persistence, archiving, and event bus integration.
@@ -2652,10 +3202,6 @@ declare class EventStoreDurableObject extends DurableObject<Env> {
     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;
     /** Tracks if alarm handler is currently active to prevent concurrency violations */
     private isAlarmActive;
     /** Tracks if we're in the process of scheduling an alarm to prevent race conditions */
@@ -2678,6 +3224,12 @@ declare class EventStoreDurableObject extends DurableObject<Env> {
      * @param eventStoreID - The ID to assign to this event store
      */
     initialize(eventStoreID: string): void;
+    /**
+     * Ensures the event store has been initialized
+     * @throws NotFoundError if not initialized
+     * @private
+     */
+    private ensureInitialized;
     /**
      * Appends events to a stream with optimistic concurrency control
      * @param streamId - The unique identifier for the stream
@@ -2745,12 +3297,21 @@ declare class EventStoreDurableObject extends DurableObject<Env> {
      */
     private formatDateToISO;
     /**
-     * Maps a database row to an event object
+     * Converts ISO 8601 date string to SQLite DATETIME format for query comparisons
+     * This ensures backward compatibility with existing data stored in SQLite format
+     * @param isoDate - ISO 8601 date string like "2025-12-02T05:00:00.000Z"
+     * @returns SQLite DATETIME format string like "2025-12-02 05:00:00"
+     * @private
+     */
+    private formatDateToSQLite;
+    /**
+     * 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;
+    private mapRowToOutboxDlqEntry;
     /**
      * Gets the current version of a stream
      * @param streamId - The stream to get the version for
@@ -2812,6 +3373,13 @@ declare class EventStoreDurableObject extends DurableObject<Env> {
      * @private
      */
     private processPendingEventBusMessages;
+    listOutboxDlq(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<OutboxDlqResult>;
+    retryOutboxDlqEntry(entryId: number): Promise<boolean>;
+    retryAllOutboxDlq(): Promise<number>;
+    deleteOutboxDlqEntry(entryId: number): Promise<boolean>;
     /**
      * Gets the current database size in bytes (consistent with EventBusDO)
      * @returns Database size in bytes
@@ -3064,6 +3632,42 @@ declare class EventStoreManagerDurableObject extends DurableObject<Env> {
     }>;
 }
 
+interface SubscriberInitConfig {
+    subscriberId: string;
+    subscriberType: SubscriberType;
+    subscriberConfig: SubscriberTypeConfig['config'];
+    eventFilter: string;
+    retryPolicy: RetryPolicy;
+}
+type SubscriberStatus = 'ACTIVE' | 'PAUSED' | 'ERROR';
+declare class SubscriberDurableObject extends DurableObject<Env> {
+    private readonly BATCH_SIZE;
+    private readonly MAX_BATCHES_PER_ALARM;
+    private isAlarmActive;
+    private isSchedulingAlarm;
+    sql: SqlStorage;
+    constructor(state: DurableObjectState, env: Env);
+    private initializeTables;
+    initialize(config: SubscriberInitConfig): void;
+    setCursor(position: number): void;
+    enqueue(events: EventMessage[]): Promise<void>;
+    private requestAlarm;
+    private getConfigRow;
+    private getSubscriberStatus;
+    private getRetryPolicy;
+    private getSubscriberConfig;
+    updateStatus(status: SubscriberStatus, _error?: string): void;
+    private getReadyOutboxBatch;
+    private getNextAlarmTime;
+    private scheduleNextAlarm;
+    private reconstructEvent;
+    private markEventDelivered;
+    private moveToDlq;
+    private updateRetryState;
+    private deliverEvent;
+    alarm(): Promise<void>;
+}
+
 interface ConnectionListOptions {
     limit?: number;
     offset?: number;
@@ -4180,6 +4784,178 @@ declare const routes: hono_hono_base.HonoBase<{
             status: 200;
         };
     };
+} & {
+    "/event-stores/:eventStoreName/outbox-dlq": {
+        $get: {
+            input: {
+                param: {
+                    eventStoreName: string;
+                };
+            } & {
+                query: {
+                    limit?: string | undefined;
+                    offset?: string | undefined;
+                };
+            };
+            output: {
+                error: "UNAUTHORIZED";
+                message: "Unauthorized: Organization ID not found in authentication context";
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {
+                param: {
+                    eventStoreName: string;
+                };
+            } & {
+                query: {
+                    limit?: string | undefined;
+                    offset?: string | undefined;
+                };
+            };
+            output: {
+                entries: {
+                    id: number;
+                    streamId: string;
+                    streamPosition: number;
+                    globalPosition: number;
+                    messageId: string;
+                    messageType: string;
+                    messageData: {
+                        [x: string]: hono_utils_types.JSONValue;
+                    };
+                    messageMetadata: {
+                        [x: string]: hono_utils_types.JSONValue;
+                    };
+                    messageSchemaVersion: string;
+                    transactionId: string;
+                    totalAttempts: number;
+                    lastError: string | null;
+                    dlqReason: "max_publish_retries" | "eventbus_unreachable" | "manual" | "subscriber_deleted";
+                    originalCreatedAt: string;
+                    movedToDlqAt: string;
+                }[];
+                pagination: {
+                    limit: number;
+                    offset: number;
+                    hasMore: boolean;
+                    total?: number | undefined;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/event-stores/:eventStoreName/outbox-dlq/:entryId/retry": {
+        $post: {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    entryId: string;
+                };
+            };
+            output: {
+                error: "UNAUTHORIZED";
+                message: "Unauthorized: Organization ID not found in authentication context";
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    entryId: string;
+                };
+            };
+            output: {
+                success: boolean;
+                entryId: number;
+            };
+            outputFormat: "json";
+            status: 200;
+        } | {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    entryId: string;
+                };
+            };
+            output: {
+                error: "Not found";
+            };
+            outputFormat: "json";
+            status: 404;
+        };
+    };
+} & {
+    "/event-stores/:eventStoreName/outbox-dlq/retry-all": {
+        $post: {
+            input: {
+                param: {
+                    eventStoreName: string;
+                };
+            };
+            output: {
+                error: "UNAUTHORIZED";
+                message: "Unauthorized: Organization ID not found in authentication context";
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {
+                param: {
+                    eventStoreName: string;
+                };
+            };
+            output: {
+                success: boolean;
+                count: number;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/event-stores/:eventStoreName/outbox-dlq/:entryId": {
+        $delete: {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    entryId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 204;
+        } | {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    entryId: string;
+                };
+            };
+            output: {
+                error: "UNAUTHORIZED";
+                message: "Unauthorized: Organization ID not found in authentication context";
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    entryId: string;
+                };
+            };
+            output: {
+                error: "Not found";
+            };
+            outputFormat: "json";
+            status: 404;
+        };
+    };
 }, "/api"> | hono_types.MergeSchemaPath<{
     "/event-stores/:eventStoreName/subscribe": {
         $post: {
@@ -4246,11 +5022,10 @@ declare const routes: hono_hono_base.HonoBase<{
                 };
             };
             output: {
-                subscriptionId: string;
+                subscriberId: string;
                 status: "ACTIVE" | "SUSPENDED" | "ERROR" | "INITIALIZING" | "DELETED";
                 eventStoreName: string;
                 eventFilter: string;
-                subscriberId: string;
                 subscriberType: "durable_object" | "webhook" | "queue" | "cloudflare_workflow" | "websocket";
                 createdAt: string;
                 updatedAt: string;
@@ -4260,6 +5035,9 @@ declare const routes: hono_hono_base.HonoBase<{
                     retryCount?: number | undefined;
                     nextRetryAt?: string | undefined;
                 } | undefined;
+                subscriberConfig?: {
+                    [x: string]: any;
+                } | undefined;
                 lastProcessedEventGlobalPosition?: number | undefined;
                 isExistingSubscription?: boolean | undefined;
                 message?: string | undefined;
@@ -4557,12 +5335,12 @@ declare const routes: hono_hono_base.HonoBase<{
         };
     };
 } & {
-    "/event-stores/:eventStoreName/subscriptions/:subscriptionId": {
+    "/event-stores/:eventStoreName/subscriptions/:subscriberId": {
         $delete: {
             input: {
                 param: {
                     eventStoreName: string;
-                    subscriptionId: string;
+                    subscriberId: string;
                 };
             };
             output: {
@@ -4578,7 +5356,7 @@ declare const routes: hono_hono_base.HonoBase<{
             input: {
                 param: {
                     eventStoreName: string;
-                    subscriptionId: string;
+                    subscriberId: string;
                 };
             };
             output: {
@@ -4594,7 +5372,7 @@ declare const routes: hono_hono_base.HonoBase<{
             input: {
                 param: {
                     eventStoreName: string;
-                    subscriptionId: string;
+                    subscriberId: string;
                 };
             };
             output: {
@@ -4610,7 +5388,7 @@ declare const routes: hono_hono_base.HonoBase<{
             input: {
                 param: {
                     eventStoreName: string;
-                    subscriptionId: string;
+                    subscriberId: string;
                 };
             };
             output: {
@@ -4704,11 +5482,10 @@ declare const routes: hono_hono_base.HonoBase<{
             };
             output: {
                 subscriptions: {
-                    subscriptionId: string;
+                    subscriberId: string;
                     status: "ACTIVE" | "SUSPENDED" | "ERROR" | "INITIALIZING" | "DELETED";
                     eventStoreName: string;
                     eventFilter: string;
-                    subscriberId: string;
                     subscriberType: "durable_object" | "webhook" | "queue" | "cloudflare_workflow" | "websocket";
                     createdAt: string;
                     updatedAt: string;
@@ -4718,6 +5495,9 @@ declare const routes: hono_hono_base.HonoBase<{
                         retryCount?: number | undefined;
                         nextRetryAt?: string | undefined;
                     } | undefined;
+                    subscriberConfig?: {
+                        [x: string]: any;
+                    } | undefined;
                     lastProcessedEventGlobalPosition?: number | undefined;
                     isExistingSubscription?: boolean | undefined;
                     message?: string | undefined;
@@ -4729,20 +5509,115 @@ declare const routes: hono_hono_base.HonoBase<{
         };
     };
 } & {
-    "/event-stores/:eventStoreName/subscriptions/:subscriptionId": {
+    "/event-stores/:eventStoreName/subscriptions/:subscriberId": {
         $get: {
             input: {
                 param: {
                     eventStoreName: string;
-                    subscriptionId: string;
+                    subscriberId: string;
                 };
             };
             output: {
-                subscriptionId: string;
+                subscriberId: string;
                 status: "ACTIVE" | "SUSPENDED" | "ERROR" | "INITIALIZING" | "DELETED";
                 eventStoreName: string;
                 eventFilter: string;
+                subscriberType: "durable_object" | "webhook" | "queue" | "cloudflare_workflow" | "websocket";
+                createdAt: string;
+                updatedAt: string;
+                statusDetails?: {
+                    lastError?: string | undefined;
+                    lastErrorAt?: string | undefined;
+                    retryCount?: number | undefined;
+                    nextRetryAt?: string | undefined;
+                } | undefined;
+                subscriberConfig?: {
+                    [x: string]: any;
+                } | undefined;
+                lastProcessedEventGlobalPosition?: number | undefined;
+                isExistingSubscription?: boolean | undefined;
+                message?: string | undefined;
+            };
+            outputFormat: "json";
+            status: 200;
+        } | {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    subscriberId: string;
+                };
+            };
+            output: {
+                error: string;
+                message: string;
+                details?: {
+                    [x: string]: any;
+                } | undefined;
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    subscriberId: string;
+                };
+            };
+            output: {
+                error: string;
+                message: string;
+                details?: {
+                    [x: string]: any;
+                } | undefined;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    subscriberId: string;
+                };
+            };
+            output: {
+                error: string;
+                message: string;
+                details?: {
+                    [x: string]: any;
+                } | undefined;
+            };
+            outputFormat: "json";
+            status: 500;
+        };
+    };
+} & {
+    "/event-stores/:eventStoreName/subscriptions/:subscriberId": {
+        $patch: {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    subscriberId: string;
+                };
+            } & {
+                json: {
+                    eventFilter?: string | string[] | undefined;
+                    subscriberConfig?: Record<string, unknown> | undefined;
+                    retryPolicy?: {
+                        strategy: "fixed" | "exponential" | "linear";
+                        maxAttempts: number;
+                        initialDelayMs: number;
+                        maxDelayMs: number;
+                        multiplier?: number | undefined;
+                        jitterPercent?: number | undefined;
+                    } | undefined;
+                    status?: "ACTIVE" | "SUSPENDED" | undefined;
+                };
+            };
+            output: {
                 subscriberId: string;
+                status: "ACTIVE" | "SUSPENDED" | "ERROR" | "INITIALIZING" | "DELETED";
+                eventStoreName: string;
+                eventFilter: string;
                 subscriberType: "durable_object" | "webhook" | "queue" | "cloudflare_workflow" | "websocket";
                 createdAt: string;
                 updatedAt: string;
@@ -4752,6 +5627,9 @@ declare const routes: hono_hono_base.HonoBase<{
                     retryCount?: number | undefined;
                     nextRetryAt?: string | undefined;
                 } | undefined;
+                subscriberConfig?: {
+                    [x: string]: any;
+                } | undefined;
                 lastProcessedEventGlobalPosition?: number | undefined;
                 isExistingSubscription?: boolean | undefined;
                 message?: string | undefined;
@@ -4762,7 +5640,51 @@ declare const routes: hono_hono_base.HonoBase<{
             input: {
                 param: {
                     eventStoreName: string;
-                    subscriptionId: string;
+                    subscriberId: string;
+                };
+            } & {
+                json: {
+                    eventFilter?: string | string[] | undefined;
+                    subscriberConfig?: Record<string, unknown> | undefined;
+                    retryPolicy?: {
+                        strategy: "fixed" | "exponential" | "linear";
+                        maxAttempts: number;
+                        initialDelayMs: number;
+                        maxDelayMs: number;
+                        multiplier?: number | undefined;
+                        jitterPercent?: number | undefined;
+                    } | undefined;
+                    status?: "ACTIVE" | "SUSPENDED" | undefined;
+                };
+            };
+            output: {
+                error: string;
+                message: string;
+                details?: {
+                    [x: string]: any;
+                } | undefined;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    subscriberId: string;
+                };
+            } & {
+                json: {
+                    eventFilter?: string | string[] | undefined;
+                    subscriberConfig?: Record<string, unknown> | undefined;
+                    retryPolicy?: {
+                        strategy: "fixed" | "exponential" | "linear";
+                        maxAttempts: number;
+                        initialDelayMs: number;
+                        maxDelayMs: number;
+                        multiplier?: number | undefined;
+                        jitterPercent?: number | undefined;
+                    } | undefined;
+                    status?: "ACTIVE" | "SUSPENDED" | undefined;
                 };
             };
             output: {
@@ -4778,7 +5700,21 @@ declare const routes: hono_hono_base.HonoBase<{
             input: {
                 param: {
                     eventStoreName: string;
-                    subscriptionId: string;
+                    subscriberId: string;
+                };
+            } & {
+                json: {
+                    eventFilter?: string | string[] | undefined;
+                    subscriberConfig?: Record<string, unknown> | undefined;
+                    retryPolicy?: {
+                        strategy: "fixed" | "exponential" | "linear";
+                        maxAttempts: number;
+                        initialDelayMs: number;
+                        maxDelayMs: number;
+                        multiplier?: number | undefined;
+                        jitterPercent?: number | undefined;
+                    } | undefined;
+                    status?: "ACTIVE" | "SUSPENDED" | undefined;
                 };
             };
             output: {
@@ -4794,7 +5730,21 @@ declare const routes: hono_hono_base.HonoBase<{
             input: {
                 param: {
                     eventStoreName: string;
-                    subscriptionId: string;
+                    subscriberId: string;
+                };
+            } & {
+                json: {
+                    eventFilter?: string | string[] | undefined;
+                    subscriberConfig?: Record<string, unknown> | undefined;
+                    retryPolicy?: {
+                        strategy: "fixed" | "exponential" | "linear";
+                        maxAttempts: number;
+                        initialDelayMs: number;
+                        maxDelayMs: number;
+                        multiplier?: number | undefined;
+                        jitterPercent?: number | undefined;
+                    } | undefined;
+                    status?: "ACTIVE" | "SUSPENDED" | undefined;
                 };
             };
             output: {
@@ -4806,6 +5756,36 @@ declare const routes: hono_hono_base.HonoBase<{
             };
             outputFormat: "json";
             status: 500;
+        } | {
+            input: {
+                param: {
+                    eventStoreName: string;
+                    subscriberId: string;
+                };
+            } & {
+                json: {
+                    eventFilter?: string | string[] | undefined;
+                    subscriberConfig?: Record<string, unknown> | undefined;
+                    retryPolicy?: {
+                        strategy: "fixed" | "exponential" | "linear";
+                        maxAttempts: number;
+                        initialDelayMs: number;
+                        maxDelayMs: number;
+                        multiplier?: number | undefined;
+                        jitterPercent?: number | undefined;
+                    } | undefined;
+                    status?: "ACTIVE" | "SUSPENDED" | undefined;
+                };
+            };
+            output: {
+                error: string;
+                message: string;
+                details?: {
+                    [x: string]: any;
+                } | undefined;
+            };
+            outputFormat: "json";
+            status: 409;
         };
     };
 }, "/api"> | hono_types.MergeSchemaPath<{
@@ -4987,7 +5967,7 @@ declare const routes: hono_hono_base.HonoBase<{
             status: 200;
         };
     };
-}, "/api">) & {
+}, "/api"> | hono_types.MergeSchemaPath<{}, "/">) & {
     "/api/reference": {
         $get: {
             input: {};
@@ -4997,7 +5977,13 @@ declare const routes: hono_hono_base.HonoBase<{
         };
     };
 }, "/">;
+/**
+ * Get the OpenAPI specification for the platform API.
+ * This is used by documentation generators to extract the API schema at build time.
+ * @returns The OpenAPI 3.0 specification object
+ */
+declare function getOpenAPISpec(): Record<string, unknown>;
 
 type AppType = typeof routes;
 
-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 };
+export { type AppType, type BaseSubscriberConfig, type CloudflareWorkflowConfig, type DurableObjectConfig, EventBusAPI, EventBusDurableObject, type EventFilter, EventStoreAPI, EventStoreDurableObject, EventStoreManagerDurableObject, type EventType, ManagementAPI, type QueueConfig, SubscriberDurableObject, SubscriberType, WebSocketManagerDurableObject, WebSocketsAPI, type WebhookConfig, type WildcardPattern, routes as default, getOpenAPISpec };