@mastra/server 1.12.0 → 1.13.0

package/dist/server/handlers/stored-prompt-blocks.d.ts

@@ -82,7 +82,136 @@ export declare const LIST_STORED_PROMPT_BLOCKS_ROUTE: import("../server-adapter"
         } | undefined;
         requestContextSchema?: Record<string, unknown> | undefined;
     }[];
-}, "json">;
+}, "json", import("../server-adapter").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">;
 /**
  * GET /stored/prompt-blocks/:storedPromptBlockId - Get a stored prompt block by ID
  */
@@ -129,7 +258,98 @@ export declare const GET_STORED_PROMPT_BLOCK_ROUTE: import("../server-adapter").
         })[];
     } | undefined;
     requestContextSchema?: Record<string, unknown> | undefined;
-}, "json">;
+}, "json", import("../server-adapter").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">;
 /**
  * POST /stored/prompt-blocks - Create a new stored prompt block
  */
@@ -198,7 +418,168 @@ export declare const CREATE_STORED_PROMPT_BLOCK_ROUTE: import("../server-adapter
         })[];
     } | undefined;
     requestContextSchema?: Record<string, unknown> | undefined;
-}, "json">;
+}, "json", import("../server-adapter").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">;
 /**
  * PATCH /stored/prompt-blocks/:storedPromptBlockId - Update a stored prompt block
  */
@@ -324,7 +705,177 @@ export declare const UPDATE_STORED_PROMPT_BLOCK_ROUTE: import("../server-adapter
     activeVersionId?: string | undefined;
     authorId?: string | undefined;
     metadata?: Record<string, unknown> | undefined;
-}, "json">;
+}, "json", import("../server-adapter").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">;
 /**
  * DELETE /stored/prompt-blocks/:storedPromptBlockId - Delete a stored prompt block
  */
@@ -333,5 +884,10 @@ export declare const DELETE_STORED_PROMPT_BLOCK_ROUTE: import("../server-adapter
 }, {
     success: boolean;
     message: string;
-}, "json">;
+}, "json", import("../server-adapter").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">;
 //# sourceMappingURL=stored-prompt-blocks.d.ts.map

package/dist/server/handlers/stored-prompt-blocks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stored-prompt-blocks.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/stored-prompt-blocks.ts"],"names":[],"mappings":"AAwCA;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA+C1C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAsCxC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA+E3C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA0F3C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gCAAgC;;;;;UAuC3C,CAAC"}
+{"version":3,"file":"stored-prompt-blocks.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/stored-prompt-blocks.ts"],"names":[],"mappings":"AAwCA;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEA+C1C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uFAsCxC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mEA+E3C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2FA0F3C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;0FAuC3C,CAAC"}

package/dist/server/handlers/stored-prompt-blocks.js

@@ -1,3 +1,3 @@
-export { CREATE_STORED_PROMPT_BLOCK_ROUTE, DELETE_STORED_PROMPT_BLOCK_ROUTE, GET_STORED_PROMPT_BLOCK_ROUTE, LIST_STORED_PROMPT_BLOCKS_ROUTE, UPDATE_STORED_PROMPT_BLOCK_ROUTE } from '../../chunk-QRQAZI3Q.js';
+export { CREATE_STORED_PROMPT_BLOCK_ROUTE, DELETE_STORED_PROMPT_BLOCK_ROUTE, GET_STORED_PROMPT_BLOCK_ROUTE, LIST_STORED_PROMPT_BLOCKS_ROUTE, UPDATE_STORED_PROMPT_BLOCK_ROUTE } from '../../chunk-2GOCJDE2.js';
 //# sourceMappingURL=stored-prompt-blocks.js.map
 //# sourceMappingURL=stored-prompt-blocks.js.map

package/dist/server/handlers/stored-scorers.cjs

@@ -1,28 +1,28 @@
 'use strict';
 
-var chunkRCEX4V4N_cjs = require('../../chunk-RCEX4V4N.cjs');
+var chunkC3U5LR4X_cjs = require('../../chunk-C3U5LR4X.cjs');
 
 
 
 Object.defineProperty(exports, "CREATE_STORED_SCORER_ROUTE", {
   enumerable: true,
-  get: function () { return chunkRCEX4V4N_cjs.CREATE_STORED_SCORER_ROUTE; }
+  get: function () { return chunkC3U5LR4X_cjs.CREATE_STORED_SCORER_ROUTE; }
 });
 Object.defineProperty(exports, "DELETE_STORED_SCORER_ROUTE", {
   enumerable: true,
-  get: function () { return chunkRCEX4V4N_cjs.DELETE_STORED_SCORER_ROUTE; }
+  get: function () { return chunkC3U5LR4X_cjs.DELETE_STORED_SCORER_ROUTE; }
 });
 Object.defineProperty(exports, "GET_STORED_SCORER_ROUTE", {
   enumerable: true,
-  get: function () { return chunkRCEX4V4N_cjs.GET_STORED_SCORER_ROUTE; }
+  get: function () { return chunkC3U5LR4X_cjs.GET_STORED_SCORER_ROUTE; }
 });
 Object.defineProperty(exports, "LIST_STORED_SCORERS_ROUTE", {
   enumerable: true,
-  get: function () { return chunkRCEX4V4N_cjs.LIST_STORED_SCORERS_ROUTE; }
+  get: function () { return chunkC3U5LR4X_cjs.LIST_STORED_SCORERS_ROUTE; }
 });
 Object.defineProperty(exports, "UPDATE_STORED_SCORER_ROUTE", {
   enumerable: true,
-  get: function () { return chunkRCEX4V4N_cjs.UPDATE_STORED_SCORER_ROUTE; }
+  get: function () { return chunkC3U5LR4X_cjs.UPDATE_STORED_SCORER_ROUTE; }
 });
 //# sourceMappingURL=stored-scorers.cjs.map
 //# sourceMappingURL=stored-scorers.cjs.map