@btst/stack 4.5.1 → 5.0.0

package/dist/shared/stack.Bt3WG2yb.d.cts

@@ -0,0 +1,1184 @@
+import * as _btst_stack_plugins_client from '@btst/stack/plugins/client';
+import { createApiClient } from '@btst/stack/plugins/client';
+import * as zod from 'zod';
+import { z } from 'zod';
+import { c as createPostSchema, u as updatePostSchema } from './stack.CKc_Bais.cjs';
+import { P as Post, T as Tag, S as SerializedPost, a as SerializedTag } from './stack.Dsatjh0B.cjs';
+import * as _btst_stack_plugins_api from '@btst/stack/plugins/api';
+import { DeepReadonly, OperationContext, OperationErrorContext } from '@btst/stack/plugins/api';
+import { PermissionDescriptor } from '../authorization/index.cjs';
+import * as zod_v4_core from 'zod/v4/core';
+import * as better_call from 'better-call';
+import { QueryClient } from '@tanstack/react-query';
+import { PermissionFactsFor } from '@btst/stack/authorization';
+import { DBAdapter } from '@btst/db';
+import { blogPermissions } from '../plugins/blog/permissions.cjs';
+
+/**
+ * Parameters for filtering/paginating posts.
+ * Mirrors the shape of the list API query schema.
+ */
+interface PostListParams {
+    slug?: string;
+    tagSlug?: string;
+    offset?: number;
+    limit?: number;
+    query?: string;
+    published?: boolean;
+}
+/**
+ * Paginated result returned by {@link getAllPosts}.
+ */
+interface PostListResult {
+    items: Array<Post & {
+        tags: Tag[];
+    }>;
+    total: number;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Retrieve all posts matching optional filter criteria.
+ * Pure DB function — no hooks, no HTTP context. Safe for SSG and server-side use.
+ *
+ * @remarks **Security:** Operation authorization and lifecycle hooks are NOT
+ * called. The caller is responsible for any access-control checks before
+ * invoking this function.
+ *
+ * @param adapter - The database adapter
+ * @param params - Optional filter/pagination parameters (same shape as the list API query)
+ */
+declare function getAllPosts(adapter: DBAdapter, params?: PostListParams): Promise<PostListResult>;
+/**
+ * Retrieve a single post by its slug, including associated tags.
+ * Returns null if no post is found.
+ * Pure DB function — no hooks, no HTTP context. Safe for SSG and server-side use.
+ *
+ * @remarks **Security:** Operation authorization and lifecycle hooks are NOT called. The caller is
+ * responsible for any access-control checks before invoking this function.
+ *
+ * @param adapter - The database adapter
+ * @param slug - The post slug
+ */
+declare function getPostBySlug(adapter: DBAdapter, slug: string): Promise<(Post & {
+    tags: Tag[];
+}) | null>;
+/**
+ * Retrieve all tags, sorted alphabetically by name.
+ * Pure DB function — no hooks, no HTTP context. Safe for SSG and server-side use.
+ *
+ * @remarks **Security:** Operation authorization and lifecycle hooks are NOT called. The caller is
+ * responsible for any access-control checks before invoking this function.
+ *
+ * @param adapter - The database adapter
+ */
+declare function getAllTags(adapter: DBAdapter): Promise<Tag[]>;
+
+declare const PostListQuerySchema: z.ZodObject<{
+    slug: z.ZodOptional<z.ZodString>;
+    tagSlug: z.ZodOptional<z.ZodString>;
+    offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    query: z.ZodOptional<z.ZodString>;
+    published: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>]>>, z.ZodTransform<boolean | undefined, boolean | "true" | "false" | undefined>>;
+}, z.core.$strip>;
+declare const NextPreviousPostsQuerySchema: z.ZodObject<{
+    date: z.ZodPipe<z.ZodCoercedDate<unknown>, z.ZodTransform<string, Date>>;
+}, z.core.$strip>;
+declare const CreatePostOperationInputSchema: z.ZodObject<{
+    slug: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    content: z.ZodString;
+    excerpt: z.ZodString;
+    image: z.ZodOptional<z.ZodString>;
+    published: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        slug: z.ZodString;
+    }, z.core.$strip>]>>>>;
+    publishedAt: z.ZodOptional<z.ZodPipe<z.ZodCoercedDate<unknown>, z.ZodTransform<string, Date>>>;
+    createdAt: z.ZodOptional<z.ZodPipe<z.ZodCoercedDate<unknown>, z.ZodTransform<string, Date>>>;
+    updatedAt: z.ZodOptional<z.ZodPipe<z.ZodCoercedDate<unknown>, z.ZodTransform<string, Date>>>;
+}, z.core.$strip>;
+declare const UpdatePostOperationInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    data: z.ZodObject<{
+        slug: z.ZodString;
+        title: z.ZodString;
+        content: z.ZodString;
+        excerpt: z.ZodString;
+        image: z.ZodOptional<z.ZodString>;
+        published: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            slug: z.ZodString;
+        }, z.core.$strip>]>>>>;
+        publishedAt: z.ZodOptional<z.ZodPipe<z.ZodCoercedDate<unknown>, z.ZodTransform<string, Date>>>;
+        createdAt: z.ZodOptional<z.ZodPipe<z.ZodCoercedDate<unknown>, z.ZodTransform<string, Date>>>;
+        updatedAt: z.ZodOptional<z.ZodPipe<z.ZodCoercedDate<unknown>, z.ZodTransform<string, Date>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const DeletePostInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+type ReadFacts = PermissionFactsFor<typeof blogPermissions.post.read>;
+type CreateFacts = PermissionFactsFor<typeof blogPermissions.post.create>;
+type UpdateFacts = PermissionFactsFor<typeof blogPermissions.post.update>;
+type DeleteFacts = PermissionFactsFor<typeof blogPermissions.post.delete>;
+type ListPostsInput = z.output<typeof PostListQuerySchema>;
+type CreatePostInput = z.output<typeof CreatePostOperationInputSchema>;
+type UpdatePostInput = z.output<typeof UpdatePostOperationInputSchema>;
+type DeletePostInput = z.output<typeof DeletePostInputSchema>;
+type NextPreviousPostsInput = z.output<typeof NextPreviousPostsQuerySchema>;
+type SerializedPostListResult = ReturnType<typeof serializeListResult>;
+type SerializedNextPreviousPostsResult = Awaited<ReturnType<typeof findNextPreviousPosts>>;
+type RequestFields = {
+    readonly request?: Request;
+    readonly headers?: Headers;
+};
+type BlogOperationContext<TInput, TFacts> = OperationContext<TInput, TFacts> & RequestFields;
+type BlogOperationErrorContext<TInput, TFacts> = OperationErrorContext<TInput, TFacts> & RequestFields;
+/** Authorized context supplied before a Blog post-list query executes. */
+interface BlogListOperationContext extends BlogOperationContext<ListPostsInput, ReadFacts> {
+    readonly query: DeepReadonly<ListPostsInput>;
+}
+/** Blog post-list context after execution, including the readonly result. */
+interface BlogListResultContext extends BlogListOperationContext {
+    readonly result: DeepReadonly<SerializedPostListResult>;
+}
+/** Blog post-list context supplied when authorized execution fails. */
+interface BlogListErrorContext extends BlogOperationErrorContext<ListPostsInput, ReadFacts> {
+    readonly query: DeepReadonly<ListPostsInput>;
+}
+/** Authorized context supplied before a Blog post is created. */
+interface BlogCreateOperationContext extends BlogOperationContext<CreatePostInput, CreateFacts> {
+    readonly body: DeepReadonly<CreatePostInput>;
+}
+/** Blog create context after execution, including the readonly post. */
+interface BlogCreateResultContext extends BlogCreateOperationContext {
+    readonly result: DeepReadonly<SerializedPost>;
+}
+/** Blog create context supplied when authorized execution fails. */
+interface BlogCreateErrorContext extends BlogOperationErrorContext<CreatePostInput, CreateFacts> {
+    readonly body: DeepReadonly<CreatePostInput>;
+}
+/** Authorized context supplied before a Blog post is updated. */
+interface BlogUpdateOperationContext extends BlogOperationContext<UpdatePostInput, UpdateFacts> {
+    readonly params: {
+        readonly id: string;
+    };
+    readonly body: DeepReadonly<UpdatePostInput["data"]>;
+}
+/** Blog update context after execution, including the readonly post. */
+interface BlogUpdateResultContext extends BlogUpdateOperationContext {
+    readonly result: DeepReadonly<SerializedPost>;
+}
+/** Blog update context supplied when authorized execution fails. */
+interface BlogUpdateErrorContext extends BlogOperationErrorContext<UpdatePostInput, UpdateFacts> {
+    readonly params: {
+        readonly id: string;
+    };
+    readonly body: DeepReadonly<UpdatePostInput["data"]>;
+}
+/** Authorized context supplied before a Blog post is deleted. */
+interface BlogDeleteOperationContext extends BlogOperationContext<DeletePostInput, DeleteFacts> {
+    readonly params: {
+        readonly id: string;
+    };
+}
+/** Blog delete context after execution, including its success result. */
+interface BlogDeleteResultContext extends BlogDeleteOperationContext {
+    readonly result: {
+        readonly success: true;
+    };
+}
+/** Blog delete context supplied when authorized execution fails. */
+interface BlogDeleteErrorContext extends BlogOperationErrorContext<DeletePostInput, DeleteFacts> {
+    readonly params: {
+        readonly id: string;
+    };
+}
+/** Authorized context supplied before Blog navigation posts are queried. */
+interface BlogNextPreviousOperationContext extends BlogOperationContext<NextPreviousPostsInput, ReadFacts> {
+    readonly query: DeepReadonly<NextPreviousPostsInput>;
+}
+/** Blog navigation context after execution, including adjacent posts. */
+interface BlogNextPreviousResultContext extends BlogNextPreviousOperationContext {
+    readonly result: DeepReadonly<SerializedNextPreviousPostsResult>;
+}
+/** Blog navigation context supplied when authorized execution fails. */
+interface BlogNextPreviousErrorContext extends BlogOperationErrorContext<NextPreviousPostsInput, ReadFacts> {
+    readonly query: DeepReadonly<NextPreviousPostsInput>;
+}
+/** Domain lifecycle hooks that run only after successful Blog authorization. */
+interface BlogBackendHooks {
+    onBeforeListPosts?: (filter: DeepReadonly<ListPostsInput>, context: BlogListOperationContext) => Promise<void> | void;
+    onBeforeCreatePost?: (data: DeepReadonly<CreatePostInput>, context: BlogCreateOperationContext) => Promise<void> | void;
+    onBeforeUpdatePost?: (postId: string, data: DeepReadonly<UpdatePostInput["data"]>, context: BlogUpdateOperationContext) => Promise<void> | void;
+    onBeforeDeletePost?: (postId: string, context: BlogDeleteOperationContext) => Promise<void> | void;
+    onBeforeGetNextPreviousPosts?: (query: DeepReadonly<NextPreviousPostsInput>, context: BlogNextPreviousOperationContext) => Promise<void> | void;
+    onAfterListPosts?: (posts: readonly DeepReadonly<SerializedPost>[], filter: DeepReadonly<ListPostsInput>, context: BlogListResultContext) => Promise<void> | void;
+    onAfterCreatePost?: (post: DeepReadonly<SerializedPost>, context: BlogCreateResultContext) => Promise<void> | void;
+    onAfterUpdatePost?: (post: DeepReadonly<SerializedPost>, context: BlogUpdateResultContext) => Promise<void> | void;
+    onAfterDeletePost?: (postId: string, context: BlogDeleteResultContext) => Promise<void> | void;
+    onAfterGetNextPreviousPosts?: (result: DeepReadonly<SerializedNextPreviousPostsResult>, context: BlogNextPreviousResultContext) => Promise<void> | void;
+    onErrorListPosts?: (error: Error, context: BlogListErrorContext) => Promise<void> | void;
+    onErrorGetNextPreviousPosts?: (error: Error, context: BlogNextPreviousErrorContext) => Promise<void> | void;
+    onErrorCreatePost?: (error: Error, context: BlogCreateErrorContext) => Promise<void> | void;
+    onErrorUpdatePost?: (error: Error, context: BlogUpdateErrorContext) => Promise<void> | void;
+    onErrorDeletePost?: (error: Error, context: BlogDeleteErrorContext) => Promise<void> | void;
+}
+declare function serializeListResult(result: Awaited<ReturnType<typeof getAllPosts>>): {
+    offset?: number | undefined;
+    limit?: number | undefined;
+    items: {
+        tags: {
+            createdAt: string;
+            updatedAt: string;
+            id: string;
+            name: string;
+            slug: string;
+        }[];
+        publishedAt?: string;
+        createdAt: string;
+        updatedAt: string;
+        id: string;
+        slug: string;
+        title: string;
+        content: string;
+        excerpt: string;
+        image?: string | undefined;
+        published: boolean;
+        authorId?: string | undefined;
+        defaultLocale?: string | undefined;
+        status?: "DRAFT" | "PUBLISHED" | undefined;
+    }[];
+    total: number;
+};
+declare function findNextPreviousPosts(adapter: DBAdapter, date: Date): Promise<{
+    previous: {
+        tags: {
+            createdAt: string;
+            updatedAt: string;
+            id: string;
+            name: string;
+            slug: string;
+        }[];
+        publishedAt?: string;
+        createdAt: string;
+        updatedAt: string;
+        id: string;
+        slug: string;
+        title: string;
+        content: string;
+        excerpt: string;
+        image?: string | undefined;
+        published: boolean;
+        authorId?: string | undefined;
+        defaultLocale?: string | undefined;
+        status?: "DRAFT" | "PUBLISHED" | undefined;
+    } | null;
+    next: {
+        tags: {
+            createdAt: string;
+            updatedAt: string;
+            id: string;
+            name: string;
+            slug: string;
+        }[];
+        publishedAt?: string;
+        createdAt: string;
+        updatedAt: string;
+        id: string;
+        slug: string;
+        title: string;
+        content: string;
+        excerpt: string;
+        image?: string | undefined;
+        published: boolean;
+        authorId?: string | undefined;
+        defaultLocale?: string | undefined;
+        status?: "DRAFT" | "PUBLISHED" | undefined;
+    } | null;
+}>;
+
+/** Route keys returned by the Blog client plugin. */
+type BlogRouteKey = "posts" | "drafts" | "post" | "tag" | "newPost" | "editPost";
+interface BlogPrefetchForRoute {
+    (key: "posts" | "drafts" | "newPost", qc: QueryClient): Promise<void>;
+    (key: "post" | "editPost", qc: QueryClient, params: {
+        slug: string;
+    }): Promise<void>;
+    (key: "tag", qc: QueryClient, params: {
+        tagSlug: string;
+    }): Promise<void>;
+}
+/**
+ * Blog backend plugin. Every maintained HTTP endpoint adapts the same
+ * operation exposed by `forRequest(request).operations.blog` and `trusted.blog`.
+ */
+interface BlogBackendOptions {
+    /** Post-authorization domain lifecycle hooks. */
+    hooks?: BlogBackendHooks;
+}
+declare const blogBackendPlugin: (options?: BlogBackendOptions) => _btst_stack_plugins_api.BackendPlugin<{
+    readonly listPosts: better_call.StrictEndpoint<"/posts", {
+        requireRequest: true;
+    } & {
+        method: "GET";
+    } & {
+        query: better_call.StandardSchemaV1<{
+            slug?: string | undefined;
+            tagSlug?: string | undefined;
+            offset?: unknown;
+            limit?: unknown;
+            query?: string | undefined;
+            published?: boolean | "true" | "false" | undefined;
+        }, {
+            slug?: string | undefined;
+            tagSlug?: string | undefined;
+            offset?: unknown;
+            limit?: unknown;
+            query?: string | undefined;
+            published?: boolean | "true" | "false" | undefined;
+        }>;
+    }, {
+        readonly offset?: number | undefined;
+        readonly limit?: number | undefined;
+        readonly items: readonly {
+            readonly tags: readonly {
+                readonly createdAt: string;
+                readonly updatedAt: string;
+                readonly id: string;
+                readonly name: string;
+                readonly slug: string;
+            }[];
+            readonly publishedAt?: string | undefined;
+            readonly createdAt: string;
+            readonly updatedAt: string;
+            readonly id: string;
+            readonly slug: string;
+            readonly title: string;
+            readonly content: string;
+            readonly excerpt: string;
+            readonly image?: string | undefined;
+            readonly published: boolean;
+            readonly authorId?: string | undefined;
+            readonly defaultLocale?: string | undefined;
+            readonly status?: "DRAFT" | "PUBLISHED" | undefined;
+        }[];
+        readonly total: number;
+    }>;
+    readonly createPost: better_call.StrictEndpoint<"/posts", {
+        requireRequest: true;
+    } & {
+        method: "POST";
+        body: better_call.StandardSchemaV1<{
+            title: string;
+            content: string;
+            excerpt: string;
+            slug?: string | undefined;
+            image?: string | undefined;
+            published?: boolean | undefined;
+            tags?: ({
+                name: string;
+            } | {
+                id: string;
+                name: string;
+                slug: string;
+            })[] | undefined;
+            publishedAt?: unknown;
+            createdAt?: unknown;
+            updatedAt?: unknown;
+        }, {
+            title: string;
+            content: string;
+            excerpt: string;
+            slug?: string | undefined;
+            image?: string | undefined;
+            published?: boolean | undefined;
+            tags?: ({
+                name: string;
+            } | {
+                id: string;
+                name: string;
+                slug: string;
+            })[] | undefined;
+            publishedAt?: unknown;
+            createdAt?: unknown;
+            updatedAt?: unknown;
+        }>;
+    }, {
+        readonly tags: readonly {
+            readonly createdAt: string;
+            readonly updatedAt: string;
+            readonly id: string;
+            readonly name: string;
+            readonly slug: string;
+        }[];
+        readonly publishedAt?: string | undefined;
+        readonly createdAt: string;
+        readonly updatedAt: string;
+        readonly id: string;
+        readonly slug: string;
+        readonly title: string;
+        readonly content: string;
+        readonly excerpt: string;
+        readonly image?: string | undefined;
+        readonly published: boolean;
+        readonly authorId?: string | undefined;
+        readonly defaultLocale?: string | undefined;
+        readonly status?: "DRAFT" | "PUBLISHED" | undefined;
+    }>;
+    readonly updatePost: better_call.StrictEndpoint<"/posts/:id", {
+        requireRequest: true;
+    } & {
+        method: "PUT";
+        body: better_call.StandardSchemaV1<{
+            slug: string;
+            title: string;
+            content: string;
+            excerpt: string;
+            image?: string | undefined;
+            published?: boolean | undefined;
+            tags?: ({
+                name: string;
+            } | {
+                id: string;
+                name: string;
+                slug: string;
+            })[] | undefined;
+            publishedAt?: unknown;
+            createdAt?: unknown;
+            updatedAt?: unknown;
+        }, {
+            slug: string;
+            title: string;
+            content: string;
+            excerpt: string;
+            image?: string | undefined;
+            published?: boolean | undefined;
+            tags?: ({
+                name: string;
+            } | {
+                id: string;
+                name: string;
+                slug: string;
+            })[] | undefined;
+            publishedAt?: unknown;
+            createdAt?: unknown;
+            updatedAt?: unknown;
+        }>;
+    }, {
+        readonly tags: readonly {
+            readonly createdAt: string;
+            readonly updatedAt: string;
+            readonly id: string;
+            readonly name: string;
+            readonly slug: string;
+        }[];
+        readonly publishedAt?: string | undefined;
+        readonly createdAt: string;
+        readonly updatedAt: string;
+        readonly id: string;
+        readonly slug: string;
+        readonly title: string;
+        readonly content: string;
+        readonly excerpt: string;
+        readonly image?: string | undefined;
+        readonly published: boolean;
+        readonly authorId?: string | undefined;
+        readonly defaultLocale?: string | undefined;
+        readonly status?: "DRAFT" | "PUBLISHED" | undefined;
+    }>;
+    readonly deletePost: better_call.StrictEndpoint<"/posts/:id", {
+        requireRequest: true;
+    } & {
+        method: "DELETE";
+        body: better_call.StandardSchemaV1<unknown, unknown>;
+    }, {
+        readonly success: true;
+    }>;
+    readonly getNextPreviousPosts: better_call.StrictEndpoint<"/posts/next-previous", {
+        requireRequest: true;
+    } & {
+        method: "GET";
+    } & {
+        query: better_call.StandardSchemaV1<{
+            date: unknown;
+        }, {
+            date: unknown;
+        }>;
+    }, {
+        readonly previous: {
+            readonly tags: readonly {
+                readonly createdAt: string;
+                readonly updatedAt: string;
+                readonly id: string;
+                readonly name: string;
+                readonly slug: string;
+            }[];
+            readonly publishedAt?: string | undefined;
+            readonly createdAt: string;
+            readonly updatedAt: string;
+            readonly id: string;
+            readonly slug: string;
+            readonly title: string;
+            readonly content: string;
+            readonly excerpt: string;
+            readonly image?: string | undefined;
+            readonly published: boolean;
+            readonly authorId?: string | undefined;
+            readonly defaultLocale?: string | undefined;
+            readonly status?: "DRAFT" | "PUBLISHED" | undefined;
+        } | null;
+        readonly next: {
+            readonly tags: readonly {
+                readonly createdAt: string;
+                readonly updatedAt: string;
+                readonly id: string;
+                readonly name: string;
+                readonly slug: string;
+            }[];
+            readonly publishedAt?: string | undefined;
+            readonly createdAt: string;
+            readonly updatedAt: string;
+            readonly id: string;
+            readonly slug: string;
+            readonly title: string;
+            readonly content: string;
+            readonly excerpt: string;
+            readonly image?: string | undefined;
+            readonly published: boolean;
+            readonly authorId?: string | undefined;
+            readonly defaultLocale?: string | undefined;
+            readonly status?: "DRAFT" | "PUBLISHED" | undefined;
+        } | null;
+    }>;
+    readonly listTags: better_call.StrictEndpoint<"/tags", {
+        requireRequest: true;
+    } & {
+        method: "GET";
+    }, readonly {
+        readonly createdAt: string;
+        readonly updatedAt: string;
+        readonly id: string;
+        readonly name: string;
+        readonly slug: string;
+    }[]>;
+}, {
+    prefetchForRoute: BlogPrefetchForRoute;
+}, {
+    readonly listPosts: _btst_stack_plugins_api.Operation<zod.ZodObject<{
+        slug: zod.ZodOptional<zod.ZodString>;
+        tagSlug: zod.ZodOptional<zod.ZodString>;
+        offset: zod.ZodOptional<zod.ZodCoercedNumber<unknown>>;
+        limit: zod.ZodOptional<zod.ZodCoercedNumber<unknown>>;
+        query: zod.ZodOptional<zod.ZodString>;
+        published: zod.ZodPipe<zod.ZodOptional<zod.ZodUnion<readonly [zod.ZodBoolean, zod.ZodEnum<{
+            true: "true";
+            false: "false";
+        }>]>>, zod.ZodTransform<boolean | undefined, boolean | "true" | "false" | undefined>>;
+    }, zod_v4_core.$strip>, PermissionDescriptor<"blog:post.read", zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+        scope: zod.ZodLiteral<"published">;
+    }, zod_v4_core.$strip>, zod.ZodObject<{
+        scope: zod.ZodLiteral<"drafts">;
+    }, zod_v4_core.$strip>, zod.ZodObject<{
+        scope: zod.ZodLiteral<"post">;
+        slug: zod.ZodString;
+        exists: zod.ZodBoolean;
+        id: zod.ZodOptional<zod.ZodString>;
+        authorId: zod.ZodOptional<zod.ZodString>;
+        published: zod.ZodBoolean;
+    }, zod_v4_core.$strip>], "scope">>, {
+        offset?: number | undefined;
+        limit?: number | undefined;
+        items: {
+            tags: {
+                createdAt: string;
+                updatedAt: string;
+                id: string;
+                name: string;
+                slug: string;
+            }[];
+            publishedAt?: string;
+            createdAt: string;
+            updatedAt: string;
+            id: string;
+            slug: string;
+            title: string;
+            content: string;
+            excerpt: string;
+            image?: string | undefined;
+            published: boolean;
+            authorId?: string | undefined;
+            defaultLocale?: string | undefined;
+            status?: "DRAFT" | "PUBLISHED" | undefined;
+        }[];
+        total: number;
+    }, false>;
+    readonly createPost: _btst_stack_plugins_api.Operation<zod.ZodObject<{
+        slug: zod.ZodOptional<zod.ZodString>;
+        title: zod.ZodString;
+        content: zod.ZodString;
+        excerpt: zod.ZodString;
+        image: zod.ZodOptional<zod.ZodString>;
+        published: zod.ZodDefault<zod.ZodOptional<zod.ZodBoolean>>;
+        tags: zod.ZodDefault<zod.ZodOptional<zod.ZodArray<zod.ZodUnion<readonly [zod.ZodObject<{
+            name: zod.ZodString;
+        }, zod_v4_core.$strip>, zod.ZodObject<{
+            id: zod.ZodString;
+            name: zod.ZodString;
+            slug: zod.ZodString;
+        }, zod_v4_core.$strip>]>>>>;
+        publishedAt: zod.ZodOptional<zod.ZodPipe<zod.ZodCoercedDate<unknown>, zod.ZodTransform<string, Date>>>;
+        createdAt: zod.ZodOptional<zod.ZodPipe<zod.ZodCoercedDate<unknown>, zod.ZodTransform<string, Date>>>;
+        updatedAt: zod.ZodOptional<zod.ZodPipe<zod.ZodCoercedDate<unknown>, zod.ZodTransform<string, Date>>>;
+    }, zod_v4_core.$strip>, PermissionDescriptor<"blog:post.create", zod.ZodObject<{
+        publish: zod.ZodEnum<{
+            published: "published";
+            draft: "draft";
+        }>;
+    }, zod_v4_core.$strip>>, {
+        tags: {
+            createdAt: string;
+            updatedAt: string;
+            id: string;
+            name: string;
+            slug: string;
+        }[];
+        publishedAt?: string;
+        createdAt: string;
+        updatedAt: string;
+        id: string;
+        slug: string;
+        title: string;
+        content: string;
+        excerpt: string;
+        image?: string | undefined;
+        published: boolean;
+        authorId?: string | undefined;
+        defaultLocale?: string | undefined;
+        status?: "DRAFT" | "PUBLISHED" | undefined;
+    }, false>;
+    readonly updatePost: _btst_stack_plugins_api.Operation<zod.ZodObject<{
+        id: zod.ZodString;
+        data: zod.ZodObject<{
+            slug: zod.ZodString;
+            title: zod.ZodString;
+            content: zod.ZodString;
+            excerpt: zod.ZodString;
+            image: zod.ZodOptional<zod.ZodString>;
+            published: zod.ZodDefault<zod.ZodOptional<zod.ZodBoolean>>;
+            tags: zod.ZodDefault<zod.ZodOptional<zod.ZodArray<zod.ZodUnion<readonly [zod.ZodObject<{
+                name: zod.ZodString;
+            }, zod_v4_core.$strip>, zod.ZodObject<{
+                id: zod.ZodString;
+                name: zod.ZodString;
+                slug: zod.ZodString;
+            }, zod_v4_core.$strip>]>>>>;
+            publishedAt: zod.ZodOptional<zod.ZodPipe<zod.ZodCoercedDate<unknown>, zod.ZodTransform<string, Date>>>;
+            createdAt: zod.ZodOptional<zod.ZodPipe<zod.ZodCoercedDate<unknown>, zod.ZodTransform<string, Date>>>;
+            updatedAt: zod.ZodOptional<zod.ZodPipe<zod.ZodCoercedDate<unknown>, zod.ZodTransform<string, Date>>>;
+        }, zod_v4_core.$strip>;
+    }, zod_v4_core.$strip>, PermissionDescriptor<"blog:post.update", zod.ZodObject<{
+        id: zod.ZodString;
+        authorId: zod.ZodOptional<zod.ZodString>;
+        publish: zod.ZodEnum<{
+            publish: "publish";
+            unchanged: "unchanged";
+            unpublish: "unpublish";
+        }>;
+    }, zod_v4_core.$strip>>, {
+        tags: {
+            createdAt: string;
+            updatedAt: string;
+            id: string;
+            name: string;
+            slug: string;
+        }[];
+        publishedAt?: string;
+        createdAt: string;
+        updatedAt: string;
+        id: string;
+        slug: string;
+        title: string;
+        content: string;
+        excerpt: string;
+        image?: string | undefined;
+        published: boolean;
+        authorId?: string | undefined;
+        defaultLocale?: string | undefined;
+        status?: "DRAFT" | "PUBLISHED" | undefined;
+    }, false>;
+    readonly deletePost: _btst_stack_plugins_api.Operation<zod.ZodObject<{
+        id: zod.ZodString;
+    }, zod_v4_core.$strip>, PermissionDescriptor<"blog:post.delete", zod.ZodObject<{
+        id: zod.ZodString;
+        authorId: zod.ZodOptional<zod.ZodString>;
+    }, zod_v4_core.$strip>>, {
+        readonly success: true;
+    }, false>;
+    readonly getNextPreviousPosts: _btst_stack_plugins_api.Operation<zod.ZodObject<{
+        date: zod.ZodPipe<zod.ZodCoercedDate<unknown>, zod.ZodTransform<string, Date>>;
+    }, zod_v4_core.$strip>, PermissionDescriptor<"blog:post.read", zod.ZodDiscriminatedUnion<[zod.ZodObject<{
+        scope: zod.ZodLiteral<"published">;
+    }, zod_v4_core.$strip>, zod.ZodObject<{
+        scope: zod.ZodLiteral<"drafts">;
+    }, zod_v4_core.$strip>, zod.ZodObject<{
+        scope: zod.ZodLiteral<"post">;
+        slug: zod.ZodString;
+        exists: zod.ZodBoolean;
+        id: zod.ZodOptional<zod.ZodString>;
+        authorId: zod.ZodOptional<zod.ZodString>;
+        published: zod.ZodBoolean;
+    }, zod_v4_core.$strip>], "scope">>, {
+        previous: {
+            tags: {
+                createdAt: string;
+                updatedAt: string;
+                id: string;
+                name: string;
+                slug: string;
+            }[];
+            publishedAt?: string;
+            createdAt: string;
+            updatedAt: string;
+            id: string;
+            slug: string;
+            title: string;
+            content: string;
+            excerpt: string;
+            image?: string | undefined;
+            published: boolean;
+            authorId?: string | undefined;
+            defaultLocale?: string | undefined;
+            status?: "DRAFT" | "PUBLISHED" | undefined;
+        } | null;
+        next: {
+            tags: {
+                createdAt: string;
+                updatedAt: string;
+                id: string;
+                name: string;
+                slug: string;
+            }[];
+            publishedAt?: string;
+            createdAt: string;
+            updatedAt: string;
+            id: string;
+            slug: string;
+            title: string;
+            content: string;
+            excerpt: string;
+            image?: string | undefined;
+            published: boolean;
+            authorId?: string | undefined;
+            defaultLocale?: string | undefined;
+            status?: "DRAFT" | "PUBLISHED" | undefined;
+        } | null;
+    }, false>;
+    readonly listTags: _btst_stack_plugins_api.Operation<zod.ZodObject<{}, zod_v4_core.$strip>, PermissionDescriptor<"blog:tag.read", undefined>, {
+        createdAt: string;
+        updatedAt: string;
+        id: string;
+        name: string;
+        slug: string;
+    }[], false>;
+}, "blog">;
+type BlogApiRouter = ReturnType<ReturnType<typeof blogBackendPlugin>["routes"]>;
+
+/**
+ * Internal query key constants for the blog plugin.
+ * Shared between query-keys.ts (HTTP path) and prefetchForRoute (DB path)
+ * to prevent key drift between SSR loaders and SSG prefetching.
+ */
+interface PostsListDiscriminator {
+    query: string | undefined;
+    limit: number;
+    published: boolean;
+    tagSlug: string | undefined;
+}
+/** Full query key builders — use these with queryClient.setQueryData() */
+declare const BLOG_QUERY_KEYS: {
+    postsList: (params: {
+        published: boolean;
+        limit?: number;
+        tagSlug?: string;
+    }) => readonly ["posts", "list", PostsListDiscriminator];
+    postDetail: (slug: string) => readonly ["posts", "detail", string];
+    tagsList: () => readonly ["tags", "list", "tags"];
+};
+
+interface PostsListParams {
+    query?: string;
+    limit?: number;
+    published?: boolean;
+    tagSlug?: string;
+}
+type PostCreateInput = z.infer<typeof createPostSchema>;
+type PostUpdateInput = z.infer<typeof updatePostSchema>;
+/**
+ * Blog resource declaration — the single source of truth for query keys,
+ * HTTP mappings and mutations. Feeds both `createBlogQueryKeys` (SSR
+ * loaders) and `createResource` (client hooks, see `client/hooks`).
+ *
+ * Key shapes intentionally match `BLOG_QUERY_KEYS` in
+ * `api/query-key-defs.ts` so SSG `prefetchForRoute` hydration keeps working.
+ */
+declare const blogResources: {
+    posts: {
+        queries: {
+            list: {
+                path: string;
+                query: (params?: PostsListParams) => {
+                    query: string | undefined;
+                    limit: number;
+                    published: string | undefined;
+                    tagSlug: string | undefined;
+                };
+                key: (params?: PostsListParams) => PostsListDiscriminator[];
+                select: (data: any, _params?: PostsListParams) => SerializedPost[];
+                infinite: true;
+                pageSize: (params?: PostsListParams) => number;
+            };
+            detail: {
+                path: string;
+                query: (slug: string) => {
+                    slug: string;
+                    limit: number;
+                };
+                key: (slug: string) => string[];
+                select: (data: any, _slug: string) => SerializedPost | null;
+                skip: (slug: string) => boolean;
+            };
+            nextPrevious: {
+                path: string;
+                query: (date: Date | string) => {
+                    date: string;
+                };
+                key: (date: Date | string) => (string | Date)[];
+                select: (data: any, _date: Date | string) => {
+                    previous: SerializedPost | null;
+                    next: SerializedPost | null;
+                };
+            };
+            recent: {
+                path: string;
+                query: (params?: {
+                    limit?: number;
+                    excludeSlug?: string;
+                }) => {
+                    limit: number;
+                    published: string;
+                };
+                key: (params?: {
+                    limit?: number;
+                    excludeSlug?: string;
+                }) => (string | {
+                    limit?: number;
+                    excludeSlug?: string;
+                } | undefined)[];
+                select: (data: any, params?: {
+                    limit?: number;
+                    excludeSlug?: string;
+                }) => SerializedPost[];
+            };
+        };
+        mutations: {
+            create: {
+                path: string;
+                method: "POST";
+                input: (vars: PostCreateInput) => {
+                    body: {
+                        title: string;
+                        published: boolean;
+                        content: string;
+                        excerpt: string;
+                        tags: ({
+                            name: string;
+                        } | {
+                            id: string;
+                            name: string;
+                            slug: string;
+                        })[];
+                        slug?: string | undefined;
+                        publishedAt?: Date | undefined;
+                        createdAt?: Date | undefined;
+                        updatedAt?: Date | undefined;
+                        image?: string | undefined;
+                    };
+                };
+                select: (data: any) => SerializedPost | null;
+                invalidates: string[];
+                setData: {
+                    query: string;
+                    args: (created: SerializedPost | null) => string[] | null;
+                };
+            };
+            update: {
+                path: string;
+                method: "PUT";
+                input: (vars: {
+                    id: string;
+                    data: PostUpdateInput;
+                }) => {
+                    params: {
+                        id: string;
+                    };
+                    body: {
+                        title: string;
+                        content: string;
+                        excerpt: string;
+                        published: boolean;
+                        slug: string;
+                        tags: ({
+                            name: string;
+                        } | {
+                            id: string;
+                            name: string;
+                            slug: string;
+                        })[];
+                        id: string;
+                        publishedAt?: Date | undefined;
+                        createdAt?: Date | undefined;
+                        updatedAt?: Date | undefined;
+                        image?: string | undefined;
+                    };
+                };
+                select: (data: any) => SerializedPost | null;
+                invalidates: string[];
+                setData: {
+                    query: string;
+                    args: (updated: SerializedPost | null) => string[] | null;
+                };
+            };
+            delete: {
+                path: string;
+                method: "DELETE";
+                input: (vars: {
+                    id: string;
+                }) => {
+                    params: {
+                        id: string;
+                    };
+                };
+                select: (data: any) => {
+                    success: boolean;
+                };
+                invalidates: string[];
+            };
+        };
+    };
+    drafts: {
+        queries: {
+            list: {
+                path: string;
+                query: (params?: PostsListParams) => {
+                    query: string | undefined;
+                    limit: number;
+                    published: string;
+                };
+                key: (params?: PostsListParams) => {
+                    limit?: number | undefined;
+                }[];
+                select: (data: any, _params?: PostsListParams) => SerializedPost[];
+                infinite: true;
+                pageSize: (params?: PostsListParams) => number;
+            };
+        };
+    };
+    tags: {
+        queries: {
+            list: {
+                path: string;
+                key: () => string[];
+                select: (data: any) => SerializedTag[];
+            };
+        };
+    };
+};
+declare function createBlogQueryKeys(client: ReturnType<typeof createApiClient<BlogApiRouter>>, headers?: HeadersInit): _btst_stack_plugins_client.ResourceQueryKeys<{
+    posts: {
+        queries: {
+            list: {
+                path: string;
+                query: (params?: PostsListParams) => {
+                    query: string | undefined;
+                    limit: number;
+                    published: string | undefined;
+                    tagSlug: string | undefined;
+                };
+                key: (params?: PostsListParams) => PostsListDiscriminator[];
+                select: (data: any, _params?: PostsListParams) => SerializedPost[];
+                infinite: true;
+                pageSize: (params?: PostsListParams) => number;
+            };
+            detail: {
+                path: string;
+                query: (slug: string) => {
+                    slug: string;
+                    limit: number;
+                };
+                key: (slug: string) => string[];
+                select: (data: any, _slug: string) => SerializedPost | null;
+                skip: (slug: string) => boolean;
+            };
+            nextPrevious: {
+                path: string;
+                query: (date: Date | string) => {
+                    date: string;
+                };
+                key: (date: Date | string) => (string | Date)[];
+                select: (data: any, _date: Date | string) => {
+                    previous: SerializedPost | null;
+                    next: SerializedPost | null;
+                };
+            };
+            recent: {
+                path: string;
+                query: (params?: {
+                    limit?: number;
+                    excludeSlug?: string;
+                }) => {
+                    limit: number;
+                    published: string;
+                };
+                key: (params?: {
+                    limit?: number;
+                    excludeSlug?: string;
+                }) => (string | {
+                    limit?: number;
+                    excludeSlug?: string;
+                } | undefined)[];
+                select: (data: any, params?: {
+                    limit?: number;
+                    excludeSlug?: string;
+                }) => SerializedPost[];
+            };
+        };
+        mutations: {
+            create: {
+                path: string;
+                method: "POST";
+                input: (vars: PostCreateInput) => {
+                    body: {
+                        title: string;
+                        published: boolean;
+                        content: string;
+                        excerpt: string;
+                        tags: ({
+                            name: string;
+                        } | {
+                            id: string;
+                            name: string;
+                            slug: string;
+                        })[];
+                        slug?: string | undefined;
+                        publishedAt?: Date | undefined;
+                        createdAt?: Date | undefined;
+                        updatedAt?: Date | undefined;
+                        image?: string | undefined;
+                    };
+                };
+                select: (data: any) => SerializedPost | null;
+                invalidates: string[];
+                setData: {
+                    query: string;
+                    args: (created: SerializedPost | null) => string[] | null;
+                };
+            };
+            update: {
+                path: string;
+                method: "PUT";
+                input: (vars: {
+                    id: string;
+                    data: PostUpdateInput;
+                }) => {
+                    params: {
+                        id: string;
+                    };
+                    body: {
+                        title: string;
+                        content: string;
+                        excerpt: string;
+                        published: boolean;
+                        slug: string;
+                        tags: ({
+                            name: string;
+                        } | {
+                            id: string;
+                            name: string;
+                            slug: string;
+                        })[];
+                        id: string;
+                        publishedAt?: Date | undefined;
+                        createdAt?: Date | undefined;
+                        updatedAt?: Date | undefined;
+                        image?: string | undefined;
+                    };
+                };
+                select: (data: any) => SerializedPost | null;
+                invalidates: string[];
+                setData: {
+                    query: string;
+                    args: (updated: SerializedPost | null) => string[] | null;
+                };
+            };
+            delete: {
+                path: string;
+                method: "DELETE";
+                input: (vars: {
+                    id: string;
+                }) => {
+                    params: {
+                        id: string;
+                    };
+                };
+                select: (data: any) => {
+                    success: boolean;
+                };
+                invalidates: string[];
+            };
+        };
+    };
+    drafts: {
+        queries: {
+            list: {
+                path: string;
+                query: (params?: PostsListParams) => {
+                    query: string | undefined;
+                    limit: number;
+                    published: string;
+                };
+                key: (params?: PostsListParams) => {
+                    limit?: number | undefined;
+                }[];
+                select: (data: any, _params?: PostsListParams) => SerializedPost[];
+                infinite: true;
+                pageSize: (params?: PostsListParams) => number;
+            };
+        };
+    };
+    tags: {
+        queries: {
+            list: {
+                path: string;
+                key: () => string[];
+                select: (data: any) => SerializedTag[];
+            };
+        };
+    };
+}>;
+
+export { getPostBySlug as A, BLOG_QUERY_KEYS as B, CreatePostOperationInputSchema as C, blogResources as D, NextPreviousPostsQuerySchema as N, UpdatePostOperationInputSchema as U, PostListQuerySchema as t, blogBackendPlugin as w, createBlogQueryKeys as x, getAllPosts as y, getAllTags as z };
+export type { PostListParams as P, SerializedNextPreviousPostsResult as S, BlogApiRouter as a, BlogBackendHooks as b, BlogBackendOptions as c, BlogCreateErrorContext as d, BlogCreateOperationContext as e, BlogCreateResultContext as f, BlogDeleteErrorContext as g, BlogDeleteOperationContext as h, BlogDeleteResultContext as i, BlogListErrorContext as j, BlogListOperationContext as k, BlogListResultContext as l, BlogNextPreviousErrorContext as m, BlogNextPreviousOperationContext as n, BlogNextPreviousResultContext as o, BlogRouteKey as p, BlogUpdateErrorContext as q, BlogUpdateOperationContext as r, BlogUpdateResultContext as s, PostListResult as u, SerializedPostListResult as v };