@btst/stack 2.12.2 → 3.0.0-rc.1

package/dist/plugins/cms/query-keys.d.cts

@@ -1,464 +1,449 @@
-import * as _btst_stack_plugins_api from '@btst/stack/plugins/api';
-import { a as SerializedContentItemWithType, S as SerializedContentType, b as ContentType, c as ContentItem, d as SerializedContentItem, e as ContentItemWithType, f as CMSBackendConfig, I as InverseRelation, P as PaginatedContentItems } from '../../shared/stack.DFtpFS00.cjs';
-import * as better_call from 'better-call';
-import { z } from 'zod';
-import { DBAdapter } from '@btst/db';
-import * as _tanstack_react_query from '@tanstack/react-query';
-import { QueryClient } from '@tanstack/react-query';
+import { a as CMSApiRouter, C as ContentListDiscriminator } from '../../shared/stack.BvxHSZYT.cjs';
+import * as _btst_stack_plugins_client from '@btst/stack/plugins/client';
 import { createApiClient } from '@btst/stack/plugins/client';
+import { S as SerializedContentType, I as InverseRelation, a as SerializedContentItemWithType, P as PaginatedContentItems } from '../../shared/stack.aXdBOJAR.cjs';
+import '@btst/stack/plugins/api';
+import 'better-call';
+import 'zod';
+import '@btst/db';
+import '@tanstack/react-query';
 
-/**
- * Serialize a ContentType for SSR/SSG use (convert dates to strings).
- * Applies lazy migration for legacy schemas (version 1 → 2).
- */
-declare function serializeContentType(ct: ContentType): SerializedContentType;
-/**
- * Serialize a ContentItem for SSR/SSG use (convert dates to strings).
- */
-declare function serializeContentItem(item: ContentItem): SerializedContentItem;
-/**
- * Serialize a ContentItem with parsed data and joined ContentType.
- * Throws a SyntaxError if `item.data` is not valid JSON, so corrupted rows
- * produce a visible, debuggable error rather than silently returning null.
- */
-declare function serializeContentItemWithType(item: ContentItemWithType): SerializedContentItemWithType;
-/**
- * Retrieve all content types.
- * Pure DB function — no hooks, no HTTP context. Safe for SSG and server-side use.
- *
- * @remarks **Security:** Authorization hooks are NOT called. The caller is
- * responsible for any access-control checks before invoking this function.
- *
- * @param adapter - The database adapter
- */
-declare function getAllContentTypes(adapter: DBAdapter): Promise<SerializedContentType[]>;
-/**
- * Retrieve all content items for a given content type, with optional pagination.
- * Pure DB function — no hooks, no HTTP context. Safe for SSG and server-side use.
- *
- * @remarks **Security:** Authorization hooks (e.g. `onBeforeListItems`) are NOT
- * called. The caller is responsible for any access-control checks before
- * invoking this function.
- *
- * @param adapter - The database adapter
- * @param contentTypeSlug - The slug of the content type to query
- * @param params - Optional filter/pagination parameters
- */
-declare function getAllContentItems(adapter: DBAdapter, contentTypeSlug: string, params?: {
-    slug?: string;
+/** Params for the paginated content list (one page per `limit`). */
+interface ContentListParams {
+    typeSlug: string;
     limit?: number;
+    /**
+     * Included in the query key discriminator for compatibility with
+     * callers that pass it explicitly; the infinite query itself injects
+     * the page offset per page (always starting at 0).
+     */
     offset?: number;
-}): Promise<{
-    items: SerializedContentItemWithType[];
-    total: number;
+    /** Free-text search across item slugs and data values */
+    search?: string;
+}
+interface ContentOptionsParams {
+    typeSlug: string;
+    search?: string;
     limit?: number;
-    offset?: number;
-}>;
-/**
- * Retrieve a single content item by its ID.
- * Returns null if the item is not found.
- * Pure DB function — no hooks, no HTTP context. Safe for SSG and server-side use.
- *
- * @remarks **Security:** Authorization hooks are NOT called. The caller is
- * responsible for any access-control checks before invoking this function.
- *
- * @param adapter - The database adapter
- * @param id - The content item ID (UUID)
- */
-declare function getContentItemById(adapter: DBAdapter, id: string): Promise<SerializedContentItemWithType | null>;
-/**
- * Retrieve a single content item by its slug within a content type.
- * Returns null if the content type or item is not found.
- * Pure DB function — no hooks, no HTTP context. Safe for SSG and server-side use.
- *
- * @remarks **Security:** Authorization hooks are NOT called. The caller is
- * responsible for any access-control checks before invoking this function.
- *
- * @param adapter - The database adapter
- * @param contentTypeSlug - The slug of the content type
- * @param slug - The slug of the content item
- */
-declare function getContentItemBySlug(adapter: DBAdapter, contentTypeSlug: string, slug: string): Promise<SerializedContentItemWithType | null>;
-
-/**
- * Input for creating a new CMS content item.
- */
-interface CreateCMSContentItemInput {
-    /** URL-safe slug for the item */
-    slug: string;
-    /** Arbitrary data payload — should match the content type schema */
-    data: Record<string, unknown>;
 }
-/**
- * Options for {@link createCMSContentItem}.
- */
-interface CreateCMSContentItemOptions {
-    /**
-     * When `true`, persist relation fields (`belongsTo`, `hasMany`,
-     * `manyToMany`) into the `contentRelation` junction table in addition to
-     * the item's JSON payload.
-     *
-     * This is what the HTTP `POST /content/:typeSlug` route does, and is
-     * required for the admin "Related Items" panel / inverse-relation queries
-     * to find the item.
-     *
-     * Seeds and other programmatic callers that want the admin UI to work
-     * should enable this flag. Callers are still expected to pass
-     * pre-created target IDs (`{ id }` or `[{ id }, ...]`) — inline `_new`
-     * creation is only supported via the HTTP route.
-     *
-     * Defaults to `false` for backwards compatibility (a no-op for content
-     * types without relations).
-     */
-    syncRelations?: boolean;
+interface ContentByRelationParams {
+    typeSlug: string;
+    field: string;
+    targetId: string;
+    limit?: number;
 }
-/**
- * Create a new content item for a content type (looked up by slug).
- *
- * Bypasses Zod schema validation and inline `_new` relation creation — the
- * caller is responsible for providing valid data and pre-created relation
- * IDs. For schema validation or inline creation of related items, use the
- * HTTP endpoint instead.
- *
- * Throws if the content type is not found or the slug is already taken within
- * that content type.
- *
- * @remarks **Security:** No authorization hooks (`onBeforeCreate`, `onAfterCreate`)
- * are called. The caller is responsible for any access-control checks before
- * invoking this function.
- *
- * @param adapter - The database adapter
- * @param contentTypeSlug - Slug of the target content type
- * @param input - Item slug and data payload
- * @param options - See {@link CreateCMSContentItemOptions}. Pass
- *   `{ syncRelations: true }` to also populate the `contentRelation`
- *   junction table for relation fields in the payload.
- */
-declare function createCMSContentItem(adapter: DBAdapter, contentTypeSlug: string, input: CreateCMSContentItemInput, options?: CreateCMSContentItemOptions): Promise<SerializedContentItem>;
-
-/**
- * Route keys for the CMS plugin — matches the keys returned by
- * `stackClient.router.getRoute(path).routeKey`.
- */
-type CMSRouteKey = "dashboard" | "contentList" | "newContent" | "editContent";
-interface CMSPrefetchForRoute {
-    (key: "dashboard" | "newContent", qc: QueryClient): Promise<void>;
-    (key: "contentList", qc: QueryClient, params: {
-        typeSlug: string;
-    }): Promise<void>;
-    (key: "editContent", qc: QueryClient, params: {
-        typeSlug: string;
-        id: string;
-    }): Promise<void>;
+interface InverseRelationsParams {
+    slug: string;
+    itemId: string;
+}
+interface InverseRelationItemsParams {
+    slug: string;
+    sourceType: string;
+    itemId: string;
+    fieldName: string;
 }
 /**
- * CMS backend plugin
- * Provides API endpoints for managing content types and content items
+ * CMS resource declaration — the single source of truth for query keys,
+ * HTTP mappings and mutations. Feeds both `createCMSQueryKeys` (SSR
+ * loaders) and `createResource` (client hooks, see `client/hooks`).
  *
- * @param config - Configuration with content types and optional hooks
+ * Key shapes intentionally match `CMS_QUERY_KEYS` in
+ * `api/query-key-defs.ts` so SSG `prefetchForRoute` hydration keeps working.
+ * List pages stay as `{ items, total, limit, offset }` envelopes (via
+ * `nextPageParam`) so `total` survives SSG dehydration.
  */
-declare const cmsBackendPlugin: (config: CMSBackendConfig) => _btst_stack_plugins_api.BackendPlugin<{
-    listContentTypes: better_call.StrictEndpoint<"/content-types", {} & {
-        method: "GET";
-    }, {
-        itemCount: number;
-        createdAt: string;
-        updatedAt: string;
-        name: string;
-        id: string;
-        slug: string;
-        description?: string | undefined;
-        jsonSchema: string;
-        fieldConfig?: string | undefined;
-        autoFormVersion?: number | undefined;
-    }[]>;
-    getContentTypeBySlug: better_call.StrictEndpoint<"/content-types/:slug", {
-        params: z.ZodObject<{
-            slug: z.ZodString;
-        }, z.core.$strip>;
-    } & {
-        method: "GET";
-    }, SerializedContentType>;
-    listContentItems: better_call.StrictEndpoint<"/content/:typeSlug", {
-        params: z.ZodObject<{
-            typeSlug: z.ZodString;
-        }, z.core.$strip>;
-    } & {
-        method: "GET";
-    } & {
-        query: better_call.StandardSchemaV1<{
-            slug?: string | undefined;
-            limit?: unknown;
-            offset?: unknown;
-        }, {
-            slug?: string | undefined;
-            limit?: unknown;
-            offset?: unknown;
-        }>;
-    }, {
-        items: SerializedContentItemWithType[];
-        total: number;
-        limit?: number;
-        offset?: number;
-    }>;
-    getContentItem: better_call.StrictEndpoint<"/content/:typeSlug/:id", {
-        params: z.ZodObject<{
-            typeSlug: z.ZodString;
-            id: z.ZodString;
-        }, z.core.$strip>;
-    } & {
-        method: "GET";
-    }, SerializedContentItemWithType<Record<string, unknown>>>;
-    createContentItem: better_call.StrictEndpoint<"/content/:typeSlug", {
-        params: z.ZodObject<{
-            typeSlug: z.ZodString;
-        }, z.core.$strip>;
-    } & {
-        method: "POST";
-        body: better_call.StandardSchemaV1<{
-            slug: string;
-            data: {
-                [x: string]: unknown;
+declare const cmsResources: {
+    cmsTypes: {
+        queries: {
+            list: {
+                path: string;
+                key: () => string[];
+                select: (data: any) => (SerializedContentType & {
+                    itemCount: number;
+                })[];
             };
-        }, {
-            slug: string;
-            data: {
-                [x: string]: unknown;
+            detail: {
+                path: string;
+                params: (slug: string) => {
+                    slug: string;
+                };
+                key: (slug: string) => string[];
+                select: (data: any, _slug: string) => SerializedContentType | null;
+                skip: (slug: string) => boolean;
             };
-        }>;
-    }, {
-        parsedData: Record<string, unknown>;
-        createdAt: string;
-        updatedAt: string;
-        id: string;
-        slug: string;
-        contentTypeId: string;
-        data: string;
-        authorId?: string | undefined;
-    }>;
-    updateContentItem: better_call.StrictEndpoint<"/content/:typeSlug/:id", {
-        params: z.ZodObject<{
-            typeSlug: z.ZodString;
-            id: z.ZodString;
-        }, z.core.$strip>;
-    } & {
-        method: "PUT";
-        body: better_call.StandardSchemaV1<{
-            slug?: string | undefined;
-            data?: {
-                [x: string]: unknown;
-            } | undefined;
-        }, {
-            slug?: string | undefined;
-            data?: {
-                [x: string]: unknown;
-            } | undefined;
-        }>;
-    }, SerializedContentItemWithType<Record<string, unknown>>>;
-    deleteContentItem: better_call.StrictEndpoint<"/content/:typeSlug/:id", {
-        params: z.ZodObject<{
-            typeSlug: z.ZodString;
-            id: z.ZodString;
-        }, z.core.$strip>;
-    } & {
-        method: "DELETE";
-        body: better_call.StandardSchemaV1<unknown, unknown>;
-    }, {
-        success: boolean;
-    }>;
-    getContentItemPopulated: better_call.StrictEndpoint<"/content/:typeSlug/:id/populated", {
-        params: z.ZodObject<{
-            typeSlug: z.ZodString;
-            id: z.ZodString;
-        }, z.core.$strip>;
-    } & {
-        method: "GET";
-    }, {
-        _relations: Record<string, SerializedContentItemWithType<Record<string, unknown>>[]>;
-        parsedData: Record<string, unknown>;
-        contentType?: SerializedContentType;
-        createdAt: string;
-        updatedAt: string;
-        id: string;
-        slug: string;
-        contentTypeId: string;
-        data: string;
-        authorId?: string | undefined;
-    }>;
-    listContentByRelation: better_call.StrictEndpoint<"/content/:typeSlug/by-relation", {
-        params: z.ZodObject<{
-            typeSlug: z.ZodString;
-        }, z.core.$strip>;
-    } & {
-        method: "GET";
-    } & {
-        query: better_call.StandardSchemaV1<{
-            field: string;
-            targetId: string;
-            limit?: unknown;
-            offset?: unknown;
-        }, {
-            field: string;
-            targetId: string;
-            limit?: unknown;
-            offset?: unknown;
-        }>;
-    }, {
-        items: SerializedContentItemWithType<Record<string, unknown>>[];
-        total: number;
-        limit: number;
-        offset: number;
-    }>;
-    getInverseRelations: better_call.StrictEndpoint<"/content-types/:slug/inverse-relations", {
-        params: z.ZodObject<{
-            slug: z.ZodString;
-        }, z.core.$strip>;
-    } & {
-        method: "GET";
-    } & {
-        query: better_call.StandardSchemaV1<{
-            itemId?: string | undefined;
-        }, {
-            itemId?: string | undefined;
-        }>;
-    }, {
-        inverseRelations: InverseRelation[];
-    }>;
-    listInverseRelationItems: better_call.StrictEndpoint<"/content-types/:slug/inverse-relations/:sourceType", {
-        params: z.ZodObject<{
-            slug: z.ZodString;
-            sourceType: z.ZodString;
-        }, z.core.$strip>;
-    } & {
-        method: "GET";
-    } & {
-        query: better_call.StandardSchemaV1<{
-            itemId: string;
-            fieldName: string;
-            limit?: unknown;
-            offset?: unknown;
-        }, {
-            itemId: string;
-            fieldName: string;
-            limit?: unknown;
-            offset?: unknown;
-        }>;
-    }, {
-        items: SerializedContentItemWithType<Record<string, unknown>>[];
-        total: number;
-        limit: number;
-        offset: number;
-    }>;
-}, {
-    getAllContentTypes: () => Promise<SerializedContentType[]>;
-    getAllContentItems: (contentTypeSlug: string, params?: Parameters<typeof getAllContentItems>[2]) => Promise<{
-        items: SerializedContentItemWithType[];
-        total: number;
-        limit?: number;
-        offset?: number;
-    }>;
-    getContentItemBySlug: (contentTypeSlug: string, slug: string) => Promise<SerializedContentItemWithType<Record<string, unknown>> | null>;
-    getContentItemById: (id: string) => Promise<SerializedContentItemWithType<Record<string, unknown>> | null>;
-    prefetchForRoute: CMSPrefetchForRoute;
-    createContentItem: (typeSlug: string, input: Parameters<typeof createCMSContentItem>[2], options?: Parameters<typeof createCMSContentItem>[3]) => Promise<SerializedContentItem>;
-}>;
-type CMSApiRouter = ReturnType<ReturnType<typeof cmsBackendPlugin>["routes"]>;
-
-/**
- * Internal query key constants for the CMS plugin.
- * Shared between query-keys.ts (HTTP path) and prefetchForRoute (DB path)
- * to prevent key drift between SSR loaders and SSG prefetching.
- */
-interface ContentListDiscriminator {
-    typeSlug: string;
-    limit: number;
-    offset: number;
-}
-/** Full query key builders — use these with queryClient.setQueryData() */
-declare const CMS_QUERY_KEYS: {
-    /**
-     * Key for the cmsTypes.list() query.
-     * Full key: ["cmsTypes", "list", "list"]
-     */
-    typesList: () => readonly ["cmsTypes", "list", "list"];
-    /**
-     * Key for the cmsContent.list({ typeSlug, limit, offset }) query.
-     * Full key: ["cmsContent", "list", { typeSlug, limit, offset }]
-     */
-    contentList: (params: {
-        typeSlug: string;
-        limit?: number;
-        offset?: number;
-    }) => readonly ["cmsContent", "list", ContentListDiscriminator];
-    /**
-     * Key for the cmsContent.detail(typeSlug, id) query.
-     * Full key: ["cmsContent", "detail", typeSlug, id]
-     */
-    contentDetail: (typeSlug: string, id: string) => readonly ["cmsContent", "detail", string, string];
+            inverseRelations: {
+                path: string;
+                params: (p: InverseRelationsParams) => {
+                    slug: string;
+                };
+                query: (p: InverseRelationsParams) => {
+                    itemId: string;
+                };
+                key: (p: InverseRelationsParams) => string[];
+                select: (data: any) => InverseRelation[];
+            };
+            inverseRelationItems: {
+                path: string;
+                params: (p: InverseRelationItemsParams) => {
+                    slug: string;
+                    sourceType: string;
+                };
+                query: (p: InverseRelationItemsParams) => {
+                    itemId: string;
+                    fieldName: string;
+                };
+                key: (p: InverseRelationItemsParams) => string[];
+                select: (data: any) => {
+                    items: SerializedContentItemWithType[];
+                    total: number;
+                };
+            };
+        };
+    };
+    cmsContent: {
+        queries: {
+            list: {
+                path: string;
+                params: (p: ContentListParams) => {
+                    typeSlug: string;
+                };
+                query: (p: ContentListParams) => {
+                    limit: number;
+                    search: string | undefined;
+                };
+                key: (p: ContentListParams) => ContentListDiscriminator[];
+                select: (data: any, _p: ContentListParams) => PaginatedContentItems;
+                infinite: true;
+                pageSize: (p: ContentListParams) => number;
+                nextPageParam: (lastPage: PaginatedContentItems, allPages: PaginatedContentItems[], p: ContentListParams) => number | undefined;
+            };
+            detail: {
+                path: string;
+                params: (typeSlug: string, id: string) => {
+                    typeSlug: string;
+                    id: string;
+                };
+                key: (typeSlug: string, id: string) => string[];
+                select: (data: any, _typeSlug: string, _id: string) => SerializedContentItemWithType | null;
+                skip: (typeSlug: string, id: string) => boolean;
+            };
+            bySlug: {
+                path: string;
+                params: (typeSlug: string, _slug: string) => {
+                    typeSlug: string;
+                };
+                query: (_typeSlug: string, slug: string) => {
+                    slug: string;
+                    limit: number;
+                };
+                key: (typeSlug: string, slug: string) => string[];
+                select: (data: any) => SerializedContentItemWithType | null;
+                skip: (typeSlug: string, slug: string) => boolean;
+            };
+            populated: {
+                path: string;
+                params: (typeSlug: string, id: string) => {
+                    typeSlug: string;
+                    id: string;
+                };
+                key: (typeSlug: string, id: string) => string[];
+                select: (data: any) => SerializedContentItemWithType | null;
+                skip: (typeSlug: string, id: string) => boolean;
+            };
+            byRelation: {
+                path: string;
+                params: (p: ContentByRelationParams) => {
+                    typeSlug: string;
+                };
+                query: (p: ContentByRelationParams) => {
+                    field: string;
+                    targetId: string;
+                    limit: number;
+                };
+                key: (p: ContentByRelationParams) => string[];
+                select: (data: any, _p: ContentByRelationParams) => PaginatedContentItems;
+                infinite: true;
+                pageSize: (p: ContentByRelationParams) => number;
+                nextPageParam: (lastPage: PaginatedContentItems, allPages: PaginatedContentItems[], p: ContentByRelationParams) => number | undefined;
+            };
+            options: {
+                path: string;
+                params: (p: ContentOptionsParams) => {
+                    typeSlug: string;
+                };
+                query: (p: ContentOptionsParams) => {
+                    search: string | undefined;
+                    limit: number;
+                };
+                key: (p: ContentOptionsParams) => (string | number | undefined)[];
+                select: (data: any, _p: ContentOptionsParams) => SerializedContentItemWithType[];
+            };
+        };
+        mutations: {
+            create: {
+                path: string;
+                method: "POST";
+                input: (vars: {
+                    typeSlug: string;
+                    slug: string;
+                    data: Record<string, unknown>;
+                }) => {
+                    params: {
+                        typeSlug: string;
+                    };
+                    body: {
+                        slug: string;
+                        data: Record<string, unknown>;
+                    };
+                };
+                select: (data: any) => SerializedContentItemWithType | null;
+                invalidates: string[];
+            };
+            update: {
+                path: string;
+                method: "PUT";
+                input: (vars: {
+                    typeSlug: string;
+                    id: string;
+                    data: {
+                        slug?: string;
+                        data?: Record<string, unknown>;
+                    };
+                }) => {
+                    params: {
+                        typeSlug: string;
+                        id: string;
+                    };
+                    body: {
+                        slug?: string;
+                        data?: Record<string, unknown>;
+                    };
+                };
+                select: (data: any) => SerializedContentItemWithType | null;
+                invalidates: string[];
+                setData: {
+                    query: string;
+                    args: (updated: SerializedContentItemWithType | null) => string[] | null;
+                };
+            };
+            delete: {
+                path: string;
+                method: "DELETE";
+                input: (vars: {
+                    typeSlug: string;
+                    id: string;
+                }) => {
+                    params: {
+                        typeSlug: string;
+                        id: string;
+                    };
+                };
+                select: (data: any) => {
+                    success: boolean;
+                };
+                invalidates: string[];
+            };
+        };
+    };
 };
-
-interface ContentListParams {
-    limit?: number;
-    offset?: number;
-}
 /**
  * Create CMS query keys for React Query
- * Used by consumers to fetch content types and content items
+ * Used by consumers and SSR loaders to fetch content types and content items
  */
-declare function createCMSQueryKeys(client: ReturnType<typeof createApiClient<CMSApiRouter>>, headers?: HeadersInit): {
+declare function createCMSQueryKeys(client: ReturnType<typeof createApiClient<CMSApiRouter>>, headers?: HeadersInit): _btst_stack_plugins_client.ResourceQueryKeys<{
     cmsTypes: {
-        _def: readonly ["cmsTypes"];
-    } & {
-        list: (() => Omit<{
-            queryKey: readonly ["cmsTypes", "list", string];
-            queryFn: _tanstack_react_query.QueryFunction<(SerializedContentType & {
-                itemCount: number;
-            })[], readonly ["cmsTypes", "list", string]>;
-        } & {
-            _def: readonly ["cmsTypes", "list"];
-        }, "_def">) & {
-            _def: readonly ["cmsTypes", "list"];
-        };
-        detail: ((slug: string) => Omit<{
-            queryKey: readonly ["cmsTypes", "detail", string];
-            queryFn: _tanstack_react_query.QueryFunction<SerializedContentType | null, readonly ["cmsTypes", "detail", string]>;
-        } & {
-            _def: readonly ["cmsTypes", "detail"];
-        }, "_def">) & {
-            _def: readonly ["cmsTypes", "detail"];
+        queries: {
+            list: {
+                path: string;
+                key: () => string[];
+                select: (data: any) => (SerializedContentType & {
+                    itemCount: number;
+                })[];
+            };
+            detail: {
+                path: string;
+                params: (slug: string) => {
+                    slug: string;
+                };
+                key: (slug: string) => string[];
+                select: (data: any, _slug: string) => SerializedContentType | null;
+                skip: (slug: string) => boolean;
+            };
+            inverseRelations: {
+                path: string;
+                params: (p: InverseRelationsParams) => {
+                    slug: string;
+                };
+                query: (p: InverseRelationsParams) => {
+                    itemId: string;
+                };
+                key: (p: InverseRelationsParams) => string[];
+                select: (data: any) => InverseRelation[];
+            };
+            inverseRelationItems: {
+                path: string;
+                params: (p: InverseRelationItemsParams) => {
+                    slug: string;
+                    sourceType: string;
+                };
+                query: (p: InverseRelationItemsParams) => {
+                    itemId: string;
+                    fieldName: string;
+                };
+                key: (p: InverseRelationItemsParams) => string[];
+                select: (data: any) => {
+                    items: SerializedContentItemWithType[];
+                    total: number;
+                };
+            };
         };
     };
     cmsContent: {
-        _def: readonly ["cmsContent"];
-    } & {
-        list: ((params: {
-            typeSlug: string;
-        } & ContentListParams) => Omit<{
-            queryKey: readonly ["cmsContent", "list", ContentListDiscriminator];
-            queryFn: _tanstack_react_query.QueryFunction<PaginatedContentItems<Record<string, unknown>>, readonly ["cmsContent", "list", ContentListDiscriminator]>;
-        } & {
-            _def: readonly ["cmsContent", "list"];
-        }, "_def">) & {
-            _def: readonly ["cmsContent", "list"];
-        };
-        detail: ((typeSlug: string, id: string) => Omit<{
-            queryKey: readonly ["cmsContent", "detail", string, string];
-            queryFn: _tanstack_react_query.QueryFunction<SerializedContentItemWithType<Record<string, unknown>> | null, readonly ["cmsContent", "detail", string, string]>;
-        } & {
-            _def: readonly ["cmsContent", "detail"];
-        }, "_def">) & {
-            _def: readonly ["cmsContent", "detail"];
+        queries: {
+            list: {
+                path: string;
+                params: (p: ContentListParams) => {
+                    typeSlug: string;
+                };
+                query: (p: ContentListParams) => {
+                    limit: number;
+                    search: string | undefined;
+                };
+                key: (p: ContentListParams) => ContentListDiscriminator[];
+                select: (data: any, _p: ContentListParams) => PaginatedContentItems;
+                infinite: true;
+                pageSize: (p: ContentListParams) => number;
+                nextPageParam: (lastPage: PaginatedContentItems, allPages: PaginatedContentItems[], p: ContentListParams) => number | undefined;
+            };
+            detail: {
+                path: string;
+                params: (typeSlug: string, id: string) => {
+                    typeSlug: string;
+                    id: string;
+                };
+                key: (typeSlug: string, id: string) => string[];
+                select: (data: any, _typeSlug: string, _id: string) => SerializedContentItemWithType | null;
+                skip: (typeSlug: string, id: string) => boolean;
+            };
+            bySlug: {
+                path: string;
+                params: (typeSlug: string, _slug: string) => {
+                    typeSlug: string;
+                };
+                query: (_typeSlug: string, slug: string) => {
+                    slug: string;
+                    limit: number;
+                };
+                key: (typeSlug: string, slug: string) => string[];
+                select: (data: any) => SerializedContentItemWithType | null;
+                skip: (typeSlug: string, slug: string) => boolean;
+            };
+            populated: {
+                path: string;
+                params: (typeSlug: string, id: string) => {
+                    typeSlug: string;
+                    id: string;
+                };
+                key: (typeSlug: string, id: string) => string[];
+                select: (data: any) => SerializedContentItemWithType | null;
+                skip: (typeSlug: string, id: string) => boolean;
+            };
+            byRelation: {
+                path: string;
+                params: (p: ContentByRelationParams) => {
+                    typeSlug: string;
+                };
+                query: (p: ContentByRelationParams) => {
+                    field: string;
+                    targetId: string;
+                    limit: number;
+                };
+                key: (p: ContentByRelationParams) => string[];
+                select: (data: any, _p: ContentByRelationParams) => PaginatedContentItems;
+                infinite: true;
+                pageSize: (p: ContentByRelationParams) => number;
+                nextPageParam: (lastPage: PaginatedContentItems, allPages: PaginatedContentItems[], p: ContentByRelationParams) => number | undefined;
+            };
+            options: {
+                path: string;
+                params: (p: ContentOptionsParams) => {
+                    typeSlug: string;
+                };
+                query: (p: ContentOptionsParams) => {
+                    search: string | undefined;
+                    limit: number;
+                };
+                key: (p: ContentOptionsParams) => (string | number | undefined)[];
+                select: (data: any, _p: ContentOptionsParams) => SerializedContentItemWithType[];
+            };
         };
-        bySlug: ((typeSlug: string, slug: string) => Omit<{
-            queryKey: readonly ["cmsContent", "bySlug", string, string, string];
-            queryFn: _tanstack_react_query.QueryFunction<SerializedContentItemWithType<Record<string, unknown>> | null, readonly ["cmsContent", "bySlug", string, string, string]>;
-        } & {
-            _def: readonly ["cmsContent", "bySlug"];
-        }, "_def">) & {
-            _def: readonly ["cmsContent", "bySlug"];
+        mutations: {
+            create: {
+                path: string;
+                method: "POST";
+                input: (vars: {
+                    typeSlug: string;
+                    slug: string;
+                    data: Record<string, unknown>;
+                }) => {
+                    params: {
+                        typeSlug: string;
+                    };
+                    body: {
+                        slug: string;
+                        data: Record<string, unknown>;
+                    };
+                };
+                select: (data: any) => SerializedContentItemWithType | null;
+                invalidates: string[];
+            };
+            update: {
+                path: string;
+                method: "PUT";
+                input: (vars: {
+                    typeSlug: string;
+                    id: string;
+                    data: {
+                        slug?: string;
+                        data?: Record<string, unknown>;
+                    };
+                }) => {
+                    params: {
+                        typeSlug: string;
+                        id: string;
+                    };
+                    body: {
+                        slug?: string;
+                        data?: Record<string, unknown>;
+                    };
+                };
+                select: (data: any) => SerializedContentItemWithType | null;
+                invalidates: string[];
+                setData: {
+                    query: string;
+                    args: (updated: SerializedContentItemWithType | null) => string[] | null;
+                };
+            };
+            delete: {
+                path: string;
+                method: "DELETE";
+                input: (vars: {
+                    typeSlug: string;
+                    id: string;
+                }) => {
+                    params: {
+                        typeSlug: string;
+                        id: string;
+                    };
+                };
+                select: (data: any) => {
+                    success: boolean;
+                };
+                invalidates: string[];
+            };
         };
     };
-};
+}>;
 
-export { getAllContentItems as b, cmsBackendPlugin as c, createCMSQueryKeys, getContentItemBySlug as d, getContentItemById as e, serializeContentItem as f, getAllContentTypes as g, serializeContentItemWithType as h, createCMSContentItem as i, CMS_QUERY_KEYS as l, serializeContentType as s };
-export type { CMSApiRouter as C, CMSRouteKey as a, CreateCMSContentItemInput as j, CreateCMSContentItemOptions as k };
+export { cmsResources, createCMSQueryKeys };
+export type { ContentListParams };