@btst/stack 2.6.2 → 2.8.0

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

@@ -0,0 +1,335 @@
+import * as _btst_stack_plugins_api from '@btst/stack/plugins/api';
+import { d as Comment, S as SerializedComment, C as CommentListResult } from './stack.C-b3Sn8j.cjs';
+import * as better_call from 'better-call';
+import { z } from 'zod';
+
+/**
+ * Schema for the POST /comments request body.
+ * authorId is intentionally absent — the server resolves identity from the
+ * session inside onBeforePost and injects it. Never trust authorId from the
+ * client body.
+ */
+declare const createCommentSchema: z.ZodObject<{
+    resourceId: z.ZodString;
+    resourceType: z.ZodString;
+    parentId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    body: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Schema for GET /comments query parameters.
+ *
+ * `currentUserId` is intentionally absent — it is never accepted from the client.
+ * The server always resolves the caller's identity via the `resolveCurrentUserId`
+ * hook and injects it internally. Accepting it from the client would allow any
+ * anonymous caller to supply an arbitrary user ID and read that user's pending
+ * (pre-moderation) comments.
+ */
+declare const CommentListQuerySchema: z.ZodObject<{
+    resourceId: z.ZodOptional<z.ZodString>;
+    resourceType: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        pending: "pending";
+        approved: "approved";
+        spam: "spam";
+    }>>;
+    authorId: z.ZodOptional<z.ZodString>;
+    sort: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+/**
+ * Internal params schema used by `listComments()` and the `api` factory.
+ * Extends the HTTP query schema with `currentUserId`, which is always injected
+ * server-side (either by the HTTP handler via `resolveCurrentUserId`, or by a
+ * trusted server-side caller such as a Server Component or cron job).
+ */
+declare const CommentListParamsSchema: z.ZodObject<{
+    resourceId: z.ZodOptional<z.ZodString>;
+    resourceType: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        pending: "pending";
+        approved: "approved";
+        spam: "spam";
+    }>>;
+    authorId: z.ZodOptional<z.ZodString>;
+    sort: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    currentUserId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const CommentCountQuerySchema: z.ZodObject<{
+    resourceId: z.ZodString;
+    resourceType: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        pending: "pending";
+        approved: "approved";
+        spam: "spam";
+    }>>;
+}, z.core.$strip>;
+
+/**
+ * Context passed to comments API hooks
+ */
+interface CommentsApiContext {
+    body?: unknown;
+    params?: unknown;
+    query?: unknown;
+    request?: Request;
+    headers?: Headers;
+    [key: string]: unknown;
+}
+/** Shared hook and config fields that are always present regardless of allowPosting. */
+interface CommentsBackendOptionsBase {
+    /**
+     * When true, new comments are automatically approved (status: "approved").
+     * Default: false — all comments start as "pending" until a moderator approves.
+     */
+    autoApprove?: boolean;
+    /**
+     * When false, the `PATCH /comments/:id` endpoint is not registered and
+     * comment bodies cannot be edited.
+     * Default: true.
+     */
+    allowEditing?: boolean;
+    /**
+     * Server-side user resolution hook. Called once per unique authorId when
+     * serving GET /comments. Return null for deleted/unknown users (shown as "[deleted]").
+     * Deduplicates lookups — each unique authorId is resolved only once per request.
+     */
+    resolveUser?: (authorId: string) => Promise<{
+        name: string;
+        avatarUrl?: string;
+    } | null>;
+    /**
+     * Called before the comment list or count is returned. Throw to reject.
+     * When this hook is absent, any request with `status` other than "approved"
+     * is automatically rejected with 403 on both `GET /comments` and
+     * `GET /comments/count` — preventing anonymous callers from reading or
+     * probing the pending/spam moderation queues. Configure this hook to
+     * authorize admin callers (e.g. check session role).
+     */
+    onBeforeList?: (query: z.infer<typeof CommentListQuerySchema>, context: CommentsApiContext) => Promise<void> | void;
+    /**
+     * Called after a comment is successfully created.
+     */
+    onAfterPost?: (comment: Comment, context: CommentsApiContext) => Promise<void> | void;
+    /**
+     * Called before a comment body is edited. Throw an error to reject the edit.
+     * Use this to enforce that only the comment owner can edit (compare authorId to session).
+     */
+    onBeforeEdit?: (commentId: string, update: {
+        body: string;
+    }, context: CommentsApiContext) => Promise<void> | void;
+    /**
+     * Called after a comment is successfully edited.
+     */
+    onAfterEdit?: (comment: Comment, context: CommentsApiContext) => Promise<void> | void;
+    /**
+     * Called before a like is toggled. Throw to reject.
+     *
+     * When this hook is **absent**, any like/unlike request is automatically
+     * rejected with 403 — preventing unauthenticated callers from toggling likes
+     * on behalf of arbitrary user IDs. Configure this hook to verify `authorId`
+     * matches the authenticated session.
+     */
+    onBeforeLike?: (commentId: string, authorId: string, context: CommentsApiContext) => Promise<void> | void;
+    /**
+     * Called before a comment's status is changed. Throw to reject.
+     *
+     * When this hook is **absent**, any status-change request is automatically
+     * rejected with 403 — preventing unauthenticated callers from moderating
+     * comments. Configure this hook to verify the caller has admin/moderator
+     * privileges.
+     */
+    onBeforeStatusChange?: (commentId: string, status: "pending" | "approved" | "spam", context: CommentsApiContext) => Promise<void> | void;
+    /**
+     * Called after a comment status is changed to "approved".
+     */
+    onAfterApprove?: (comment: Comment, context: CommentsApiContext) => Promise<void> | void;
+    /**
+     * Called before a comment is deleted. Throw to reject.
+     *
+     * When this hook is **absent**, any delete request is automatically rejected
+     * with 403 — preventing unauthenticated callers from deleting comments.
+     * Configure this hook to enforce admin-only access.
+     */
+    onBeforeDelete?: (commentId: string, context: CommentsApiContext) => Promise<void> | void;
+    /**
+     * Called after a comment is deleted.
+     */
+    onAfterDelete?: (commentId: string, context: CommentsApiContext) => Promise<void> | void;
+    /**
+     * Called before the comment list is returned for an author-scoped query
+     * (i.e. when `authorId` is present in `GET /comments`). Throw to reject.
+     *
+     * When this hook is **absent**, any request that includes `authorId` is
+     * automatically rejected with 403 — preventing anonymous callers from
+     * reading or probing any user's comment history.
+     */
+    onBeforeListByAuthor?: (authorId: string, query: z.infer<typeof CommentListQuerySchema>, context: CommentsApiContext) => Promise<void> | void;
+}
+/**
+ * Configuration options for the comments backend plugin.
+ *
+ * TypeScript enforces the security-critical hooks based on `allowPosting`:
+ * - When `allowPosting` is absent or `true`, `onBeforePost` and
+ *   `resolveCurrentUserId` are **required**.
+ * - When `allowPosting` is `false`, both become optional (the POST endpoint
+ *   is not registered so neither hook is ever called).
+ */
+type CommentsBackendOptions = CommentsBackendOptionsBase & ({
+    /**
+     * Posting is enabled (default). `onBeforePost` and `resolveCurrentUserId`
+     * are required to prevent anonymous authorship and impersonation.
+     */
+    allowPosting?: true;
+    /**
+     * Called before a comment is created. Must return `{ authorId: string }` —
+     * the server-resolved identity of the commenter.
+     *
+     * ⚠️  SECURITY REQUIRED: Derive `authorId` from the authenticated session
+     * (e.g. JWT / session cookie). Never trust any ID supplied by the client.
+     * Throw to reject the request (e.g. when the user is not authenticated).
+     *
+     * `authorId` is intentionally absent from the POST body schema. This hook
+     * is the only place it can be set.
+     */
+    onBeforePost: (input: z.infer<typeof createCommentSchema>, context: CommentsApiContext) => Promise<{
+        authorId: string;
+    }> | {
+        authorId: string;
+    };
+    /**
+     * Resolve the current authenticated user's ID from the request context
+     * (e.g. session cookie or JWT). Used to include the user's own pending
+     * comments alongside approved ones in `GET /comments` responses so they
+     * remain visible immediately after posting.
+     *
+     * Return `null` or `undefined` for unauthenticated requests.
+     *
+     * ```ts
+     * resolveCurrentUserId: async (ctx) => {
+     *   const session = await getSession(ctx.headers)
+     *   return session?.user?.id ?? null
+     * }
+     * ```
+     */
+    resolveCurrentUserId: (context: CommentsApiContext) => Promise<string | null | undefined> | string | null | undefined;
+} | {
+    /**
+     * When `false`, the `POST /comments` endpoint is not registered.
+     * No new comments or replies can be submitted — users can only read
+     * existing comments. `onBeforePost` and `resolveCurrentUserId` become
+     * optional because they are never called.
+     */
+    allowPosting: false;
+    onBeforePost?: (input: z.infer<typeof createCommentSchema>, context: CommentsApiContext) => Promise<{
+        authorId: string;
+    }> | {
+        authorId: string;
+    };
+    resolveCurrentUserId?: (context: CommentsApiContext) => Promise<string | null | undefined> | string | null | undefined;
+});
+declare const commentsBackendPlugin: (options: CommentsBackendOptions) => _btst_stack_plugins_api.BackendPlugin<{
+    readonly getCommentCount: better_call.StrictEndpoint<"/comments/count", {} & {
+        method: "GET";
+    } & {
+        query: better_call.StandardSchemaV1<{
+            resourceId: string;
+            resourceType: string;
+            status?: "pending" | "approved" | "spam" | undefined;
+        }, {
+            resourceId: string;
+            resourceType: string;
+            status?: "pending" | "approved" | "spam" | undefined;
+        }>;
+    }, {
+        count: number;
+    }>;
+    readonly toggleLike: better_call.StrictEndpoint<"/comments/:id/like", {} & {
+        method: "POST";
+        body: better_call.StandardSchemaV1<{
+            authorId: string;
+        }, {
+            authorId: string;
+        }>;
+    }, {
+        likes: number;
+        isLiked: boolean;
+    }>;
+    readonly updateCommentStatus: better_call.StrictEndpoint<"/comments/:id/status", {} & {
+        method: "PATCH";
+        body: better_call.StandardSchemaV1<{
+            status: "pending" | "approved" | "spam";
+        }, {
+            status: "pending" | "approved" | "spam";
+        }>;
+    }, SerializedComment>;
+    readonly deleteComment: better_call.StrictEndpoint<"/comments/:id", {} & {
+        method: "DELETE";
+        body: better_call.StandardSchemaV1<unknown, unknown>;
+    }, {
+        success: boolean;
+    }>;
+    readonly updateComment?: better_call.StrictEndpoint<"/comments/:id", {} & {
+        method: "PATCH";
+        body: better_call.StandardSchemaV1<{
+            body: string;
+        }, {
+            body: string;
+        }>;
+    }, SerializedComment> | undefined;
+    readonly createComment?: better_call.StrictEndpoint<"/comments", {} & {
+        method: "POST";
+        body: better_call.StandardSchemaV1<{
+            resourceId: string;
+            resourceType: string;
+            body: string;
+            parentId?: string | null | undefined;
+        }, {
+            resourceId: string;
+            resourceType: string;
+            body: string;
+            parentId?: string | null | undefined;
+        }>;
+    }, SerializedComment> | undefined;
+    readonly listComments: better_call.StrictEndpoint<"/comments", {} & {
+        method: "GET";
+    } & {
+        query: better_call.StandardSchemaV1<{
+            resourceId?: string | undefined;
+            resourceType?: string | undefined;
+            parentId?: string | null | undefined;
+            status?: "pending" | "approved" | "spam" | undefined;
+            authorId?: string | undefined;
+            sort?: "asc" | "desc" | undefined;
+            limit?: unknown;
+            offset?: unknown;
+        }, {
+            resourceId?: string | undefined;
+            resourceType?: string | undefined;
+            parentId?: string | null | undefined;
+            status?: "pending" | "approved" | "spam" | undefined;
+            authorId?: string | undefined;
+            sort?: "asc" | "desc" | undefined;
+            limit?: unknown;
+            offset?: unknown;
+        }>;
+    }, CommentListResult>;
+}, {
+    listComments: (params: z.infer<typeof CommentListParamsSchema>) => Promise<CommentListResult>;
+    getCommentById: (id: string, currentUserId?: string) => Promise<SerializedComment | null>;
+    getCommentCount: (params: z.infer<typeof CommentCountQuerySchema>) => Promise<number>;
+}>;
+type CommentsApiRouter = ReturnType<ReturnType<typeof commentsBackendPlugin>["routes"]>;
+
+export { CommentListParamsSchema as a, CommentCountQuerySchema as b, commentsBackendPlugin as c };
+export type { CommentsApiRouter as C, CommentsApiContext as d, CommentsBackendOptions as e };

package/dist/shared/{stack.BgTmujxW.d.mts → stack.D88yU4FT.d.mts}

@@ -1,8 +1,8 @@
 import * as _btst_stack_plugins_api from '@btst/stack/plugins/api';
-import * as better_call from 'better-call';
 import { S as SerializedForm, b as SerializedFormSubmissionWithData, F as Form, d as FormSubmission, a as SerializedFormSubmission, e as FormSubmissionWithForm, f as FormBuilderBackendConfig } from './stack.BozPgbrZ.mjs';
+import * as better_call from 'better-call';
 import { z } from 'zod';
-import { Adapter } from '@btst/db';
+import { DBAdapter } from '@btst/db';
 import { QueryClient } from '@tanstack/react-query';
 
 /**
@@ -30,7 +30,7 @@ declare function serializeFormSubmissionWithData(submission: FormSubmissionWithF
  * @param adapter - The database adapter
  * @param params - Optional filter/pagination parameters
  */
-declare function getAllForms(adapter: Adapter, params?: {
+declare function getAllForms(adapter: DBAdapter, params?: {
     status?: string;
     limit?: number;
     offset?: number;
@@ -51,7 +51,7 @@ declare function getAllForms(adapter: Adapter, params?: {
  * @param adapter - The database adapter
  * @param id - The form UUID
  */
-declare function getFormById(adapter: Adapter, id: string): Promise<SerializedForm | null>;
+declare function getFormById(adapter: DBAdapter, id: string): Promise<SerializedForm | null>;
 /**
  * Retrieve a single form by its slug.
  * Returns null if the form is not found.
@@ -63,7 +63,7 @@ declare function getFormById(adapter: Adapter, id: string): Promise<SerializedFo
  * @param adapter - The database adapter
  * @param slug - The form slug
  */
-declare function getFormBySlug(adapter: Adapter, slug: string): Promise<SerializedForm | null>;
+declare function getFormBySlug(adapter: DBAdapter, slug: string): Promise<SerializedForm | null>;
 /**
  * Retrieve submissions for a form by form ID, with optional pagination.
  * Returns an empty result if the form does not exist.
@@ -76,7 +76,7 @@ declare function getFormBySlug(adapter: Adapter, slug: string): Promise<Serializ
  * @param formId - The form ID
  * @param params - Optional pagination parameters
  */
-declare function getFormSubmissions(adapter: Adapter, formId: string, params?: {
+declare function getFormSubmissions(adapter: DBAdapter, formId: string, params?: {
     limit?: number;
     offset?: number;
 }): Promise<{
@@ -104,17 +104,18 @@ interface FormBuilderPrefetchForRoute {
  * @param config - Configuration with optional hooks
  */
 declare const formBuilderBackendPlugin: (config?: FormBuilderBackendConfig) => _btst_stack_plugins_api.BackendPlugin<{
-    listForms: better_call.StrictEndpoint<"/forms", {
+    listForms: better_call.StrictEndpoint<"/forms", {} & {
         method: "GET";
-        query: z.ZodObject<{
-            status: z.ZodOptional<z.ZodEnum<{
-                active: "active";
-                inactive: "inactive";
-                archived: "archived";
-            }>>;
-            limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
-            offset: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
-        }, z.core.$strip>;
+    } & {
+        query: better_call.StandardSchemaV1<{
+            status?: "active" | "inactive" | "archived" | undefined;
+            limit?: unknown;
+            offset?: unknown;
+        }, {
+            status?: "active" | "inactive" | "archived" | undefined;
+            limit?: unknown;
+            offset?: unknown;
+        }>;
     }, {
         items: SerializedForm[];
         total: number;
@@ -122,68 +123,88 @@ declare const formBuilderBackendPlugin: (config?: FormBuilderBackendConfig) => _
         offset?: number;
     }>;
     getFormBySlug: better_call.StrictEndpoint<"/forms/:slug", {
-        method: "GET";
         params: z.ZodObject<{
             slug: z.ZodString;
         }, z.core.$strip>;
+    } & {
+        method: "GET";
     }, SerializedForm>;
     getFormById: better_call.StrictEndpoint<"/forms/id/:id", {
-        method: "GET";
         params: z.ZodObject<{
             id: z.ZodString;
         }, z.core.$strip>;
+    } & {
+        method: "GET";
     }, SerializedForm>;
-    createForm: better_call.StrictEndpoint<"/forms", {
+    createForm: better_call.StrictEndpoint<"/forms", {} & {
         method: "POST";
-        body: z.ZodObject<{
-            name: z.ZodString;
-            slug: z.ZodString;
-            description: z.ZodOptional<z.ZodString>;
-            schema: z.ZodString;
-            successMessage: z.ZodOptional<z.ZodString>;
-            redirectUrl: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
-            status: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-                active: "active";
-                inactive: "inactive";
-                archived: "archived";
-            }>>>;
-        }, z.core.$strip>;
+        body: better_call.StandardSchemaV1<{
+            name: string;
+            slug: string;
+            schema: string;
+            description?: string | undefined;
+            successMessage?: string | undefined;
+            redirectUrl?: string | undefined;
+            status?: "active" | "inactive" | "archived" | undefined;
+        }, {
+            name: string;
+            slug: string;
+            schema: string;
+            description?: string | undefined;
+            successMessage?: string | undefined;
+            redirectUrl?: string | undefined;
+            status?: "active" | "inactive" | "archived" | undefined;
+        }>;
     }, SerializedForm>;
     updateForm: better_call.StrictEndpoint<"/forms/:id", {
-        method: "PUT";
         params: z.ZodObject<{
             id: z.ZodString;
         }, z.core.$strip>;
-        body: z.ZodObject<{
-            name: z.ZodOptional<z.ZodString>;
-            slug: z.ZodOptional<z.ZodString>;
-            description: z.ZodOptional<z.ZodString>;
-            schema: z.ZodOptional<z.ZodString>;
-            successMessage: z.ZodOptional<z.ZodString>;
-            redirectUrl: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
-            status: z.ZodOptional<z.ZodEnum<{
-                active: "active";
-                inactive: "inactive";
-                archived: "archived";
-            }>>;
-        }, z.core.$strip>;
+    } & {
+        method: "PUT";
+        body: better_call.StandardSchemaV1<{
+            name?: string | undefined;
+            slug?: string | undefined;
+            description?: string | undefined;
+            schema?: string | undefined;
+            successMessage?: string | undefined;
+            redirectUrl?: string | undefined;
+            status?: "active" | "inactive" | "archived" | undefined;
+        }, {
+            name?: string | undefined;
+            slug?: string | undefined;
+            description?: string | undefined;
+            schema?: string | undefined;
+            successMessage?: string | undefined;
+            redirectUrl?: string | undefined;
+            status?: "active" | "inactive" | "archived" | undefined;
+        }>;
     }, SerializedForm>;
     deleteForm: better_call.StrictEndpoint<"/forms/:id", {
-        method: "DELETE";
         params: z.ZodObject<{
             id: z.ZodString;
         }, z.core.$strip>;
+    } & {
+        method: "DELETE";
+        body: better_call.StandardSchemaV1<unknown, unknown>;
     }, {
         success: boolean;
     }>;
     submitForm: better_call.StrictEndpoint<"/forms/:slug/submit", {
-        method: "POST";
         params: z.ZodObject<{
             slug: z.ZodString;
         }, z.core.$strip>;
-        body: z.ZodObject<{
-            data: z.ZodObject<{}, z.core.$loose>;
-        }, z.core.$strip>;
+    } & {
+        method: "POST";
+        body: better_call.StandardSchemaV1<{
+            data: {
+                [x: string]: unknown;
+            };
+        }, {
+            data: {
+                [x: string]: unknown;
+            };
+        }>;
     }, {
         form: {
             successMessage: string | undefined;
@@ -198,14 +219,19 @@ declare const formBuilderBackendPlugin: (config?: FormBuilderBackendConfig) => _
         userAgent?: string | undefined;
     }>;
     listSubmissions: better_call.StrictEndpoint<"/forms/:formId/submissions", {
-        method: "GET";
         params: z.ZodObject<{
             formId: z.ZodString;
         }, z.core.$strip>;
-        query: z.ZodObject<{
-            limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
-            offset: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
-        }, z.core.$strip>;
+    } & {
+        method: "GET";
+    } & {
+        query: better_call.StandardSchemaV1<{
+            limit?: unknown;
+            offset?: unknown;
+        }, {
+            limit?: unknown;
+            offset?: unknown;
+        }>;
     }, {
         items: SerializedFormSubmissionWithData[];
         total: number;
@@ -213,18 +239,21 @@ declare const formBuilderBackendPlugin: (config?: FormBuilderBackendConfig) => _
         offset?: number;
     }>;
     getSubmission: better_call.StrictEndpoint<"/forms/:formId/submissions/:subId", {
-        method: "GET";
         params: z.ZodObject<{
             formId: z.ZodString;
             subId: z.ZodString;
         }, z.core.$strip>;
+    } & {
+        method: "GET";
     }, SerializedFormSubmissionWithData<Record<string, unknown>>>;
     deleteSubmission: better_call.StrictEndpoint<"/forms/:formId/submissions/:subId", {
-        method: "DELETE";
         params: z.ZodObject<{
             formId: z.ZodString;
             subId: z.ZodString;
         }, z.core.$strip>;
+    } & {
+        method: "DELETE";
+        body: better_call.StandardSchemaV1<unknown, unknown>;
     }, {
         success: boolean;
     }>;

package/dist/shared/{stack.DVtk5CNw.d.mts → stack.DLPa6Gzm.d.mts}

@@ -1,4 +1,4 @@
-import { C as ComponentLayer, V as Variable } from './stack.B1srlBud.mjs';
+import { C as ComponentLayer, V as Variable } from './stack.BFoBvGML.mjs';
 
 /**
  * UI Builder Page data structure

package/dist/shared/{stack.BAT540yW.d.ts → stack.DOZ1EXjM.d.mts}

@@ -1,5 +1,5 @@
 import * as _tanstack_react_query from '@tanstack/react-query';
-import { S as SerializedPost, c as createPostSchema, u as updatePostSchema, a as SerializedTag } from './stack.BQmuNl5p.js';
+import { S as SerializedPost, c as createPostSchema, u as updatePostSchema, a as SerializedTag } from './stack.BWp0hcm9.mjs';
 import { z } from 'zod';
 
 /**
@@ -135,14 +135,14 @@ declare function useCreatePost(): _tanstack_react_query.UseMutationResult<Serial
         name: string;
         slug: string;
     })[];
+    published: boolean;
     title: string;
     content: string;
     excerpt: string;
-    published: boolean;
     slug?: string | undefined;
+    publishedAt?: Date | undefined;
     createdAt?: Date | undefined;
     updatedAt?: Date | undefined;
-    publishedAt?: Date | undefined;
     image?: string | undefined;
 }, unknown>;
 /** Update an existing post by id */
@@ -184,13 +184,10 @@ interface UseNextPreviousPostsResult {
     refetch: () => void;
 }
 /**
- * Hook for fetching previous and next posts relative to a given date
- * Uses useInView to only fetch when the component is in view
+ * Hook for fetching previous and next posts relative to a given date.
+ * Pair with `<WhenVisible>` in the render tree for lazy loading.
  */
-declare function useNextPreviousPosts(createdAt: string | Date, options?: UseNextPreviousPostsOptions): UseNextPreviousPostsResult & {
-    ref: (node: Element | null) => void;
-    inView: boolean;
-};
+declare function useNextPreviousPosts(createdAt: string | Date, options?: UseNextPreviousPostsOptions): UseNextPreviousPostsResult;
 /**
  * Options for the useRecentPosts hook
  */
@@ -216,13 +213,10 @@ interface UseRecentPostsResult {
     refetch: () => void;
 }
 /**
- * Hook for fetching recent posts
- * Uses useInView to only fetch when the component is in view
+ * Hook for fetching recent posts.
+ * Pair with `<WhenVisible>` in the render tree for lazy loading.
  */
-declare function useRecentPosts(options?: UseRecentPostsOptions): UseRecentPostsResult & {
-    ref: (node: Element | null) => void;
-    inView: boolean;
-};
+declare function useRecentPosts(options?: UseRecentPostsOptions): UseRecentPostsResult;
 
 export { useSuspensePosts as f, usePost as g, useSuspensePost as h, useTags as i, useSuspenseTags as j, useCreatePost as k, useUpdatePost as l, useDeletePost as m, usePostSearch as n, useNextPreviousPosts as q, useRecentPosts as t, usePosts as u };
 export type { PostCreateInput as P, UsePostsOptions as U, UsePostsResult as a, UsePostSearchOptions as b, UsePostSearchResult as c, UsePostResult as d, PostUpdateInput as e, UseNextPreviousPostsOptions as o, UseNextPreviousPostsResult as p, UseRecentPostsOptions as r, UseRecentPostsResult as s };