@delta-base/core 1.3.6 → 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;
             };
         };
     }, "/">;
@@ -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,80 +1894,252 @@ 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;
-        Variables: {
+    } & {
+        "/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,16 +2935,18 @@ declare class EventBusDurableObject extends DurableObject<Env$1> {
      * @private
      */
     private formatDateToISO;
+    constructor(state: DurableObjectState, env: Env);
+    private initializeTables;
+    private ensureSubscriberDoColumn;
     /**
-     * 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
+     * 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 formatDateToSQLite;
-    constructor(state: DurableObjectState, env: Env$1);
-    private initializeTables;
+    private migrateSubscriptionsPrimaryKey;
     initialize(eventStoreID: string): void;
     /**
      * Ensures the event bus has been initialized
@@ -2494,6 +2954,7 @@ declare class EventBusDurableObject extends DurableObject<Env$1> {
      * @private
      */
     private ensureInitialized;
+    private getEventStoreId;
     /**
      * Check if a webhook subscription with the same configuration already exists
      * @param eventFilter - The event filter pattern to match
@@ -2513,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;
@@ -2578,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;
 }
 
 /**
@@ -2652,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.
@@ -2775,6 +3311,7 @@ declare class EventStoreDurableObject extends DurableObject<Env> {
      * @private
      */
     private mapRowToEvent;
+    private mapRowToOutboxDlqEntry;
     /**
      * Gets the current version of a stream
      * @param streamId - The stream to get the version for
@@ -2836,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
@@ -3088,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;
@@ -4204,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: {
@@ -4270,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;
@@ -4284,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;
@@ -4581,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: {
@@ -4602,7 +5356,7 @@ declare const routes: hono_hono_base.HonoBase<{
             input: {
                 param: {
                     eventStoreName: string;
-                    subscriptionId: string;
+                    subscriberId: string;
                 };
             };
             output: {
@@ -4618,7 +5372,7 @@ declare const routes: hono_hono_base.HonoBase<{
             input: {
                 param: {
                     eventStoreName: string;
-                    subscriptionId: string;
+                    subscriberId: string;
                 };
             };
             output: {
@@ -4634,7 +5388,7 @@ declare const routes: hono_hono_base.HonoBase<{
             input: {
                 param: {
                     eventStoreName: string;
-                    subscriptionId: string;
+                    subscriberId: string;
                 };
             };
             output: {
@@ -4728,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;
@@ -4742,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;
@@ -4753,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;
@@ -4776,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;
@@ -4786,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: {
@@ -4802,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: {
@@ -4818,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: {
@@ -4830,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<{
@@ -5011,7 +5967,7 @@ declare const routes: hono_hono_base.HonoBase<{
             status: 200;
         };
     };
-}, "/api">) & {
+}, "/api"> | hono_types.MergeSchemaPath<{}, "/">) & {
     "/api/reference": {
         $get: {
             input: {};
@@ -5021,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 };