@mastra/server 1.12.0 → 1.13.0

package/dist/server/server-adapter/routes/stored-prompt-blocks.d.ts

@@ -1,3 +1,1698 @@
-import type { ServerRoute } from '.';
-export declare const STORED_PROMPT_BLOCKS_ROUTES: ServerRoute<any, any, any>[];
+export declare const STORED_PROMPT_BLOCKS_ROUTES: readonly [import(".").ServerRoute<import(".").InferParams<undefined, import("zod").ZodObject<{
+    perPage: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
+    orderBy: import("zod").ZodOptional<import("zod").ZodObject<{
+        field: import("zod").ZodOptional<import("zod").ZodEnum<{
+            createdAt: "createdAt";
+            updatedAt: "updatedAt";
+        }>>;
+        direction: import("zod").ZodOptional<import("zod").ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>>;
+    }, import("zod/v4/core").$strip>>;
+    status: import("zod").ZodOptional<import("zod").ZodEnum<{
+        draft: "draft";
+        published: "published";
+        archived: "archived";
+    }>>;
+    authorId: import("zod").ZodOptional<import("zod").ZodString>;
+    metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+}, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+    perPage: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
+    orderBy: import("zod").ZodOptional<import("zod").ZodObject<{
+        field: import("zod").ZodOptional<import("zod").ZodEnum<{
+            createdAt: "createdAt";
+            updatedAt: "updatedAt";
+        }>>;
+        direction: import("zod").ZodOptional<import("zod").ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>>;
+    }, import("zod/v4/core").$strip>>;
+    status: import("zod").ZodOptional<import("zod").ZodEnum<{
+        draft: "draft";
+        published: "published";
+        archived: "archived";
+    }>>;
+    authorId: import("zod").ZodOptional<import("zod").ZodString>;
+    metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+}, import("zod/v4/core").$strip>, undefined>, {
+    total: number;
+    page: number;
+    perPage: number | false;
+    hasMore: boolean;
+    promptBlocks: {
+        id: string;
+        status: string;
+        createdAt: Date;
+        updatedAt: Date;
+        name: string;
+        content: string;
+        activeVersionId?: string | undefined;
+        hasDraft?: boolean | undefined;
+        authorId?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        description?: string | undefined;
+        rules?: {
+            operator: "AND" | "OR";
+            conditions: ({
+                field: string;
+                operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                value?: unknown;
+            } | {
+                operator: "AND" | "OR";
+                conditions: ({
+                    field: string;
+                    operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                    value?: unknown;
+                } | {
+                    operator: "AND" | "OR";
+                    conditions: {
+                        field: string;
+                        operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                        value?: unknown;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+        requestContextSchema?: Record<string, unknown> | undefined;
+    }[];
+}, "json", import(".").RouteSchemas<undefined, import("zod").ZodObject<{
+    perPage: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
+    orderBy: import("zod").ZodOptional<import("zod").ZodObject<{
+        field: import("zod").ZodOptional<import("zod").ZodEnum<{
+            createdAt: "createdAt";
+            updatedAt: "updatedAt";
+        }>>;
+        direction: import("zod").ZodOptional<import("zod").ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>>;
+    }, import("zod/v4/core").$strip>>;
+    status: import("zod").ZodOptional<import("zod").ZodEnum<{
+        draft: "draft";
+        published: "published";
+        archived: "archived";
+    }>>;
+    authorId: import("zod").ZodOptional<import("zod").ZodString>;
+    metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+}, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+    perPage: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
+    orderBy: import("zod").ZodOptional<import("zod").ZodObject<{
+        field: import("zod").ZodOptional<import("zod").ZodEnum<{
+            createdAt: "createdAt";
+            updatedAt: "updatedAt";
+        }>>;
+        direction: import("zod").ZodOptional<import("zod").ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>>;
+    }, import("zod/v4/core").$strip>>;
+    status: import("zod").ZodOptional<import("zod").ZodEnum<{
+        draft: "draft";
+        published: "published";
+        archived: "archived";
+    }>>;
+    authorId: import("zod").ZodOptional<import("zod").ZodString>;
+    metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+}, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
+    total: import("zod").ZodNumber;
+    page: import("zod").ZodNumber;
+    perPage: import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodLiteral<false>]>;
+    hasMore: import("zod").ZodBoolean;
+    promptBlocks: import("zod").ZodArray<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        status: import("zod").ZodString;
+        activeVersionId: import("zod").ZodOptional<import("zod").ZodString>;
+        hasDraft: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        authorId: import("zod").ZodOptional<import("zod").ZodString>;
+        metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        createdAt: import("zod").ZodCoercedDate<unknown>;
+        updatedAt: import("zod").ZodCoercedDate<unknown>;
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        content: import("zod").ZodString;
+        rules: import("zod").ZodOptional<import("zod").ZodObject<{
+            operator: import("zod").ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                field: import("zod").ZodString;
+                operator: import("zod").ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                operator: import("zod").ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    field: import("zod").ZodString;
+                    operator: import("zod").ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    operator: import("zod").ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: import("zod").ZodArray<import("zod").ZodObject<{
+                        field: import("zod").ZodString;
+                        operator: import("zod").ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$strip>]>>;
+            }, import("zod/v4/core").$strip>]>>;
+        }, import("zod/v4/core").$strip>>;
+        requestContextSchema: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>>, "GET", "/stored/prompt-blocks">, import(".").ServerRoute<import(".").InferParams<import("zod").ZodObject<{
+    storedPromptBlockId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    status: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<{
+        draft: "draft";
+        published: "published";
+        archived: "archived";
+    }>>>;
+}, import("zod/v4/core").$strip>, undefined>, {
+    id: string;
+    status: string;
+    createdAt: Date;
+    updatedAt: Date;
+    name: string;
+    content: string;
+    activeVersionId?: string | undefined;
+    hasDraft?: boolean | undefined;
+    authorId?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    description?: string | undefined;
+    rules?: {
+        operator: "AND" | "OR";
+        conditions: ({
+            field: string;
+            operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+            value?: unknown;
+        } | {
+            operator: "AND" | "OR";
+            conditions: ({
+                field: string;
+                operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                value?: unknown;
+            } | {
+                operator: "AND" | "OR";
+                conditions: {
+                    field: string;
+                    operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                    value?: unknown;
+                }[];
+            })[];
+        })[];
+    } | undefined;
+    requestContextSchema?: Record<string, unknown> | undefined;
+}, "json", import(".").RouteSchemas<import("zod").ZodObject<{
+    storedPromptBlockId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    status: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<{
+        draft: "draft";
+        published: "published";
+        archived: "archived";
+    }>>>;
+}, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    status: import("zod").ZodString;
+    activeVersionId: import("zod").ZodOptional<import("zod").ZodString>;
+    hasDraft: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    authorId: import("zod").ZodOptional<import("zod").ZodString>;
+    metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    createdAt: import("zod").ZodCoercedDate<unknown>;
+    updatedAt: import("zod").ZodCoercedDate<unknown>;
+    name: import("zod").ZodString;
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+    content: import("zod").ZodString;
+    rules: import("zod").ZodOptional<import("zod").ZodObject<{
+        operator: import("zod").ZodEnum<{
+            AND: "AND";
+            OR: "OR";
+        }>;
+        conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            field: import("zod").ZodString;
+            operator: import("zod").ZodEnum<{
+                in: "in";
+                equals: "equals";
+                not_equals: "not_equals";
+                contains: "contains";
+                not_contains: "not_contains";
+                greater_than: "greater_than";
+                less_than: "less_than";
+                greater_than_or_equal: "greater_than_or_equal";
+                less_than_or_equal: "less_than_or_equal";
+                not_in: "not_in";
+                exists: "exists";
+                not_exists: "not_exists";
+            }>;
+            value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            operator: import("zod").ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                field: import("zod").ZodString;
+                operator: import("zod").ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                operator: import("zod").ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: import("zod").ZodArray<import("zod").ZodObject<{
+                    field: import("zod").ZodString;
+                    operator: import("zod").ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>]>>;
+        }, import("zod/v4/core").$strip>]>>;
+    }, import("zod/v4/core").$strip>>;
+    requestContextSchema: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+}, import("zod/v4/core").$strip>>, "GET", "/stored/prompt-blocks/:storedPromptBlockId">, import(".").ServerRoute<{
+    name: string;
+    content: string;
+    id?: string | undefined;
+    authorId?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    description?: string | undefined;
+    rules?: {
+        operator: "AND" | "OR";
+        conditions: ({
+            field: string;
+            operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+            value?: unknown;
+        } | {
+            operator: "AND" | "OR";
+            conditions: ({
+                field: string;
+                operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                value?: unknown;
+            } | {
+                operator: "AND" | "OR";
+                conditions: {
+                    field: string;
+                    operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                    value?: unknown;
+                }[];
+            })[];
+        })[];
+    } | undefined;
+    requestContextSchema?: Record<string, unknown> | undefined;
+}, {
+    id: string;
+    status: string;
+    createdAt: Date;
+    updatedAt: Date;
+    name: string;
+    content: string;
+    activeVersionId?: string | undefined;
+    hasDraft?: boolean | undefined;
+    authorId?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    description?: string | undefined;
+    rules?: {
+        operator: "AND" | "OR";
+        conditions: ({
+            field: string;
+            operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+            value?: unknown;
+        } | {
+            operator: "AND" | "OR";
+            conditions: ({
+                field: string;
+                operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                value?: unknown;
+            } | {
+                operator: "AND" | "OR";
+                conditions: {
+                    field: string;
+                    operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                    value?: unknown;
+                }[];
+            })[];
+        })[];
+    } | undefined;
+    requestContextSchema?: Record<string, unknown> | undefined;
+}, "json", import(".").RouteSchemas<undefined, undefined, import("zod").ZodObject<{
+    id: import("zod").ZodOptional<import("zod").ZodString>;
+    authorId: import("zod").ZodOptional<import("zod").ZodString>;
+    metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    name: import("zod").ZodString;
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+    content: import("zod").ZodString;
+    rules: import("zod").ZodOptional<import("zod").ZodObject<{
+        operator: import("zod").ZodEnum<{
+            AND: "AND";
+            OR: "OR";
+        }>;
+        conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            field: import("zod").ZodString;
+            operator: import("zod").ZodEnum<{
+                in: "in";
+                equals: "equals";
+                not_equals: "not_equals";
+                contains: "contains";
+                not_contains: "not_contains";
+                greater_than: "greater_than";
+                less_than: "less_than";
+                greater_than_or_equal: "greater_than_or_equal";
+                less_than_or_equal: "less_than_or_equal";
+                not_in: "not_in";
+                exists: "exists";
+                not_exists: "not_exists";
+            }>;
+            value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            operator: import("zod").ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                field: import("zod").ZodString;
+                operator: import("zod").ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                operator: import("zod").ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: import("zod").ZodArray<import("zod").ZodObject<{
+                    field: import("zod").ZodString;
+                    operator: import("zod").ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>]>>;
+        }, import("zod/v4/core").$strip>]>>;
+    }, import("zod/v4/core").$strip>>;
+    requestContextSchema: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    status: import("zod").ZodString;
+    activeVersionId: import("zod").ZodOptional<import("zod").ZodString>;
+    hasDraft: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    authorId: import("zod").ZodOptional<import("zod").ZodString>;
+    metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    createdAt: import("zod").ZodCoercedDate<unknown>;
+    updatedAt: import("zod").ZodCoercedDate<unknown>;
+    name: import("zod").ZodString;
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+    content: import("zod").ZodString;
+    rules: import("zod").ZodOptional<import("zod").ZodObject<{
+        operator: import("zod").ZodEnum<{
+            AND: "AND";
+            OR: "OR";
+        }>;
+        conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            field: import("zod").ZodString;
+            operator: import("zod").ZodEnum<{
+                in: "in";
+                equals: "equals";
+                not_equals: "not_equals";
+                contains: "contains";
+                not_contains: "not_contains";
+                greater_than: "greater_than";
+                less_than: "less_than";
+                greater_than_or_equal: "greater_than_or_equal";
+                less_than_or_equal: "less_than_or_equal";
+                not_in: "not_in";
+                exists: "exists";
+                not_exists: "not_exists";
+            }>;
+            value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            operator: import("zod").ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                field: import("zod").ZodString;
+                operator: import("zod").ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                operator: import("zod").ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: import("zod").ZodArray<import("zod").ZodObject<{
+                    field: import("zod").ZodString;
+                    operator: import("zod").ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>]>>;
+        }, import("zod/v4/core").$strip>]>>;
+    }, import("zod/v4/core").$strip>>;
+    requestContextSchema: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+}, import("zod/v4/core").$strip>>, "POST", "/stored/prompt-blocks">, import(".").ServerRoute<import(".").InferParams<import("zod").ZodObject<{
+    storedPromptBlockId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
+    authorId: import("zod").ZodOptional<import("zod").ZodString>;
+    metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    description: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodString>>;
+    content: import("zod").ZodOptional<import("zod").ZodString>;
+    rules: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodObject<{
+        operator: import("zod").ZodEnum<{
+            AND: "AND";
+            OR: "OR";
+        }>;
+        conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            field: import("zod").ZodString;
+            operator: import("zod").ZodEnum<{
+                in: "in";
+                equals: "equals";
+                not_equals: "not_equals";
+                contains: "contains";
+                not_contains: "not_contains";
+                greater_than: "greater_than";
+                less_than: "less_than";
+                greater_than_or_equal: "greater_than_or_equal";
+                less_than_or_equal: "less_than_or_equal";
+                not_in: "not_in";
+                exists: "exists";
+                not_exists: "not_exists";
+            }>;
+            value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            operator: import("zod").ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                field: import("zod").ZodString;
+                operator: import("zod").ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                operator: import("zod").ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: import("zod").ZodArray<import("zod").ZodObject<{
+                    field: import("zod").ZodString;
+                    operator: import("zod").ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>]>>;
+        }, import("zod/v4/core").$strip>]>>;
+    }, import("zod/v4/core").$strip>>>;
+    requestContextSchema: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+}, import("zod/v4/core").$strip>>, {
+    id: string;
+    status: string;
+    createdAt: Date;
+    updatedAt: Date;
+    name: string;
+    content: string;
+    activeVersionId?: string | undefined;
+    hasDraft?: boolean | undefined;
+    authorId?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    description?: string | undefined;
+    rules?: {
+        operator: "AND" | "OR";
+        conditions: ({
+            field: string;
+            operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+            value?: unknown;
+        } | {
+            operator: "AND" | "OR";
+            conditions: ({
+                field: string;
+                operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                value?: unknown;
+            } | {
+                operator: "AND" | "OR";
+                conditions: {
+                    field: string;
+                    operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                    value?: unknown;
+                }[];
+            })[];
+        })[];
+    } | undefined;
+    requestContextSchema?: Record<string, unknown> | undefined;
+} | {
+    id: string;
+    status: string;
+    createdAt: Date;
+    updatedAt: Date;
+    activeVersionId?: string | undefined;
+    authorId?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, "json", import(".").RouteSchemas<import("zod").ZodObject<{
+    storedPromptBlockId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
+    authorId: import("zod").ZodOptional<import("zod").ZodString>;
+    metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    description: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodString>>;
+    content: import("zod").ZodOptional<import("zod").ZodString>;
+    rules: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodObject<{
+        operator: import("zod").ZodEnum<{
+            AND: "AND";
+            OR: "OR";
+        }>;
+        conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            field: import("zod").ZodString;
+            operator: import("zod").ZodEnum<{
+                in: "in";
+                equals: "equals";
+                not_equals: "not_equals";
+                contains: "contains";
+                not_contains: "not_contains";
+                greater_than: "greater_than";
+                less_than: "less_than";
+                greater_than_or_equal: "greater_than_or_equal";
+                less_than_or_equal: "less_than_or_equal";
+                not_in: "not_in";
+                exists: "exists";
+                not_exists: "not_exists";
+            }>;
+            value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            operator: import("zod").ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                field: import("zod").ZodString;
+                operator: import("zod").ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                operator: import("zod").ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: import("zod").ZodArray<import("zod").ZodObject<{
+                    field: import("zod").ZodString;
+                    operator: import("zod").ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>]>>;
+        }, import("zod/v4/core").$strip>]>>;
+    }, import("zod/v4/core").$strip>>>;
+    requestContextSchema: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    status: import("zod").ZodString;
+    activeVersionId: import("zod").ZodOptional<import("zod").ZodString>;
+    authorId: import("zod").ZodOptional<import("zod").ZodString>;
+    metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    createdAt: import("zod").ZodCoercedDate<unknown>;
+    updatedAt: import("zod").ZodCoercedDate<unknown>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    status: import("zod").ZodString;
+    activeVersionId: import("zod").ZodOptional<import("zod").ZodString>;
+    hasDraft: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    authorId: import("zod").ZodOptional<import("zod").ZodString>;
+    metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    createdAt: import("zod").ZodCoercedDate<unknown>;
+    updatedAt: import("zod").ZodCoercedDate<unknown>;
+    name: import("zod").ZodString;
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+    content: import("zod").ZodString;
+    rules: import("zod").ZodOptional<import("zod").ZodObject<{
+        operator: import("zod").ZodEnum<{
+            AND: "AND";
+            OR: "OR";
+        }>;
+        conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            field: import("zod").ZodString;
+            operator: import("zod").ZodEnum<{
+                in: "in";
+                equals: "equals";
+                not_equals: "not_equals";
+                contains: "contains";
+                not_contains: "not_contains";
+                greater_than: "greater_than";
+                less_than: "less_than";
+                greater_than_or_equal: "greater_than_or_equal";
+                less_than_or_equal: "less_than_or_equal";
+                not_in: "not_in";
+                exists: "exists";
+                not_exists: "not_exists";
+            }>;
+            value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            operator: import("zod").ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                field: import("zod").ZodString;
+                operator: import("zod").ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                operator: import("zod").ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: import("zod").ZodArray<import("zod").ZodObject<{
+                    field: import("zod").ZodString;
+                    operator: import("zod").ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>]>>;
+        }, import("zod/v4/core").$strip>]>>;
+    }, import("zod/v4/core").$strip>>;
+    requestContextSchema: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+}, import("zod/v4/core").$strip>]>>, "PATCH", "/stored/prompt-blocks/:storedPromptBlockId">, import(".").ServerRoute<{
+    storedPromptBlockId: string;
+}, {
+    success: boolean;
+    message: string;
+}, "json", import(".").RouteSchemas<import("zod").ZodObject<{
+    storedPromptBlockId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined, undefined, import("zod").ZodObject<{
+    success: import("zod").ZodBoolean;
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>>, "DELETE", "/stored/prompt-blocks/:storedPromptBlockId">, import(".").ServerRoute<import(".").InferParams<import("zod").ZodObject<{
+    promptBlockId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    perPage: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
+    orderBy: import("zod").ZodOptional<import("zod").ZodObject<{
+        field: import("zod").ZodOptional<import("zod").ZodEnum<{
+            createdAt: "createdAt";
+            versionNumber: "versionNumber";
+        }>>;
+        direction: import("zod").ZodOptional<import("zod").ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+    perPage: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
+    orderBy: import("zod").ZodOptional<import("zod").ZodObject<{
+        field: import("zod").ZodOptional<import("zod").ZodEnum<{
+            createdAt: "createdAt";
+            versionNumber: "versionNumber";
+        }>>;
+        direction: import("zod").ZodOptional<import("zod").ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, undefined>, {
+    total: number;
+    page: number;
+    perPage: number | false;
+    hasMore: boolean;
+    versions: {
+        id: string;
+        blockId: string;
+        versionNumber: number;
+        name: string;
+        content: string;
+        createdAt: Date;
+        description?: string | undefined;
+        rules?: {
+            operator: "AND" | "OR";
+            conditions: ({
+                field: string;
+                operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                value?: unknown;
+            } | {
+                operator: "AND" | "OR";
+                conditions: ({
+                    field: string;
+                    operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                    value?: unknown;
+                } | {
+                    operator: "AND" | "OR";
+                    conditions: {
+                        field: string;
+                        operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                        value?: unknown;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+        requestContextSchema?: Record<string, unknown> | undefined;
+        changedFields?: string[] | undefined;
+        changeMessage?: string | undefined;
+    }[];
+}, "json", import(".").RouteSchemas<import("zod").ZodObject<{
+    promptBlockId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    perPage: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
+    orderBy: import("zod").ZodOptional<import("zod").ZodObject<{
+        field: import("zod").ZodOptional<import("zod").ZodEnum<{
+            createdAt: "createdAt";
+            versionNumber: "versionNumber";
+        }>>;
+        direction: import("zod").ZodOptional<import("zod").ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+    perPage: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
+    orderBy: import("zod").ZodOptional<import("zod").ZodObject<{
+        field: import("zod").ZodOptional<import("zod").ZodEnum<{
+            createdAt: "createdAt";
+            versionNumber: "versionNumber";
+        }>>;
+        direction: import("zod").ZodOptional<import("zod").ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
+    total: import("zod").ZodNumber;
+    page: import("zod").ZodNumber;
+    perPage: import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodLiteral<false>]>;
+    hasMore: import("zod").ZodBoolean;
+    versions: import("zod").ZodArray<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        blockId: import("zod").ZodString;
+        versionNumber: import("zod").ZodNumber;
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        content: import("zod").ZodString;
+        rules: import("zod").ZodOptional<import("zod").ZodObject<{
+            operator: import("zod").ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                field: import("zod").ZodString;
+                operator: import("zod").ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                operator: import("zod").ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    field: import("zod").ZodString;
+                    operator: import("zod").ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    operator: import("zod").ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: import("zod").ZodArray<import("zod").ZodObject<{
+                        field: import("zod").ZodString;
+                        operator: import("zod").ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$strip>]>>;
+            }, import("zod/v4/core").$strip>]>>;
+        }, import("zod/v4/core").$strip>>;
+        requestContextSchema: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        changedFields: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        changeMessage: import("zod").ZodOptional<import("zod").ZodString>;
+        createdAt: import("zod").ZodCoercedDate<unknown>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>>, "GET", "/stored/prompt-blocks/:promptBlockId/versions">, import(".").ServerRoute<import(".").InferParams<import("zod").ZodObject<{
+    promptBlockId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
+    changeMessage: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>>, {
+    id: string;
+    blockId: string;
+    versionNumber: number;
+    createdAt: Date;
+    name?: string | undefined;
+    description?: string | undefined;
+    content?: string | undefined;
+    rules?: {
+        operator: "AND" | "OR";
+        conditions: ({
+            field: string;
+            operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+            value?: unknown;
+        } | {
+            operator: "AND" | "OR";
+            conditions: ({
+                field: string;
+                operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                value?: unknown;
+            } | {
+                operator: "AND" | "OR";
+                conditions: {
+                    field: string;
+                    operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                    value?: unknown;
+                }[];
+            })[];
+        })[];
+    } | undefined;
+    requestContextSchema?: Record<string, unknown> | undefined;
+    changedFields?: string[] | undefined;
+    changeMessage?: string | undefined;
+}, "json", import(".").RouteSchemas<import("zod").ZodObject<{
+    promptBlockId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
+    changeMessage: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    description: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodString>>;
+    content: import("zod").ZodOptional<import("zod").ZodString>;
+    rules: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodObject<{
+        operator: import("zod").ZodEnum<{
+            AND: "AND";
+            OR: "OR";
+        }>;
+        conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            field: import("zod").ZodString;
+            operator: import("zod").ZodEnum<{
+                in: "in";
+                equals: "equals";
+                not_equals: "not_equals";
+                contains: "contains";
+                not_contains: "not_contains";
+                greater_than: "greater_than";
+                less_than: "less_than";
+                greater_than_or_equal: "greater_than_or_equal";
+                less_than_or_equal: "less_than_or_equal";
+                not_in: "not_in";
+                exists: "exists";
+                not_exists: "not_exists";
+            }>;
+            value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            operator: import("zod").ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                field: import("zod").ZodString;
+                operator: import("zod").ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                operator: import("zod").ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: import("zod").ZodArray<import("zod").ZodObject<{
+                    field: import("zod").ZodString;
+                    operator: import("zod").ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>]>>;
+        }, import("zod/v4/core").$strip>]>>;
+    }, import("zod/v4/core").$strip>>>;
+    requestContextSchema: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    changedFields: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>>;
+    changeMessage: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodString>>;
+    id: import("zod").ZodString;
+    blockId: import("zod").ZodString;
+    versionNumber: import("zod").ZodNumber;
+    createdAt: import("zod").ZodCoercedDate<unknown>;
+}, import("zod/v4/core").$strip>>, "POST", "/stored/prompt-blocks/:promptBlockId/versions">, import(".").ServerRoute<import(".").InferParams<import("zod").ZodObject<{
+    promptBlockId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    from: import("zod").ZodString;
+    to: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined>, {
+    diffs: {
+        field: string;
+        previousValue: unknown;
+        currentValue: unknown;
+    }[];
+    fromVersion: {
+        id: string;
+        blockId: string;
+        versionNumber: number;
+        name: string;
+        content: string;
+        createdAt: Date;
+        description?: string | undefined;
+        rules?: {
+            operator: "AND" | "OR";
+            conditions: ({
+                field: string;
+                operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                value?: unknown;
+            } | {
+                operator: "AND" | "OR";
+                conditions: ({
+                    field: string;
+                    operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                    value?: unknown;
+                } | {
+                    operator: "AND" | "OR";
+                    conditions: {
+                        field: string;
+                        operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                        value?: unknown;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+        requestContextSchema?: Record<string, unknown> | undefined;
+        changedFields?: string[] | undefined;
+        changeMessage?: string | undefined;
+    };
+    toVersion: {
+        id: string;
+        blockId: string;
+        versionNumber: number;
+        name: string;
+        content: string;
+        createdAt: Date;
+        description?: string | undefined;
+        rules?: {
+            operator: "AND" | "OR";
+            conditions: ({
+                field: string;
+                operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                value?: unknown;
+            } | {
+                operator: "AND" | "OR";
+                conditions: ({
+                    field: string;
+                    operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                    value?: unknown;
+                } | {
+                    operator: "AND" | "OR";
+                    conditions: {
+                        field: string;
+                        operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                        value?: unknown;
+                    }[];
+                })[];
+            })[];
+        } | undefined;
+        requestContextSchema?: Record<string, unknown> | undefined;
+        changedFields?: string[] | undefined;
+        changeMessage?: string | undefined;
+    };
+}, "json", import(".").RouteSchemas<import("zod").ZodObject<{
+    promptBlockId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    from: import("zod").ZodString;
+    to: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
+    diffs: import("zod").ZodArray<import("zod").ZodObject<{
+        field: import("zod").ZodString;
+        previousValue: import("zod").ZodUnknown;
+        currentValue: import("zod").ZodUnknown;
+    }, import("zod/v4/core").$strip>>;
+    fromVersion: import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        blockId: import("zod").ZodString;
+        versionNumber: import("zod").ZodNumber;
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        content: import("zod").ZodString;
+        rules: import("zod").ZodOptional<import("zod").ZodObject<{
+            operator: import("zod").ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                field: import("zod").ZodString;
+                operator: import("zod").ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                operator: import("zod").ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    field: import("zod").ZodString;
+                    operator: import("zod").ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    operator: import("zod").ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: import("zod").ZodArray<import("zod").ZodObject<{
+                        field: import("zod").ZodString;
+                        operator: import("zod").ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$strip>]>>;
+            }, import("zod/v4/core").$strip>]>>;
+        }, import("zod/v4/core").$strip>>;
+        requestContextSchema: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        changedFields: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        changeMessage: import("zod").ZodOptional<import("zod").ZodString>;
+        createdAt: import("zod").ZodCoercedDate<unknown>;
+    }, import("zod/v4/core").$strip>;
+    toVersion: import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        blockId: import("zod").ZodString;
+        versionNumber: import("zod").ZodNumber;
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        content: import("zod").ZodString;
+        rules: import("zod").ZodOptional<import("zod").ZodObject<{
+            operator: import("zod").ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                field: import("zod").ZodString;
+                operator: import("zod").ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                operator: import("zod").ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    field: import("zod").ZodString;
+                    operator: import("zod").ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    operator: import("zod").ZodEnum<{
+                        AND: "AND";
+                        OR: "OR";
+                    }>;
+                    conditions: import("zod").ZodArray<import("zod").ZodObject<{
+                        field: import("zod").ZodString;
+                        operator: import("zod").ZodEnum<{
+                            in: "in";
+                            equals: "equals";
+                            not_equals: "not_equals";
+                            contains: "contains";
+                            not_contains: "not_contains";
+                            greater_than: "greater_than";
+                            less_than: "less_than";
+                            greater_than_or_equal: "greater_than_or_equal";
+                            less_than_or_equal: "less_than_or_equal";
+                            not_in: "not_in";
+                            exists: "exists";
+                            not_exists: "not_exists";
+                        }>;
+                        value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$strip>]>>;
+            }, import("zod/v4/core").$strip>]>>;
+        }, import("zod/v4/core").$strip>>;
+        requestContextSchema: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        changedFields: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        changeMessage: import("zod").ZodOptional<import("zod").ZodString>;
+        createdAt: import("zod").ZodCoercedDate<unknown>;
+    }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>>, "GET", "/stored/prompt-blocks/:promptBlockId/versions/compare">, import(".").ServerRoute<{
+    promptBlockId: string;
+    versionId: string;
+}, {
+    id: string;
+    blockId: string;
+    versionNumber: number;
+    name: string;
+    content: string;
+    createdAt: Date;
+    description?: string | undefined;
+    rules?: {
+        operator: "AND" | "OR";
+        conditions: ({
+            field: string;
+            operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+            value?: unknown;
+        } | {
+            operator: "AND" | "OR";
+            conditions: ({
+                field: string;
+                operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                value?: unknown;
+            } | {
+                operator: "AND" | "OR";
+                conditions: {
+                    field: string;
+                    operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                    value?: unknown;
+                }[];
+            })[];
+        })[];
+    } | undefined;
+    requestContextSchema?: Record<string, unknown> | undefined;
+    changedFields?: string[] | undefined;
+    changeMessage?: string | undefined;
+}, "json", import(".").RouteSchemas<import("zod").ZodObject<{
+    promptBlockId: import("zod").ZodString;
+    versionId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined, undefined, import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    blockId: import("zod").ZodString;
+    versionNumber: import("zod").ZodNumber;
+    name: import("zod").ZodString;
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+    content: import("zod").ZodString;
+    rules: import("zod").ZodOptional<import("zod").ZodObject<{
+        operator: import("zod").ZodEnum<{
+            AND: "AND";
+            OR: "OR";
+        }>;
+        conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            field: import("zod").ZodString;
+            operator: import("zod").ZodEnum<{
+                in: "in";
+                equals: "equals";
+                not_equals: "not_equals";
+                contains: "contains";
+                not_contains: "not_contains";
+                greater_than: "greater_than";
+                less_than: "less_than";
+                greater_than_or_equal: "greater_than_or_equal";
+                less_than_or_equal: "less_than_or_equal";
+                not_in: "not_in";
+                exists: "exists";
+                not_exists: "not_exists";
+            }>;
+            value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            operator: import("zod").ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                field: import("zod").ZodString;
+                operator: import("zod").ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                operator: import("zod").ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: import("zod").ZodArray<import("zod").ZodObject<{
+                    field: import("zod").ZodString;
+                    operator: import("zod").ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>]>>;
+        }, import("zod/v4/core").$strip>]>>;
+    }, import("zod/v4/core").$strip>>;
+    requestContextSchema: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    changedFields: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    changeMessage: import("zod").ZodOptional<import("zod").ZodString>;
+    createdAt: import("zod").ZodCoercedDate<unknown>;
+}, import("zod/v4/core").$strip>>, "GET", "/stored/prompt-blocks/:promptBlockId/versions/:versionId">, import(".").ServerRoute<{
+    promptBlockId: string;
+    versionId: string;
+}, {
+    success: boolean;
+    message: string;
+    activeVersionId: string;
+}, "json", import(".").RouteSchemas<import("zod").ZodObject<{
+    promptBlockId: import("zod").ZodString;
+    versionId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined, undefined, import("zod").ZodObject<{
+    success: import("zod").ZodBoolean;
+    message: import("zod").ZodString;
+    activeVersionId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>>, "POST", "/stored/prompt-blocks/:promptBlockId/versions/:versionId/activate">, import(".").ServerRoute<{
+    promptBlockId: string;
+    versionId: string;
+}, {
+    id: string;
+    blockId: string;
+    versionNumber: number;
+    name: string;
+    content: string;
+    createdAt: Date;
+    description?: string | undefined;
+    rules?: {
+        operator: "AND" | "OR";
+        conditions: ({
+            field: string;
+            operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+            value?: unknown;
+        } | {
+            operator: "AND" | "OR";
+            conditions: ({
+                field: string;
+                operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                value?: unknown;
+            } | {
+                operator: "AND" | "OR";
+                conditions: {
+                    field: string;
+                    operator: "in" | "equals" | "not_equals" | "contains" | "not_contains" | "greater_than" | "less_than" | "greater_than_or_equal" | "less_than_or_equal" | "not_in" | "exists" | "not_exists";
+                    value?: unknown;
+                }[];
+            })[];
+        })[];
+    } | undefined;
+    requestContextSchema?: Record<string, unknown> | undefined;
+    changedFields?: string[] | undefined;
+    changeMessage?: string | undefined;
+}, "json", import(".").RouteSchemas<import("zod").ZodObject<{
+    promptBlockId: import("zod").ZodString;
+    versionId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined, undefined, import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    blockId: import("zod").ZodString;
+    versionNumber: import("zod").ZodNumber;
+    name: import("zod").ZodString;
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+    content: import("zod").ZodString;
+    rules: import("zod").ZodOptional<import("zod").ZodObject<{
+        operator: import("zod").ZodEnum<{
+            AND: "AND";
+            OR: "OR";
+        }>;
+        conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            field: import("zod").ZodString;
+            operator: import("zod").ZodEnum<{
+                in: "in";
+                equals: "equals";
+                not_equals: "not_equals";
+                contains: "contains";
+                not_contains: "not_contains";
+                greater_than: "greater_than";
+                less_than: "less_than";
+                greater_than_or_equal: "greater_than_or_equal";
+                less_than_or_equal: "less_than_or_equal";
+                not_in: "not_in";
+                exists: "exists";
+                not_exists: "not_exists";
+            }>;
+            value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            operator: import("zod").ZodEnum<{
+                AND: "AND";
+                OR: "OR";
+            }>;
+            conditions: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                field: import("zod").ZodString;
+                operator: import("zod").ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    greater_than: "greater_than";
+                    less_than: "less_than";
+                    greater_than_or_equal: "greater_than_or_equal";
+                    less_than_or_equal: "less_than_or_equal";
+                    not_in: "not_in";
+                    exists: "exists";
+                    not_exists: "not_exists";
+                }>;
+                value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                operator: import("zod").ZodEnum<{
+                    AND: "AND";
+                    OR: "OR";
+                }>;
+                conditions: import("zod").ZodArray<import("zod").ZodObject<{
+                    field: import("zod").ZodString;
+                    operator: import("zod").ZodEnum<{
+                        in: "in";
+                        equals: "equals";
+                        not_equals: "not_equals";
+                        contains: "contains";
+                        not_contains: "not_contains";
+                        greater_than: "greater_than";
+                        less_than: "less_than";
+                        greater_than_or_equal: "greater_than_or_equal";
+                        less_than_or_equal: "less_than_or_equal";
+                        not_in: "not_in";
+                        exists: "exists";
+                        not_exists: "not_exists";
+                    }>;
+                    value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>]>>;
+        }, import("zod/v4/core").$strip>]>>;
+    }, import("zod/v4/core").$strip>>;
+    requestContextSchema: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    changedFields: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    changeMessage: import("zod").ZodOptional<import("zod").ZodString>;
+    createdAt: import("zod").ZodCoercedDate<unknown>;
+}, import("zod/v4/core").$strip>>, "POST", "/stored/prompt-blocks/:promptBlockId/versions/:versionId/restore">, import(".").ServerRoute<{
+    promptBlockId: string;
+    versionId: string;
+}, {
+    success: boolean;
+    message: string;
+}, "json", import(".").RouteSchemas<import("zod").ZodObject<{
+    promptBlockId: import("zod").ZodString;
+    versionId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined, undefined, import("zod").ZodObject<{
+    success: import("zod").ZodBoolean;
+    message: import("zod").ZodString;
+}, import("zod/v4/core").$strip>>, "DELETE", "/stored/prompt-blocks/:promptBlockId/versions/:versionId">];
 //# sourceMappingURL=stored-prompt-blocks.d.ts.map