@btst/plugin-cms 0.0.0-stage → 1.0.0-beta.0

package/dist/client/hooks/index.d.mts

@@ -0,0 +1,693 @@
+'use client';
+import { ResourceFormConfig, ResourceFormResult, ResourceSelectResult } from '@btst/stack/plugins/client/hooks';
+import { SerializedContentItemWithType, CMSReadView, CMSContentFields, CMSReadOptions, CMSContentItemResult, SerializedContentType, CMSContentTypeMap, InverseRelation } from '../../types.mjs';
+import 'zod';
+
+interface UseContentTypesResult {
+    contentTypes: (SerializedContentType & {
+        itemCount: number;
+    })[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+/**
+ * Hook for fetching all content types
+ */
+declare function useContentTypes(): UseContentTypesResult;
+/**
+ * Suspense variant of useContentTypes
+ */
+declare function useSuspenseContentTypes(): {
+    contentTypes: (SerializedContentType & {
+        itemCount: number;
+    })[];
+    refetch: () => Promise<unknown>;
+};
+/**
+ * Hook for fetching a single content type by slug
+ */
+declare function useContentType(slug: string): {
+    contentType: SerializedContentType | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+};
+interface UseContentOptions<TView extends CMSReadView = CMSReadView, TFields extends CMSContentFields = CMSContentFields> extends CMSReadOptions<TView, TFields> {
+    /** Number of items per page (default: 10) */
+    limit?: number;
+    /** Whether to enable the query (default: true) */
+    enabled?: boolean;
+    /** Free-text search across item slugs and data values */
+    search?: string;
+}
+/**
+ * Result type for useContent hook with load more functionality
+ * @template TData - The type of parsedData (defaults to Record<string, unknown>)
+ */
+interface UseContentResult<TData = Record<string, unknown>, TView extends CMSReadView = undefined, TFields extends CMSContentFields = undefined> {
+    /** Array of all loaded content items */
+    items: CMSContentItemResult<TData, TView, TFields>[];
+    /** Total number of items available */
+    total: number;
+    /** Whether the initial load is in progress */
+    isLoading: boolean;
+    /** Error if the query failed */
+    error: Error | null;
+    /** Function to load the next page of items */
+    loadMore: () => void;
+    /** Whether there are more items to load */
+    hasMore: boolean;
+    /** Whether the next page is being loaded */
+    isLoadingMore: boolean;
+    /** Function to refetch all items */
+    refetch: () => void;
+}
+/**
+ * Hook for fetching paginated content items with load more functionality.
+ * Uses React Query's infinite query for efficient pagination.
+ *
+ * @template TMap - A type map of content type slugs to their data types
+ * @template TSlug - The content type slug (inferred from typeSlug parameter)
+ *
+ * @example
+ * ```typescript
+ * // Without type safety (backward compatible)
+ * const { items, loadMore, hasMore, isLoadingMore } = useContent("product")
+ *
+ * // With type safety using a type map
+ * type MyCMSTypes = {
+ *   product: { name: string; price: number }
+ *   testimonial: { author: string; quote: string }
+ * }
+ * const { items, loadMore, hasMore } = useContent<MyCMSTypes, "product">("product")
+ * // items[0].parsedData.name is string
+ * // items[0].parsedData.price is number
+ * ```
+ */
+declare function useContent<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, const TFields extends readonly string[] = readonly string[]>(typeSlug: TSlug & string, options: UseContentOptions<"content", TFields> & {
+    view: "content";
+    fields: TFields;
+}): UseContentResult<TMap[TSlug], "content", TFields>;
+declare function useContent<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, options: UseContentOptions<"content"> & {
+    view: "content";
+    fields?: undefined;
+}): UseContentResult<TMap[TSlug], "content">;
+declare function useContent<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, TView extends CMSReadView = undefined, TFields extends CMSContentFields = undefined>(typeSlug: TSlug & string, options?: UseContentOptions<TView, TFields>): UseContentResult<TMap[TSlug], TView, TFields>;
+/**
+ * Suspense variant of useContent with load more functionality.
+ *
+ * @template TMap - A type map of content type slugs to their data types
+ * @template TSlug - The content type slug (inferred from typeSlug parameter)
+ */
+type SuspenseContentResult<TData, TView extends CMSReadView, TFields extends CMSContentFields = undefined> = {
+    items: CMSContentItemResult<TData, TView, TFields>[];
+    total: number;
+    loadMore: () => Promise<unknown>;
+    hasMore: boolean;
+    isLoadingMore: boolean;
+    refetch: () => Promise<unknown>;
+};
+declare function useSuspenseContent<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, const TFields extends readonly string[] = readonly string[]>(typeSlug: TSlug & string, options: UseContentOptions<"content", TFields> & {
+    view: "content";
+    fields: TFields;
+}): SuspenseContentResult<TMap[TSlug], "content", TFields>;
+declare function useSuspenseContent<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, options: UseContentOptions<"content"> & {
+    view: "content";
+    fields?: undefined;
+}): SuspenseContentResult<TMap[TSlug], "content">;
+declare function useSuspenseContent<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, TView extends CMSReadView = undefined, TFields extends CMSContentFields = undefined>(typeSlug: TSlug & string, options?: UseContentOptions<TView, TFields>): SuspenseContentResult<TMap[TSlug], TView, TFields>;
+/**
+ * Hook for fetching a single content item by ID with optional type safety.
+ *
+ * @template TMap - A type map of content type slugs to their data types
+ * @template TSlug - The content type slug (inferred from typeSlug parameter)
+ *
+ * @example
+ * ```typescript
+ * type MyCMSTypes = { product: { name: string; price: number } }
+ * const { item } = useContentItem<MyCMSTypes, "product">("product", "some-id")
+ * // item?.parsedData.name is string
+ * ```
+ */
+type ContentItemQueryResult<TData, TView extends CMSReadView, TFields extends CMSContentFields = undefined> = {
+    item: CMSContentItemResult<TData, TView, TFields> | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+};
+declare function useContentItem<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, const TFields extends readonly string[] = readonly string[]>(typeSlug: TSlug & string, id: string, options: CMSReadOptions<"content", TFields> & {
+    view: "content";
+    fields: TFields;
+}): ContentItemQueryResult<TMap[TSlug], "content", TFields>;
+declare function useContentItem<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, id: string, options: CMSReadOptions<"content"> & {
+    view: "content";
+    fields?: undefined;
+}): ContentItemQueryResult<TMap[TSlug], "content">;
+declare function useContentItem<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, TView extends CMSReadView = undefined, TFields extends CMSContentFields = undefined>(typeSlug: TSlug & string, id: string, options?: CMSReadOptions<TView, TFields>): ContentItemQueryResult<TMap[TSlug], TView, TFields>;
+/**
+ * Suspense variant of useContentItem with optional type safety.
+ *
+ * @template TMap - A type map of content type slugs to their data types
+ * @template TSlug - The content type slug (inferred from typeSlug parameter)
+ */
+type SuspenseContentItemResult<TData, TView extends CMSReadView, TFields extends CMSContentFields = undefined> = {
+    item: CMSContentItemResult<TData, TView, TFields> | null;
+    refetch: () => Promise<unknown>;
+};
+declare function useSuspenseContentItem<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, const TFields extends readonly string[] = readonly string[]>(typeSlug: TSlug & string, id: string, options: CMSReadOptions<"content", TFields> & {
+    view: "content";
+    fields: TFields;
+}): SuspenseContentItemResult<TMap[TSlug], "content", TFields>;
+declare function useSuspenseContentItem<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, id: string, options: CMSReadOptions<"content"> & {
+    view: "content";
+    fields?: undefined;
+}): SuspenseContentItemResult<TMap[TSlug], "content">;
+declare function useSuspenseContentItem<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, TView extends CMSReadView = undefined, TFields extends CMSContentFields = undefined>(typeSlug: TSlug & string, id: string, options?: CMSReadOptions<TView, TFields>): SuspenseContentItemResult<TMap[TSlug], TView, TFields>;
+/**
+ * Hook for fetching a content item by slug with optional type safety.
+ *
+ * @template TMap - A type map of content type slugs to their data types
+ * @template TSlug - The content type slug (inferred from typeSlug parameter)
+ *
+ * @example
+ * ```typescript
+ * type MyCMSTypes = { product: { name: string; price: number } }
+ * const { item } = useContentItemBySlug<MyCMSTypes, "product">("product", "my-product")
+ * // item?.parsedData.price is number
+ * ```
+ */
+declare function useContentItemBySlug<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, const TFields extends readonly string[] = readonly string[]>(typeSlug: TSlug & string, slug: string, options: CMSReadOptions<"content", TFields> & {
+    view: "content";
+    fields: TFields;
+}): ContentItemQueryResult<TMap[TSlug], "content", TFields>;
+declare function useContentItemBySlug<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, slug: string, options: CMSReadOptions<"content"> & {
+    view: "content";
+    fields?: undefined;
+}): ContentItemQueryResult<TMap[TSlug], "content">;
+declare function useContentItemBySlug<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, TView extends CMSReadView = undefined, TFields extends CMSContentFields = undefined>(typeSlug: TSlug & string, slug: string, options?: CMSReadOptions<TView, TFields>): ContentItemQueryResult<TMap[TSlug], TView, TFields>;
+/**
+ * Hook for creating a content item with optional type safety.
+ *
+ * @template TData - The type of the content data (defaults to Record<string, unknown>)
+ *
+ * @example
+ * ```typescript
+ * type ProductData = { name: string; price: number }
+ * const createProduct = useCreateContent<ProductData>("product")
+ *
+ * // TypeScript will enforce the correct shape
+ * createProduct.mutate({
+ *   slug: "my-product",
+ *   data: { name: "Widget", price: 29.99 }
+ * })
+ * ```
+ */
+declare function useCreateContent<TData = Record<string, unknown>>(typeSlug: string): {
+    mutate: (vars: {
+        slug: string;
+        data: TData;
+    }) => void;
+    mutateAsync: (vars: {
+        slug: string;
+        data: TData;
+    }) => Promise<SerializedContentItemWithType<TData>>;
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    mutate: (vars: {
+        slug: string;
+        data: TData;
+    }) => void;
+    mutateAsync: (vars: {
+        slug: string;
+        data: TData;
+    }) => Promise<SerializedContentItemWithType<TData>>;
+    data: undefined;
+    variables: {
+        typeSlug: string;
+        slug: string;
+        data: Record<string, unknown>;
+    };
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    mutate: (vars: {
+        slug: string;
+        data: TData;
+    }) => void;
+    mutateAsync: (vars: {
+        slug: string;
+        data: TData;
+    }) => Promise<SerializedContentItemWithType<TData>>;
+    data: undefined;
+    error: Error;
+    variables: {
+        typeSlug: string;
+        slug: string;
+        data: Record<string, unknown>;
+    };
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    mutate: (vars: {
+        slug: string;
+        data: TData;
+    }) => void;
+    mutateAsync: (vars: {
+        slug: string;
+        data: TData;
+    }) => Promise<SerializedContentItemWithType<TData>>;
+    data: SerializedContentItemWithType<Record<string, unknown>> | null;
+    error: null;
+    variables: {
+        typeSlug: string;
+        slug: string;
+        data: Record<string, unknown>;
+    };
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+};
+/**
+ * Hook for updating a content item with optional type safety.
+ *
+ * @template TData - The type of the content data (defaults to Record<string, unknown>)
+ *
+ * @example
+ * ```typescript
+ * type ProductData = { name: string; price: number }
+ * const updateProduct = useUpdateContent<ProductData>("product")
+ *
+ * updateProduct.mutate({
+ *   id: "item-id",
+ *   data: { data: { name: "Updated Widget", price: 39.99 } }
+ * })
+ * ```
+ */
+declare function useUpdateContent<TData = Record<string, unknown>>(typeSlug: string): {
+    mutate: (vars: {
+        id: string;
+        data: {
+            slug?: string;
+            data?: TData;
+        };
+    }) => void;
+    mutateAsync: (vars: {
+        id: string;
+        data: {
+            slug?: string;
+            data?: TData;
+        };
+    }) => Promise<SerializedContentItemWithType<TData>>;
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    mutate: (vars: {
+        id: string;
+        data: {
+            slug?: string;
+            data?: TData;
+        };
+    }) => void;
+    mutateAsync: (vars: {
+        id: string;
+        data: {
+            slug?: string;
+            data?: TData;
+        };
+    }) => Promise<SerializedContentItemWithType<TData>>;
+    data: undefined;
+    variables: {
+        typeSlug: string;
+        id: string;
+        data: {
+            slug?: string;
+            data?: Record<string, unknown>;
+        };
+    };
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    mutate: (vars: {
+        id: string;
+        data: {
+            slug?: string;
+            data?: TData;
+        };
+    }) => void;
+    mutateAsync: (vars: {
+        id: string;
+        data: {
+            slug?: string;
+            data?: TData;
+        };
+    }) => Promise<SerializedContentItemWithType<TData>>;
+    data: undefined;
+    error: Error;
+    variables: {
+        typeSlug: string;
+        id: string;
+        data: {
+            slug?: string;
+            data?: Record<string, unknown>;
+        };
+    };
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    mutate: (vars: {
+        id: string;
+        data: {
+            slug?: string;
+            data?: TData;
+        };
+    }) => void;
+    mutateAsync: (vars: {
+        id: string;
+        data: {
+            slug?: string;
+            data?: TData;
+        };
+    }) => Promise<SerializedContentItemWithType<TData>>;
+    data: SerializedContentItemWithType<Record<string, unknown>> | null;
+    error: null;
+    variables: {
+        typeSlug: string;
+        id: string;
+        data: {
+            slug?: string;
+            data?: Record<string, unknown>;
+        };
+    };
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+};
+/**
+ * Hook for deleting a content item
+ */
+declare function useDeleteContent(typeSlug: string): {
+    mutate: (id: string) => void;
+    mutateAsync: (id: string) => Promise<{
+        success: boolean;
+    }>;
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    mutate: (id: string) => void;
+    mutateAsync: (id: string) => Promise<{
+        success: boolean;
+    }>;
+    data: undefined;
+    variables: {
+        typeSlug: string;
+        id: string;
+    };
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    mutate: (id: string) => void;
+    mutateAsync: (id: string) => Promise<{
+        success: boolean;
+    }>;
+    data: undefined;
+    error: Error;
+    variables: {
+        typeSlug: string;
+        id: string;
+    };
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    mutate: (id: string) => void;
+    mutateAsync: (id: string) => Promise<{
+        success: boolean;
+    }>;
+    data: {
+        success: boolean;
+    };
+    error: null;
+    variables: {
+        typeSlug: string;
+        id: string;
+    };
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+};
+/**
+ * Form lifecycle hook for creating/editing content items, built on the core
+ * resource `useForm`: submits the right mutation, awaits invalidation,
+ * notifies via `useNotify()`, redirects, and maps server validation issues
+ * to `fieldErrors`.
+ */
+declare function useContentItemForm<TValues>(config: ResourceFormConfig<TValues, SerializedContentItemWithType | null, SerializedContentItemWithType | null>): ResourceFormResult<TValues, SerializedContentItemWithType | null, SerializedContentItemWithType | null>;
+/**
+ * Select-input options for content items of a target type, built on the core
+ * resource `useSelect`: debounced server-side search over the `options`
+ * query, with selected ids missing from the current results preloaded via
+ * the `detail` query (typeSlug, id) so their labels resolve.
+ *
+ * Used by the relation picker (`RelationField`). Optional content view/fields
+ * apply to both search results and selected-ID preloads; full records remain the default.
+ */
+declare function useContentOptions<TView extends CMSReadView = undefined, const TFields extends CMSContentFields = undefined>(config: {
+    /** Content type slug to search within. */
+    targetType: string;
+    /** Currently selected IDs, preloaded when absent from search results. */
+    value: string[];
+    getOptionLabel: (item: CMSContentItemResult<Record<string, unknown>, TView, TFields>) => string;
+} & CMSReadOptions<TView, TFields>): ResourceSelectResult<CMSContentItemResult<Record<string, unknown>, TView, TFields>>;
+/**
+ * Content item with populated relations
+ */
+interface ContentItemWithRelations<TData = Record<string, unknown>> extends SerializedContentItemWithType<TData> {
+    _relations?: Record<string, SerializedContentItemWithType[]>;
+}
+/**
+ * Hook for fetching a content item with its relations populated.
+ * Use this when you need to display related items alongside the main item.
+ *
+ * @template TMap - A type map of content type slugs to their data types
+ * @template TSlug - The content type slug (inferred from typeSlug parameter)
+ *
+ * @example
+ * ```typescript
+ * type MyCMSTypes = {
+ *   resource: { name: string; categoryIds: Array<{ id: string }> }
+ *   category: { name: string }
+ * }
+ * const { item } = useContentItemPopulated<MyCMSTypes, "resource">("resource", "some-id")
+ * // item?._relations?.categoryIds contains populated category items
+ * ```
+ */
+declare function useContentItemPopulated<TMap extends Record<string, Record<string, unknown>> = Record<string, Record<string, unknown>>, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, id: string): {
+    item: ContentItemWithRelations<TMap[TSlug]> | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+};
+/**
+ * Suspense variant of useContentItemPopulated
+ */
+declare function useSuspenseContentItemPopulated<TMap extends Record<string, Record<string, unknown>> = Record<string, Record<string, unknown>>, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, id: string): {
+    item: ContentItemWithRelations<TMap[TSlug]> | null;
+    refetch: () => Promise<unknown>;
+};
+/**
+ * Options for useContentByRelation hook
+ */
+interface UseContentByRelationOptions<TView extends CMSReadView = CMSReadView, TFields extends CMSContentFields = CMSContentFields> extends CMSReadOptions<TView, TFields> {
+    /** Number of items per page (default: 20) */
+    limit?: number;
+    /** Whether to enable the query (default: true) */
+    enabled?: boolean;
+}
+/**
+ * Hook for fetching content items that have a specific relation.
+ * Useful for "filter by category" functionality.
+ *
+ * @template TMap - A type map of content type slugs to their data types
+ * @template TSlug - The content type slug (inferred from typeSlug parameter)
+ *
+ * @example
+ * ```typescript
+ * // Get all resources in a specific category
+ * const { items } = useContentByRelation("resource", "categoryIds", categoryId)
+ * ```
+ */
+declare function useContentByRelation<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, const TFields extends readonly string[] = readonly string[]>(typeSlug: TSlug & string, fieldName: string, targetId: string, options: UseContentByRelationOptions<"content", TFields> & {
+    view: "content";
+    fields: TFields;
+}): UseContentResult<TMap[TSlug], "content", TFields>;
+declare function useContentByRelation<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, fieldName: string, targetId: string, options: UseContentByRelationOptions<"content"> & {
+    view: "content";
+    fields?: undefined;
+}): UseContentResult<TMap[TSlug], "content">;
+declare function useContentByRelation<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, TView extends CMSReadView = undefined, TFields extends CMSContentFields = undefined>(typeSlug: TSlug & string, fieldName: string, targetId: string, options?: UseContentByRelationOptions<TView, TFields>): UseContentResult<TMap[TSlug], TView, TFields>;
+/**
+ * Suspense variant of useContentByRelation
+ */
+declare function useSuspenseContentByRelation<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, const TFields extends readonly string[] = readonly string[]>(typeSlug: TSlug & string, fieldName: string, targetId: string, options: UseContentByRelationOptions<"content", TFields> & {
+    view: "content";
+    fields: TFields;
+}): SuspenseContentResult<TMap[TSlug], "content", TFields>;
+declare function useSuspenseContentByRelation<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap>(typeSlug: TSlug & string, fieldName: string, targetId: string, options: UseContentByRelationOptions<"content"> & {
+    view: "content";
+    fields?: undefined;
+}): SuspenseContentResult<TMap[TSlug], "content">;
+declare function useSuspenseContentByRelation<TMap extends CMSContentTypeMap = CMSContentTypeMap, TSlug extends keyof TMap = keyof TMap, TView extends CMSReadView = undefined, TFields extends CMSContentFields = undefined>(typeSlug: TSlug & string, fieldName: string, targetId: string, options?: UseContentByRelationOptions<TView, TFields>): SuspenseContentResult<TMap[TSlug], TView, TFields>;
+/**
+ * Hook for fetching the inverse relations of a content item — the content
+ * types with belongsTo fields pointing at it, with per-field counts.
+ */
+declare function useInverseRelations(contentTypeSlug: string, itemId: string): {
+    inverseRelations: InverseRelation[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+};
+/**
+ * Hook for listing the items behind one inverse relation (e.g. all comments
+ * whose `resourceId` points at this resource).
+ */
+declare function useInverseRelationItems<TView extends CMSReadView = undefined, const TFields extends CMSContentFields = undefined>(params: {
+    contentTypeSlug: string;
+    sourceType: string;
+    itemId: string;
+    fieldName: string;
+}, options?: CMSReadOptions<TView, TFields> & {
+    /** Whether to enable the query (default: true). */
+    enabled?: boolean;
+    /** Number of items per page (default: 20). */
+    limit?: number;
+    /** Number of matching items to skip (default: 0). */
+    offset?: number;
+}): {
+    items: CMSContentItemResult<Record<string, unknown>, TView, TFields>[];
+    total: number;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+};
+
+export { useContent, useContentByRelation, useContentItem, useContentItemBySlug, useContentItemForm, useContentItemPopulated, useContentOptions, useContentType, useContentTypes, useCreateContent, useDeleteContent, useInverseRelationItems, useInverseRelations, useSuspenseContent, useSuspenseContentByRelation, useSuspenseContentItem, useSuspenseContentItemPopulated, useSuspenseContentTypes, useUpdateContent };
+export type { ContentItemWithRelations, UseContentByRelationOptions, UseContentOptions, UseContentResult, UseContentTypesResult };