convex-cms 0.0.1

package/dist/component/contentEntries.d.ts

@@ -0,0 +1,719 @@
+/**
+ * Content Entry Query Functions
+ *
+ * Provides query functions for retrieving content entries from the CMS.
+ * Content entries are instances of content types that hold the actual content data.
+ *
+ * Uses convex-helpers paginator for robust cursor-based pagination.
+ */
+import { type Infer } from "convex/values";
+/**
+ * Comparison operators for field filtering.
+ *
+ * - `eq`: Exact equality (works with all field types)
+ * - `ne`: Not equal (works with all field types)
+ * - `gt`: Greater than (numbers, dates)
+ * - `gte`: Greater than or equal (numbers, dates)
+ * - `lt`: Less than (numbers, dates)
+ * - `lte`: Less than or equal (numbers, dates)
+ * - `contains`: String contains substring, or array contains value
+ * - `startsWith`: String starts with prefix
+ * - `endsWith`: String ends with suffix
+ * - `in`: Value is in array of allowed values
+ * - `notIn`: Value is not in array of disallowed values
+ */
+export declare const filterOperatorValidator: import("convex/values").VUnion<"endsWith" | "startsWith" | "in" | "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "contains" | "notIn", [import("convex/values").VLiteral<"eq", "required">, import("convex/values").VLiteral<"ne", "required">, import("convex/values").VLiteral<"gt", "required">, import("convex/values").VLiteral<"gte", "required">, import("convex/values").VLiteral<"lt", "required">, import("convex/values").VLiteral<"lte", "required">, import("convex/values").VLiteral<"contains", "required">, import("convex/values").VLiteral<"startsWith", "required">, import("convex/values").VLiteral<"endsWith", "required">, import("convex/values").VLiteral<"in", "required">, import("convex/values").VLiteral<"notIn", "required">], "required", never>;
+export type FilterOperator = Infer<typeof filterOperatorValidator>;
+/**
+ * A single field filter condition.
+ *
+ * @example
+ * ```typescript
+ * // Filter by exact title match
+ * { field: "title", operator: "eq", value: "My Post" }
+ *
+ * // Filter by price range
+ * { field: "price", operator: "gte", value: 100 }
+ *
+ * // Filter by category (in list)
+ * { field: "category", operator: "in", value: ["tech", "science"] }
+ *
+ * // Filter by tag contains
+ * { field: "tags", operator: "contains", value: "javascript" }
+ * ```
+ */
+export declare const fieldFilterValidator: import("convex/values").VObject<{
+    value: any;
+    field: string;
+    operator: "endsWith" | "startsWith" | "in" | "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "contains" | "notIn";
+}, {
+    /** The name of the field in the content entry's data object */
+    field: import("convex/values").VString<string, "required">;
+    /** The comparison operator to use */
+    operator: import("convex/values").VUnion<"endsWith" | "startsWith" | "in" | "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "contains" | "notIn", [import("convex/values").VLiteral<"eq", "required">, import("convex/values").VLiteral<"ne", "required">, import("convex/values").VLiteral<"gt", "required">, import("convex/values").VLiteral<"gte", "required">, import("convex/values").VLiteral<"lt", "required">, import("convex/values").VLiteral<"lte", "required">, import("convex/values").VLiteral<"contains", "required">, import("convex/values").VLiteral<"startsWith", "required">, import("convex/values").VLiteral<"endsWith", "required">, import("convex/values").VLiteral<"in", "required">, import("convex/values").VLiteral<"notIn", "required">], "required", never>;
+    /** The value to compare against (type depends on field type and operator) */
+    value: import("convex/values").VAny<any, "required", string>;
+}, "required", "value" | "field" | "operator" | `value.${string}`>;
+export type FieldFilter = Infer<typeof fieldFilterValidator>;
+/**
+ * Sort direction for query results.
+ */
+export declare const sortDirectionValidator: import("convex/values").VUnion<"asc" | "desc", [import("convex/values").VLiteral<"asc", "required">, import("convex/values").VLiteral<"desc", "required">], "required", never>;
+export type SortDirection = Infer<typeof sortDirectionValidator>;
+/**
+ * Sortable system fields for content entries.
+ * These are fields that exist on all content entries.
+ */
+export declare const systemSortFieldValidator: import("convex/values").VUnion<"_creationTime" | "version" | "scheduledPublishAt" | "firstPublishedAt" | "lastPublishedAt" | "_id", [import("convex/values").VLiteral<"_creationTime", "required">, import("convex/values").VLiteral<"_id", "required">, import("convex/values").VLiteral<"firstPublishedAt", "required">, import("convex/values").VLiteral<"lastPublishedAt", "required">, import("convex/values").VLiteral<"scheduledPublishAt", "required">, import("convex/values").VLiteral<"version", "required">], "required", never>;
+export type SystemSortField = Infer<typeof systemSortFieldValidator>;
+/**
+ * Sort field can be a system field or a custom data field (prefixed with "data.").
+ *
+ * @example
+ * ```typescript
+ * // System field sorting
+ * sortField: "_creationTime"
+ * sortField: "firstPublishedAt"
+ *
+ * // Custom data field sorting (prefix with "data.")
+ * sortField: "data.title"
+ * sortField: "data.price"
+ * sortField: "data.sortOrder"
+ * ```
+ */
+export declare const sortFieldValidator: import("convex/values").VString<string, "required">;
+export type SortField = string;
+/**
+ * Sort options for content entry queries.
+ *
+ * @example
+ * ```typescript
+ * // Sort by creation time (newest first)
+ * { sortField: "_creationTime", sortDirection: "desc" }
+ *
+ * // Sort by publish date (oldest published first)
+ * { sortField: "firstPublishedAt", sortDirection: "asc" }
+ *
+ * // Sort by custom field (e.g., price low to high)
+ * { sortField: "data.price", sortDirection: "asc" }
+ * ```
+ */
+export declare const sortOptionsValidator: import("convex/values").VObject<{
+    sortField: string;
+    sortDirection: "asc" | "desc";
+}, {
+    /** The field to sort by (system field or "data.fieldName" for custom fields) */
+    sortField: import("convex/values").VString<string, "required">;
+    /** The sort direction ("asc" for ascending, "desc" for descending) */
+    sortDirection: import("convex/values").VUnion<"asc" | "desc", [import("convex/values").VLiteral<"asc", "required">, import("convex/values").VLiteral<"desc", "required">], "required", never>;
+}, "required", "sortField" | "sortDirection">;
+export type SortOptions = Infer<typeof sortOptionsValidator>;
+/**
+ * Apply a single field filter to a content entry.
+ *
+ * @param entryData - The content entry's data object
+ * @param filter - The filter condition to apply
+ * @returns true if the entry matches the filter, false otherwise
+ */
+export declare function matchesFieldFilter(entryData: Record<string, unknown>, filter: FieldFilter): boolean;
+/**
+ * Apply multiple field filters to a content entry.
+ * All filters must match (AND logic).
+ *
+ * @param entryData - The content entry's data object
+ * @param filters - Array of filter conditions
+ * @returns true if the entry matches all filters, false otherwise
+ */
+export declare function matchesAllFieldFilters(entryData: Record<string, unknown>, filters: FieldFilter[]): boolean;
+/**
+ * Query to retrieve a single content entry by ID.
+ *
+ * Returns full content data including metadata and status.
+ * Optionally includes the latest version info when `includeVersion` is true.
+ *
+ * @param id - The content entry ID to retrieve
+ * @param includeVersion - Whether to include version info (default: false)
+ * @returns The content entry document, or null if not found or deleted
+ *
+ * @example
+ * ```typescript
+ * // Basic usage - get entry by ID
+ * const entry = await ctx.runQuery(api.contentEntries.get, {
+ *   id: entryId,
+ * });
+ *
+ * // With version info
+ * const entryWithVersion = await ctx.runQuery(api.contentEntries.get, {
+ *   id: entryId,
+ *   includeVersion: true,
+ * });
+ * if (entryWithVersion?.latestVersion) {
+ *   console.log("Current version:", entryWithVersion.latestVersion.versionNumber);
+ * }
+ * ```
+ */
+export declare const get: import("convex/server").RegisteredQuery<"public", {
+    includeVersion?: boolean | undefined;
+    id: import("convex/values").GenericId<"contentEntries">;
+}, Promise<{
+    latestVersion: {
+        _id: import("convex/values").GenericId<"contentVersions">;
+        _creationTime: number;
+        createdBy?: string | undefined;
+        changeDescription?: string | undefined;
+        publishedAt?: number | undefined;
+        slug: string;
+        status: string;
+        data: any;
+        entryId: import("convex/values").GenericId<"contentEntries">;
+        versionNumber: number;
+        wasPublished: boolean;
+    } | undefined;
+    _id: import("convex/values").GenericId<"contentEntries">;
+    _creationTime: number;
+    deletedAt?: number | undefined;
+    createdBy?: string | undefined;
+    updatedBy?: string | undefined;
+    searchText?: string | undefined;
+    locale?: string | undefined;
+    primaryEntryId?: import("convex/values").GenericId<"contentEntries"> | undefined;
+    scheduledPublishAt?: number | undefined;
+    firstPublishedAt?: number | undefined;
+    lastPublishedAt?: number | undefined;
+    lockedBy?: string | undefined;
+    lockExpiresAt?: number | undefined;
+    contentTypeId: import("convex/values").GenericId<"contentTypes">;
+    slug: string;
+    status: string;
+    data: any;
+    version: number;
+} | null>>;
+/**
+ * Query to retrieve a content entry by its slug and content type ID.
+ *
+ * This is the primary lookup function for frontend routing and SEO-friendly URLs.
+ * It uses the `by_content_type_and_slug` index for efficient O(1) lookups.
+ *
+ * @param contentTypeId - The ID of the content type to search within
+ * @param slug - The URL-friendly slug to look up
+ * @param status - Optional status filter (defaults to returning any status)
+ * @param includeDeleted - Whether to include soft-deleted entries (defaults to false)
+ *
+ * @returns The content entry if found, or null if not found
+ *
+ * @example
+ * ```typescript
+ * // From parent app - basic usage:
+ * const blogPost = await ctx.runQuery(components.convexCms.contentEntries.getBySlug, {
+ *   contentTypeId: blogTypeId,
+ *   slug: "my-first-post",
+ * });
+ *
+ * // With status filter for published content only (common for public sites):
+ * const publishedPost = await ctx.runQuery(components.convexCms.contentEntries.getBySlug, {
+ *   contentTypeId: blogTypeId,
+ *   slug: "my-first-post",
+ *   status: "published",
+ * });
+ *
+ * // Frontend routing example:
+ * // URL: /blog/my-first-post
+ * // -> Extract slug "my-first-post" from URL
+ * // -> Query: getBySlug({ contentTypeId: blogTypeId, slug: "my-first-post", status: "published" })
+ * ```
+ */
+export declare const getBySlug: import("convex/server").RegisteredQuery<"public", {
+    status?: string | undefined;
+    includeDeleted?: boolean | undefined;
+    contentTypeId: import("convex/values").GenericId<"contentTypes">;
+    slug: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"contentEntries">;
+    _creationTime: number;
+    deletedAt?: number | undefined;
+    createdBy?: string | undefined;
+    updatedBy?: string | undefined;
+    searchText?: string | undefined;
+    locale?: string | undefined;
+    primaryEntryId?: import("convex/values").GenericId<"contentEntries"> | undefined;
+    scheduledPublishAt?: number | undefined;
+    firstPublishedAt?: number | undefined;
+    lastPublishedAt?: number | undefined;
+    lockedBy?: string | undefined;
+    lockExpiresAt?: number | undefined;
+    contentTypeId: import("convex/values").GenericId<"contentTypes">;
+    slug: string;
+    status: string;
+    data: any;
+    version: number;
+} | null>>;
+/**
+ * Query to retrieve a content entry by its slug and content type name.
+ *
+ * This is a convenience function that looks up the content type by name first,
+ * then retrieves the entry by slug. Useful when you have the content type name
+ * (e.g., "blog_post") but not its ID.
+ *
+ * Note: This performs two index lookups (content type by name, then entry by slug),
+ * so `getBySlug` is more efficient if you already have the content type ID cached.
+ *
+ * @param contentTypeName - The machine-readable name of the content type (e.g., "blog_post")
+ * @param slug - The URL-friendly slug to look up
+ * @param status - Optional status filter (defaults to returning any status)
+ * @param includeDeleted - Whether to include soft-deleted entries (defaults to false)
+ *
+ * @returns The content entry if found, or null if not found (including if content type doesn't exist)
+ *
+ * @example
+ * ```typescript
+ * // From parent app - using content type name instead of ID:
+ * const blogPost = await ctx.runQuery(components.convexCms.contentEntries.getBySlugAndTypeName, {
+ *   contentTypeName: "blog_post",
+ *   slug: "my-first-post",
+ *   status: "published",
+ * });
+ *
+ * // Useful for static routes where content type is known at build time:
+ * // /blog/[slug] -> contentTypeName: "blog_post"
+ * // /products/[slug] -> contentTypeName: "product"
+ * // /pages/[slug] -> contentTypeName: "page"
+ * ```
+ */
+export declare const getBySlugAndTypeName: import("convex/server").RegisteredQuery<"public", {
+    status?: string | undefined;
+    includeDeleted?: boolean | undefined;
+    slug: string;
+    contentTypeName: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"contentEntries">;
+    _creationTime: number;
+    deletedAt?: number | undefined;
+    createdBy?: string | undefined;
+    updatedBy?: string | undefined;
+    searchText?: string | undefined;
+    locale?: string | undefined;
+    primaryEntryId?: import("convex/values").GenericId<"contentEntries"> | undefined;
+    scheduledPublishAt?: number | undefined;
+    firstPublishedAt?: number | undefined;
+    lastPublishedAt?: number | undefined;
+    lockedBy?: string | undefined;
+    lockExpiresAt?: number | undefined;
+    contentTypeId: import("convex/values").GenericId<"contentTypes">;
+    slug: string;
+    status: string;
+    data: any;
+    version: number;
+} | null>>;
+/**
+ * Query to list content entries with filtering, search, and cursor-based pagination.
+ *
+ * This is the primary function for retrieving multiple content entries.
+ * It uses the convex-helpers paginator for robust cursor-based pagination that
+ * integrates seamlessly with Convex's usePaginatedQuery hook.
+ *
+ * The query intelligently selects the most efficient index based on the
+ * provided filters:
+ * - Full-text search: Uses the `search_content` search index
+ * - Type + Status filter: Uses the `by_content_type_and_status` index
+ * - Type only: Uses the `by_content_type` index
+ * - Status only: Uses the `by_status` index
+ * - Locale filter: Uses the `by_locale` index
+ * - Field filters: Applied as post-processing filters on entry data
+ *
+ * @param contentTypeId - Optional content type ID to filter by
+ * @param contentTypeName - Optional content type name (resolved to ID internally)
+ * @param status - Optional status filter (draft, published, archived, scheduled)
+ * @param statusIn - Optional array of statuses to filter by (for admin views)
+ * @param locale - Optional locale code to filter by
+ * @param search - Optional full-text search query
+ * @param fieldFilters - Optional array of field filters (combined with AND logic)
+ * @param includeDeleted - Whether to include soft-deleted entries (default: false)
+ * @param paginationOpts - Standard Convex pagination options (numItems, cursor)
+ *
+ * @returns PaginationResult with page, continueCursor, and isDone
+ *
+ * @example
+ * ```typescript
+ * // List all published blog posts (frontend use case)
+ * const { page, continueCursor, isDone } = await ctx.runQuery(
+ *   components.convexCms.contentEntries.list,
+ *   {
+ *     contentTypeName: "blog_post",
+ *     status: "published",
+ *     paginationOpts: { numItems: 10 },
+ *   }
+ * );
+ *
+ * // List entries with multiple statuses (admin use case)
+ * // Shows draft and scheduled content for editorial workflow
+ * const editorialContent = await ctx.runQuery(
+ *   components.convexCms.contentEntries.list,
+ *   {
+ *     contentTypeName: "blog_post",
+ *     statusIn: ["draft", "scheduled"],
+ *     paginationOpts: { numItems: 20 },
+ *   }
+ * );
+ *
+ * // Filter by field values (e.g., category)
+ * const techPosts = await ctx.runQuery(
+ *   components.convexCms.contentEntries.list,
+ *   {
+ *     contentTypeName: "blog_post",
+ *     status: "published",
+ *     fieldFilters: [
+ *       { field: "category", operator: "eq", value: "tech" }
+ *     ],
+ *     paginationOpts: { numItems: 10 },
+ *   }
+ * );
+ *
+ * // Filter by numeric range (e.g., price)
+ * const affordableProducts = await ctx.runQuery(
+ *   components.convexCms.contentEntries.list,
+ *   {
+ *     contentTypeName: "product",
+ *     status: "published",
+ *     fieldFilters: [
+ *       { field: "price", operator: "gte", value: 10 },
+ *       { field: "price", operator: "lte", value: 100 }
+ *     ],
+ *     paginationOpts: { numItems: 20 },
+ *   }
+ * );
+ *
+ * // Filter by array contains (e.g., tags)
+ * const featuredPosts = await ctx.runQuery(
+ *   components.convexCms.contentEntries.list,
+ *   {
+ *     contentTypeName: "blog_post",
+ *     fieldFilters: [
+ *       { field: "tags", operator: "contains", value: "featured" }
+ *     ],
+ *     paginationOpts: { numItems: 10 },
+ *   }
+ * );
+ *
+ * // Paginate through results using continueCursor
+ * const page2 = await ctx.runQuery(
+ *   components.convexCms.contentEntries.list,
+ *   {
+ *     contentTypeName: "blog_post",
+ *     paginationOpts: {
+ *       numItems: 10,
+ *       cursor: previousResult.continueCursor,
+ *     },
+ *   }
+ * );
+ *
+ * // Full-text search with pagination
+ * const results = await ctx.runQuery(
+ *   components.convexCms.contentEntries.list,
+ *   {
+ *     search: "typescript tutorial",
+ *     status: "published",
+ *     paginationOpts: { numItems: 10 },
+ *   }
+ * );
+ *
+ * // Use with usePaginatedQuery React hook
+ * const { results, status, loadMore } = usePaginatedQuery(
+ *   api.contentEntries.list,
+ *   { contentTypeName: "blog_post", status: "published" },
+ *   { initialNumItems: 10 }
+ * );
+ * ```
+ */
+export declare const list: import("convex/server").RegisteredQuery<"public", {
+    contentTypeId?: import("convex/values").GenericId<"contentTypes"> | undefined;
+    status?: string | undefined;
+    locale?: string | undefined;
+    includeDeleted?: boolean | undefined;
+    search?: string | undefined;
+    contentTypeName?: string | undefined;
+    statusIn?: string[] | undefined;
+    sortField?: string | undefined;
+    sortDirection?: "asc" | "desc" | undefined;
+    fieldFilters?: {
+        value: any;
+        field: string;
+        operator: "endsWith" | "startsWith" | "in" | "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "contains" | "notIn";
+    }[] | undefined;
+    paginationOpts: {
+        id?: number;
+        endCursor?: string | null;
+        maximumRowsRead?: number;
+        maximumBytesRead?: number;
+        numItems: number;
+        cursor: string | null;
+    };
+}, Promise<ContentEntryPaginationResult>>;
+interface ContentEntryPaginationResult {
+    page: any[];
+    continueCursor: string | null;
+    isDone: boolean;
+}
+/**
+ * Query to retrieve version history for a content entry.
+ *
+ * Returns a paginated list of version snapshots ordered by version number
+ * descending (newest versions first). Each version includes:
+ * - versionNumber: The version at the time of the snapshot
+ * - data: Snapshot of the content data
+ * - slug: Snapshot of the slug
+ * - status: Status when the version was created
+ * - changeDescription: Optional description of changes
+ * - createdBy: User who created this version
+ * - wasPublished: Whether this version was published
+ * - publishedAt: When this version was published (if ever)
+ *
+ * @param entryId - The content entry ID to get version history for
+ * @param paginationOpts - Standard Convex pagination options (numItems, cursor)
+ *
+ * @returns PaginationResult with version documents, or null if entry not found
+ *
+ * @example
+ * ```typescript
+ * // Get first page of version history
+ * const history = await ctx.runQuery(
+ *   components.convexCms.contentEntries.getVersionHistory,
+ *   {
+ *     entryId: entryId,
+ *     paginationOpts: { numItems: 10 },
+ *   }
+ * );
+ *
+ * // Get published versions only
+ * const publishedVersions = history?.page.filter(v => v.wasPublished);
+ *
+ * // Paginate through history
+ * if (!history.isDone) {
+ *   const nextPage = await ctx.runQuery(
+ *     components.convexCms.contentEntries.getVersionHistory,
+ *     {
+ *       entryId: entryId,
+ *       paginationOpts: {
+ *         numItems: 10,
+ *         cursor: history.continueCursor,
+ *       },
+ *     }
+ *   );
+ * }
+ *
+ * // Compare versions
+ * const [current, previous] = history.page;
+ * console.log("Changes from v" + previous.versionNumber + " to v" + current.versionNumber);
+ * ```
+ */
+export declare const getVersionHistory: import("convex/server").RegisteredQuery<"public", {
+    entryId: import("convex/values").GenericId<"contentEntries">;
+    paginationOpts: {
+        id?: number;
+        endCursor?: string | null;
+        maximumRowsRead?: number;
+        maximumBytesRead?: number;
+        numItems: number;
+        cursor: string | null;
+    };
+}, Promise<{
+    page: {
+        _id: import("convex/values").GenericId<"contentVersions">;
+        _creationTime: number;
+        createdBy?: string | undefined;
+        changeDescription?: string | undefined;
+        publishedAt?: number | undefined;
+        slug: string;
+        status: string;
+        data: any;
+        entryId: import("convex/values").GenericId<"contentEntries">;
+        versionNumber: number;
+        wasPublished: boolean;
+    }[];
+    continueCursor: string;
+    isDone: boolean;
+} | null>>;
+/**
+ * Retrieve a specific version of a content entry by version ID or number.
+ *
+ * This query allows fetching the complete content state at a specific version,
+ * which is useful for:
+ * - Version comparison/diff views
+ * - Previewing historical content states
+ * - Rollback preparation (viewing what content looked like)
+ * - Audit trail investigation
+ *
+ * ## Lookup Methods
+ *
+ * You can retrieve a version by either:
+ * 1. **Version ID** (`versionId`): Direct document lookup using the `_id` field
+ * 2. **Version Number** (`versionNumber`): Uses the compound index for efficient lookup
+ *
+ * At least one of `versionId` or `versionNumber` must be provided.
+ * If both are provided, `versionId` takes precedence.
+ *
+ * ## Security
+ *
+ * - Returns `null` if the parent entry doesn't exist or has been soft-deleted
+ * - Validates that the version belongs to the specified entry (prevents cross-entry access)
+ *
+ * ## Example Usage
+ *
+ * ```typescript
+ * // Get version by version number
+ * const versionByNumber = await ctx.runQuery(
+ *   api.contentEntries.getVersion,
+ *   {
+ *     entryId: entryId,
+ *     versionNumber: 3
+ *   }
+ * );
+ *
+ * // Get version by version ID
+ * const versionById = await ctx.runQuery(
+ *   api.contentEntries.getVersion,
+ *   {
+ *     entryId: entryId,
+ *     versionId: someVersionId
+ *   }
+ * );
+ *
+ * // Access version data
+ * if (versionByNumber) {
+ *   console.log("Content at v3:", versionByNumber.data);
+ *   console.log("Slug at v3:", versionByNumber.slug);
+ *   console.log("Status at v3:", versionByNumber.status);
+ *   console.log("Was published:", versionByNumber.wasPublished);
+ * }
+ * ```
+ */
+export declare const getVersion: import("convex/server").RegisteredQuery<"public", {
+    versionNumber?: number | undefined;
+    versionId?: import("convex/values").GenericId<"contentVersions"> | undefined;
+    entryId: import("convex/values").GenericId<"contentEntries">;
+}, Promise<{
+    _id: import("convex/values").GenericId<"contentVersions">;
+    _creationTime: number;
+    createdBy?: string | undefined;
+    changeDescription?: string | undefined;
+    publishedAt?: number | undefined;
+    slug: string;
+    status: string;
+    data: any;
+    entryId: import("convex/values").GenericId<"contentEntries">;
+    versionNumber: number;
+    wasPublished: boolean;
+} | null>>;
+/**
+ * Compare two versions of a content entry and return field-level differences.
+ *
+ * This query retrieves two version snapshots by version number and computes
+ * a detailed diff showing which fields changed, what the before/after values
+ * are, and whether metadata like slug and status also changed.
+ *
+ * @example
+ * ```typescript
+ * // Compare version 2 to version 5 of an entry
+ * const diff = await ctx.runQuery(api.contentEntries.compareVersions, {
+ *   entryId: entryId,
+ *   fromVersionNumber: 2,
+ *   toVersionNumber: 5,
+ * });
+ *
+ * if (diff.hasChanges) {
+ *   console.log("Changes:", diff.changeSummary);
+ *   for (const fieldDiff of diff.fieldDiffs) {
+ *     console.log(`Field: ${fieldDiff.field}`);
+ *     console.log(`  Change type: ${fieldDiff.changeType}`);
+ *     console.log(`  From: ${JSON.stringify(fieldDiff.fromValue)}`);
+ *     console.log(`  To: ${JSON.stringify(fieldDiff.toValue)}`);
+ *   }
+ * }
+ * ```
+ *
+ * @param entryId - The ID of the content entry to compare versions for
+ * @param fromVersionNumber - The version number of the "from" (older/base) version
+ * @param toVersionNumber - The version number of the "to" (newer/target) version
+ * @returns Detailed comparison result or null if entry is deleted or versions don't exist
+ */
+export declare const compareVersions: import("convex/server").RegisteredQuery<"public", {
+    entryId: import("convex/values").GenericId<"contentEntries">;
+    fromVersionNumber: number;
+    toVersionNumber: number;
+}, Promise<{
+    hasChanges: boolean;
+    fromVersion: {
+        versionNumber: number;
+        status: string;
+        slug: string;
+        wasPublished: boolean;
+        createdAt: number;
+    };
+    toVersion: {
+        versionNumber: number;
+        status: string;
+        slug: string;
+        wasPublished: boolean;
+        createdAt: number;
+    };
+    changedFields: string[];
+    fieldDiffs: {
+        fromValue?: any;
+        toValue?: any;
+        field: string;
+        changeType: "added" | "removed" | "modified";
+    }[];
+    slugChanged: boolean;
+    statusChanged: boolean;
+    changeSummary: string;
+} | null>>;
+/**
+ * Query to count content entries matching the given filters.
+ *
+ * This query efficiently counts entries without loading all entry data.
+ * It uses database indexes for filtering and iterates through matching
+ * entries to provide an accurate count regardless of the number of entries.
+ *
+ * Unlike the `list` query which is limited by pagination, this query
+ * counts ALL matching entries and returns the total.
+ *
+ * @param contentTypeId - Optional content type ID to filter by
+ * @param contentTypeName - Optional content type name (resolved to ID internally)
+ * @param status - Optional single status filter
+ * @param statusIn - Optional array of statuses to filter by
+ * @param includeDeleted - Whether to include soft-deleted entries (default: false)
+ *
+ * @returns Object containing the count of matching entries
+ *
+ * @example
+ * ```typescript
+ * // Count all entries for a content type
+ * const { count } = await ctx.runQuery(
+ *   components.convexCms.contentEntries.count,
+ *   { contentTypeId: blogTypeId }
+ * );
+ * console.log(`Blog posts: ${count}`);
+ *
+ * // Count published entries only
+ * const { count: publishedCount } = await ctx.runQuery(
+ *   components.convexCms.contentEntries.count,
+ *   { contentTypeId: blogTypeId, status: "published" }
+ * );
+ *
+ * // Count entries by content type name
+ * const { count: productCount } = await ctx.runQuery(
+ *   components.convexCms.contentEntries.count,
+ *   { contentTypeName: "product" }
+ * );
+ * ```
+ */
+export declare const count: import("convex/server").RegisteredQuery<"public", {
+    contentTypeId?: import("convex/values").GenericId<"contentTypes"> | undefined;
+    status?: string | undefined;
+    includeDeleted?: boolean | undefined;
+    contentTypeName?: string | undefined;
+    statusIn?: string[] | undefined;
+}, Promise<{
+    count: number;
+}>>;
+export {};
+//# sourceMappingURL=contentEntries.d.ts.map