convex-cms 0.0.1

package/dist/client/wrapper.d.ts

@@ -0,0 +1,2198 @@
+/** CMS Client Wrapper with typed method APIs */
+import type { GenericDataModel, GenericMutationCtx } from "convex/server";
+import type { ComponentApi as GeneratedComponentApi } from "../component/_generated/component.js";
+import type { ComponentConfig, ResolvedComponentConfig, FeatureFlags, LocaleCode, ContentType, ContentEntry, ContentVersion, MediaAsset, MediaFolder, PaginationResult, PaginationOpts, GetUserRoleResult, AuthorizationHookContext, CmsOperation, VersionComparison, MediaVariant, MediaVariantWithUrl } from "./types.js";
+import { ContentQueryBuilder } from "./queryBuilder.js";
+import { type AuthorizationResult } from "../component/authorizationHooks.js";
+import { type RateLimitResult } from "../component/rateLimitHooks.js";
+import { type Resource, type Action, type OwnershipScope, type RoleDefinition } from "../component/roles.js";
+import { type LocaleFallbackConfig, type ResolvedFallbackChain } from "../component/localeFallbackChain.js";
+import { type LocaleResolvedEntry, type ResolveLocaleOptions } from "../component/localeFields.js";
+/**
+ * Options for resolving locale content in client wrapper methods.
+ * Extends ResolveLocaleOptions but makes fields required since
+ * they are needed for proper locale resolution.
+ */
+export type ResolveLocaleContentOptions = ResolveLocaleOptions;
+/**
+ * Authorization helper interface passed to API classes.
+ * This allows API methods to perform authorization checks before mutations.
+ *
+ * When authorization is not configured (getUserRole not provided), the helper
+ * will be undefined and authorization checks will be skipped.
+ */
+export interface AuthorizationHelper {
+    /**
+     * Get the user's CMS role.
+     * @param ctx - The Convex context (provides database and auth access to hooks)
+     * @param userId - The user ID to look up
+     * @returns The role name or null if user has no role
+     */
+    getUserRole(ctx: ConvexContext, userId: string): Promise<string | null>;
+    /**
+     * Perform authorization check and throw if denied.
+     * @param ctx - The Convex context (provides database and auth access to hooks)
+     * @param context - The authorization context
+     * @throws UnauthorizedError if the operation is not allowed
+     */
+    requireAuthorization(ctx: ConvexContext, context: Omit<AuthorizationHookContext, 'ctx'>): Promise<AuthorizationResult>;
+    /**
+     * Whether RBAC should be skipped (from config.skipRbac).
+     */
+    skipRbac: boolean;
+}
+/**
+ * Rate limit helper interface passed to API classes.
+ * This allows API methods to enforce rate limits before mutations.
+ *
+ * When rate limiting is not configured (no rateLimitHooks provided), the helper
+ * will be undefined and rate limiting checks will be skipped.
+ */
+export interface RateLimitHelper {
+    /**
+     * Get the user's CMS role for rate limit context.
+     * @param ctx - The Convex context (for database access)
+     * @param userId - The user ID to look up
+     * @returns The role name or null if user has no role
+     */
+    getUserRole(ctx: ConvexContext, userId: string): Promise<string | null>;
+    /**
+     * Enforce rate limit for an operation. Throws RateLimitedError if rate limited.
+     * @param operation - The CMS operation being performed
+     * @param options - Additional context for rate limiting
+     * @throws RateLimitedError if the operation is rate limited
+     */
+    requireRateLimit(operation: CmsOperation, options: {
+        userId?: string;
+        role?: string | null;
+        contentTypeId?: string;
+        contentTypeName?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<RateLimitResult>;
+}
+/** Convex context for CMS operations - includes db/auth for authorization hooks */
+export type ConvexContext = Pick<GenericMutationCtx<GenericDataModel>, "runMutation" | "runQuery" | "db" | "auth">;
+/** Component API type from `components.convexCms` */
+export type TypedComponentApi = GeneratedComponentApi;
+/**
+ * Partial component API type for testing purposes.
+ *
+ * This type allows partial/mock implementations of the component API
+ * for unit testing without requiring full type conformance.
+ * In production, use TypedComponentApi instead.
+ *
+ * @example
+ * ```typescript
+ * // In test files
+ * const mockApi: MockComponentApi = {
+ *   contentEntries: {
+ *     list: { _type: "query" } ,
+ *   },
+ * } as MockComponentApi;
+ * ```
+ */
+export type MockComponentApi = Partial<{
+    [K in keyof TypedComponentApi]: Partial<TypedComponentApi[K]>;
+}>;
+export type { CreateContentTypeArgs, UpdateContentTypeArgs, DeleteContentTypeArgs, GetContentTypeArgs, ListContentTypesArgs, CreateContentEntryArgs, UpdateContentEntryArgs, DeleteContentEntryArgs, GetContentEntryArgs, GetContentEntryBySlugArgs, ListContentEntriesArgs, PublishEntryArgs, UnpublishEntryArgs, ScheduleEntryArgs, RestoreEntryArgs, DuplicateEntryArgs, BulkPublishArgs, BulkUnpublishArgs, BulkDeleteArgs, BulkUpdateArgs, BulkRestoreArgs, GetVersionArgs, GetVersionHistoryArgs, RollbackVersionArgs, CompareVersionsArgs, CreateMediaAssetArgs, UpdateMediaAssetArgs, DeleteMediaAssetArgs, GetMediaAssetArgs, ListMediaAssetsArgs, RestoreMediaAssetArgs, FindMediaAssetReferencesArgs, CreateMediaFolderArgs, UpdateMediaFolderArgs, DeleteMediaFolderArgs, GetMediaFolderArgs, ListMediaFoldersArgs, MoveFolderArgs, RestoreMediaFolderArgs, GetMediaFolderByPathArgs, GetFolderTreeArgs, MoveMediaAssetsArgs, CreateMediaVariantArgs, RequestVariantGenerationArgs, DeleteMediaVariantArgs, DeleteAssetVariantsArgs, GetMediaVariantArgs, ListMediaVariantsArgs, GetBestVariantArgs, GenerateFromPresetsArgs, GenerateUploadUrlArgs, BreakingChange, UpdateContentTypeResult, DeleteContentTypeResult, BulkOperationItemResult, BulkOperationResult, GenerateUploadUrlResult, MediaAssetReference, GenerateVariantsResult, SrcsetEntry, ResponsiveSrcsetResult, VariantPreset, AssetWithVariants, } from "./argTypes.js";
+import type { CreateContentTypeArgs, UpdateContentTypeArgs, DeleteContentTypeArgs, GetContentTypeArgs, ListContentTypesArgs, CreateContentEntryArgs, UpdateContentEntryArgs, DeleteContentEntryArgs, GetContentEntryArgs, GetContentEntryBySlugArgs, ListContentEntriesArgs, PublishEntryArgs, UnpublishEntryArgs, ScheduleEntryArgs, RestoreEntryArgs, DuplicateEntryArgs, BulkPublishArgs, BulkUnpublishArgs, BulkDeleteArgs, BulkUpdateArgs, BulkRestoreArgs, GetVersionArgs, GetVersionHistoryArgs, RollbackVersionArgs, CompareVersionsArgs, CreateMediaAssetArgs, UpdateMediaAssetArgs, DeleteMediaAssetArgs, GetMediaAssetArgs, ListMediaAssetsArgs, RestoreMediaAssetArgs, FindMediaAssetReferencesArgs, CreateMediaFolderArgs, UpdateMediaFolderArgs, DeleteMediaFolderArgs, GetMediaFolderArgs, ListMediaFoldersArgs, MoveFolderArgs, RestoreMediaFolderArgs, GetMediaFolderByPathArgs, GetFolderTreeArgs, CreateMediaVariantArgs, RequestVariantGenerationArgs, DeleteMediaVariantArgs, DeleteAssetVariantsArgs, ListMediaVariantsArgs, GetBestVariantArgs, GenerateFromPresetsArgs, GenerateUploadUrlArgs, UpdateContentTypeResult, DeleteContentTypeResult, BulkOperationResult, GenerateUploadUrlResult, MediaAssetReference, GenerateVariantsResult, ResponsiveSrcsetResult, VariantPreset, AssetWithVariants } from "./argTypes.js";
+/** Content type CRUD operations */
+export declare class ContentTypesApi {
+    private readonly api;
+    private readonly config;
+    private readonly authHelper?;
+    private readonly rateLimitHelper?;
+    constructor(api: TypedComponentApi, config: ResolvedComponentConfig, authHelper?: AuthorizationHelper | undefined, rateLimitHelper?: RateLimitHelper | undefined);
+    /** @throws AuthorizationNotConfiguredError if not configured and not in permissiveMode */
+    private authorize;
+    private rateLimit;
+    create(ctx: ConvexContext, args: CreateContentTypeArgs): Promise<ContentType>;
+    /** Detects breaking changes; fails unless force:true is specified */
+    update(ctx: ConvexContext, args: UpdateContentTypeArgs): Promise<UpdateContentTypeResult>;
+    /** Soft delete by default; use hardDelete:true for permanent, cascade:true to delete entries */
+    delete(ctx: ConvexContext, args: DeleteContentTypeArgs): Promise<DeleteContentTypeResult>;
+    /**
+     * Get a content type by ID or name.
+     *
+     * @param ctx - Convex query context
+     * @param args - Get arguments (id or name)
+     * @returns The content type or null if not found
+     *
+     * @example
+     * ```typescript
+     * // Get by ID (fastest - direct document lookup)
+     * const type = await cms.contentTypes.get(ctx, { id: typeId });
+     *
+     * // Get by name (uses index)
+     * const type = await cms.contentTypes.get(ctx, { name: "blog_post" });
+     *
+     * // Include soft-deleted types
+     * const type = await cms.contentTypes.get(ctx, {
+     *   name: "archived_type",
+     *   includeDeleted: true,
+     * });
+     * ```
+     */
+    get(ctx: ConvexContext, args: GetContentTypeArgs): Promise<ContentType | null>;
+    /**
+     * Get a content type by name.
+     *
+     * Convenience method that wraps `get()` for name-based lookup.
+     *
+     * @param ctx - Convex query context
+     * @param name - The machine-readable name of the content type
+     * @param includeDeleted - Whether to include soft-deleted types
+     * @returns The content type or null if not found
+     *
+     * @example
+     * ```typescript
+     * const blogType = await cms.contentTypes.getByName(ctx, "blog_post");
+     * if (blogType) {
+     *   console.log("Fields:", blogType.fields);
+     * }
+     * ```
+     */
+    getByName(ctx: ConvexContext, name: string, includeDeleted?: boolean): Promise<ContentType | null>;
+    getById(ctx: ConvexContext, id: string, includeDeleted?: boolean): Promise<ContentType | null>;
+    exists(ctx: ConvexContext, name: string, includeDeleted?: boolean): Promise<boolean>;
+    list(ctx: ConvexContext, args?: ListContentTypesArgs): Promise<PaginationResult<ContentType>>;
+    listActive(ctx: ConvexContext, paginationOpts?: PaginationOpts): Promise<PaginationResult<ContentType>>;
+    getAll(ctx: ConvexContext, includeInactive?: boolean): Promise<ContentType[]>;
+    /**
+     * @example
+     * ```typescript
+     * const count = await cms.contentTypes.count(ctx);
+     * console.log(`You have ${count} content types`);
+     * ```
+     */
+    count(ctx: ConvexContext, includeInactive?: boolean): Promise<number>;
+    /**
+     * Deactivate a content type without deleting it.
+     *
+     * Deactivated types remain in the database but are filtered out by default
+     * when listing content types. Existing content entries remain accessible.
+     *
+     * @param ctx - Convex mutation context
+     * @param id - The content type ID to deactivate
+     * @param updatedBy - User ID making the change
+     * @returns The updated content type
+     *
+     * @example
+     * ```typescript
+     * await cms.contentTypes.deactivate(ctx, contentTypeId, currentUserId);
+     * ```
+     */
+    deactivate(ctx: ConvexContext, id: string, updatedBy?: string): Promise<UpdateContentTypeResult>;
+    /**
+     * Reactivate a previously deactivated content type.
+     *
+     * @param ctx - Convex mutation context
+     * @param id - The content type ID to reactivate
+     * @param updatedBy - User ID making the change
+     * @returns The updated content type
+     *
+     * @example
+     * ```typescript
+     * await cms.contentTypes.reactivate(ctx, contentTypeId, currentUserId);
+     * ```
+     */
+    reactivate(ctx: ConvexContext, id: string, updatedBy?: string): Promise<UpdateContentTypeResult>;
+}
+/** Content entry CRUD and workflow operations */
+export declare class ContentEntriesApi {
+    private readonly api;
+    private readonly config;
+    private readonly authHelper?;
+    private readonly rateLimitHelper?;
+    constructor(api: TypedComponentApi, config: ResolvedComponentConfig, authHelper?: AuthorizationHelper | undefined, rateLimitHelper?: RateLimitHelper | undefined);
+    /** @throws AuthorizationNotConfiguredError if not configured and not in permissiveMode */
+    private authorize;
+    private rateLimit;
+    create(ctx: ConvexContext, args: CreateContentEntryArgs): Promise<ContentEntry>;
+    update(ctx: ConvexContext, args: UpdateContentEntryArgs): Promise<ContentEntry>;
+    delete(ctx: ConvexContext, args: DeleteContentEntryArgs): Promise<ContentEntry>;
+    get(ctx: ConvexContext, args: GetContentEntryArgs): Promise<ContentEntry | null>;
+    /** Looks up by contentTypeId+slug or contentTypeName+slug */
+    getBySlug(ctx: ConvexContext, args: GetContentEntryBySlugArgs): Promise<ContentEntry | null>;
+    /** Standard Convex pagination format compatible with usePaginatedQuery */
+    list(ctx: ConvexContext, args: ListContentEntriesArgs): Promise<PaginationResult<ContentEntry>>;
+    /**
+     * Publish a content entry.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Publish arguments
+     * @returns The published entry
+     */
+    publish(ctx: ConvexContext, args: PublishEntryArgs): Promise<ContentEntry>;
+    /**
+     * Unpublish a content entry (revert to draft).
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Unpublish arguments
+     * @returns The unpublished entry
+     */
+    unpublish(ctx: ConvexContext, args: UnpublishEntryArgs): Promise<ContentEntry>;
+    /**
+     * Schedule a content entry for future publication.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Schedule arguments
+     * @returns The scheduled entry
+     *
+     * @example
+     * ```typescript
+     * await cms.contentEntries.schedule(ctx, {
+     *   id: entryId,
+     *   publishAt: Date.now() + 24 * 60 * 60 * 1000, // Tomorrow
+     * });
+     * ```
+     */
+    schedule(ctx: ConvexContext, args: ScheduleEntryArgs): Promise<ContentEntry>;
+    /**
+     * Restore a soft-deleted content entry.
+     *
+     * Removes the deletedAt timestamp from a soft-deleted entry,
+     * making it active again. Only works for soft-deleted entries;
+     * hard-deleted entries cannot be recovered.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Restore arguments
+     * @returns The restored entry
+     *
+     * @example
+     * ```typescript
+     * // Restore a soft-deleted entry
+     * const restored = await cms.contentEntries.restore(ctx, {
+     *   id: entryId,
+     *   restoredBy: currentUserId,
+     * });
+     * console.log(restored.deletedAt); // undefined
+     * ```
+     */
+    restore(ctx: ConvexContext, args: RestoreEntryArgs): Promise<ContentEntry>;
+    /**
+     * Create a fluent query builder for constructing complex content queries.
+     *
+     * The query builder provides a chainable API for building queries with:
+     * - Content type filtering
+     * - Status filtering (single or multiple)
+     * - Field-level filters with various operators
+     * - Full-text search
+     * - Locale filtering
+     * - Cursor-based pagination
+     * - Sort direction
+     *
+     * @returns A new ContentQueryBuilder instance
+     *
+     * @example
+     * ```typescript
+     * // Simple query
+     * const posts = await cms.contentEntries
+     *   .query()
+     *   .contentType("blog_post")
+     *   .status("published")
+     *   .limit(10)
+     *   .execute(ctx);
+     *
+     * // Complex query with field filters
+     * const featured = await cms.contentEntries
+     *   .query()
+     *   .contentType("blog_post")
+     *   .where("category", "eq", "technology")
+     *   .whereContains("tags", "featured")
+     *   .whereGreaterThan("views", 100)
+     *   .newestFirst()
+     *   .limit(5)
+     *   .execute(ctx);
+     *
+     * // Pagination
+     * const page1 = await cms.contentEntries
+     *   .query()
+     *   .contentType("blog_post")
+     *   .limit(20)
+     *   .execute(ctx);
+     *
+     * const page2 = await cms.contentEntries
+     *   .query()
+     *   .contentType("blog_post")
+     *   .limit(20)
+     *   .cursor(page1.continueCursor)
+     *   .execute(ctx);
+     *
+     * // Get first result only
+     * const latest = await cms.contentEntries
+     *   .query()
+     *   .contentType("blog_post")
+     *   .published()
+     *   .newestFirst()
+     *   .first(ctx);
+     *
+     * // Check if results exist
+     * const hasPublished = await cms.contentEntries
+     *   .query()
+     *   .contentType("blog_post")
+     *   .published()
+     *   .exists(ctx);
+     * ```
+     */
+    query(): ContentQueryBuilder;
+    /**
+     * Resolve locale content for a single content entry.
+     *
+     * Takes a content entry with potentially localized field values and resolves
+     * all localized fields to single values based on the requested locale and
+     * fallback chain. This merges localized and default field values.
+     *
+     * Resolution order for each localized field:
+     * 1. Try the requested locale
+     * 2. Try each locale in the fallback chain (in order)
+     * 3. Try the default locale
+     * 4. Return first available locale as last resort
+     *
+     * @param entry - The content entry to resolve (with raw localized data)
+     * @param options - Locale resolution options
+     * @returns The entry with resolved data and metadata about resolution
+     *
+     * @example
+     * ```typescript
+     * // Get an entry
+     * const entry = await cms.contentEntries.get(ctx, { id: entryId });
+     *
+     * // Resolve to Spanish with English fallback
+     * const resolved = cms.contentEntries.resolveLocale(entry, {
+     *   locale: "es-ES",
+     *   fallbackChain: ["en-US"],
+     *   defaultLocale: "en-US",
+     *   fields: contentType.fields,
+     * });
+     *
+     * // Access resolved data
+     * console.log(resolved.data.title); // "Hola" (Spanish) or "Hello" (English fallback)
+     *
+     * // Check which fields used fallback
+     * if (resolved.localeResolution.fieldsFromFallback.includes("title")) {
+     *   console.log("Title was not translated to Spanish");
+     * }
+     *
+     * // See which locale each field was resolved from
+     * console.log(resolved.localeResolution.fieldResolutions);
+     * // { content: "en-US" } - content was resolved from English
+     * ```
+     */
+    resolveLocale<T extends ContentEntry>(entry: T, options: ResolveLocaleContentOptions): T & LocaleResolvedEntry;
+    /**
+     * Resolve locale content for multiple content entries.
+     *
+     * Convenience method for batch-resolving a list of entries.
+     * Useful after fetching a paginated list of content entries.
+     *
+     * @param entries - Array of content entries to resolve
+     * @param options - Locale resolution options (applied to all entries)
+     * @returns Array of entries with resolved locale data
+     *
+     * @example
+     * ```typescript
+     * // Fetch published blog posts
+     * const { page } = await cms.contentEntries.list(ctx, {
+     *   contentTypeName: "blog_post",
+     *   status: "published",
+     *   paginationOpts: { numItems: 10 },
+     * });
+     *
+     * // Resolve all entries to Spanish
+     * const resolvedPosts = cms.contentEntries.resolveLocaleBatch(page, {
+     *   locale: "es-ES",
+     *   fallbackChain: cms.getLocaleFallbackChain("es-ES"),
+     *   defaultLocale: cms.config.defaultLocale,
+     *   fields: blogPostType.fields,
+     * });
+     *
+     * // Use resolved data
+     * for (const post of resolvedPosts) {
+     *   console.log(post.data.title); // Resolved title in Spanish or fallback
+     * }
+     * ```
+     */
+    resolveLocaleBatch<T extends ContentEntry>(entries: T[], options: ResolveLocaleContentOptions): Array<T & LocaleResolvedEntry>;
+    /**
+     * List content entries with automatic locale resolution.
+     *
+     * This is a convenience method that combines `list()` and `resolveLocaleBatch()`
+     * into a single call. It fetches content entries and automatically resolves
+     * all localized fields to the requested locale with fallback support.
+     *
+     * Note: This method requires the content type's field definitions to properly
+     * resolve localized fields. You can either pass them explicitly or let the
+     * method fetch them automatically (requires an extra query).
+     *
+     * @param ctx - Convex query context
+     * @param args - Query options with pagination
+     * @param localeOptions - Locale resolution options
+     * @returns Paginated result with locale-resolved entries
+     *
+     * @example
+     * ```typescript
+     * // List with locale resolution
+     * const { page, continueCursor, isDone } = await cms.contentEntries.listWithLocale(
+     *   ctx,
+     *   {
+     *     contentTypeName: "blog_post",
+     *     status: "published",
+     *     paginationOpts: { numItems: 10 },
+     *   },
+     *   {
+     *     locale: "es-ES",
+     *     fields: blogPostType.fields, // Required for resolution
+     *   }
+     * );
+     *
+     * // All entries have resolved locale data
+     * for (const post of page) {
+     *   console.log(post.data.title); // Resolved title
+     *   console.log(post.localeResolution.fieldsFromFallback); // Which fields used fallback
+     * }
+     * ```
+     */
+    listWithLocale(ctx: ConvexContext, args: ListContentEntriesArgs, localeOptions: ResolveLocaleContentOptions): Promise<PaginationResult<ContentEntry & LocaleResolvedEntry>>;
+    /**
+     * Get a content entry by ID with automatic locale resolution.
+     *
+     * Fetches the entry and resolves all localized fields to the requested locale.
+     *
+     * @param ctx - Convex query context
+     * @param args - Get arguments
+     * @param localeOptions - Locale resolution options
+     * @returns The entry with resolved locale data, or null if not found
+     *
+     * @example
+     * ```typescript
+     * const post = await cms.contentEntries.getWithLocale(
+     *   ctx,
+     *   { id: entryId },
+     *   {
+     *     locale: "es-ES",
+     *     fallbackChain: ["en-US"],
+     *     defaultLocale: "en-US",
+     *     fields: blogPostType.fields,
+     *   }
+     * );
+     *
+     * if (post) {
+     *   console.log(post.data.title); // Resolved title
+     * }
+     * ```
+     */
+    getWithLocale(ctx: ConvexContext, args: GetContentEntryArgs, localeOptions: ResolveLocaleContentOptions): Promise<(ContentEntry & LocaleResolvedEntry) | null>;
+    /**
+     * Get a content entry by slug with automatic locale resolution.
+     *
+     * Fetches the entry by slug and resolves all localized fields to the requested locale.
+     *
+     * @param ctx - Convex query context
+     * @param args - Get by slug arguments
+     * @param localeOptions - Locale resolution options
+     * @returns The entry with resolved locale data, or null if not found
+     *
+     * @example
+     * ```typescript
+     * const post = await cms.contentEntries.getBySlugWithLocale(
+     *   ctx,
+     *   {
+     *     contentTypeName: "blog_post",
+     *     slug: "hello-world",
+     *   },
+     *   {
+     *     locale: "es-ES",
+     *     fields: blogPostType.fields,
+     *   }
+     * );
+     * ```
+     */
+    getBySlugWithLocale(ctx: ConvexContext, args: GetContentEntryBySlugArgs, localeOptions: ResolveLocaleContentOptions): Promise<(ContentEntry & LocaleResolvedEntry) | null>;
+    /**
+     * Duplicate a content entry.
+     *
+     * Creates a copy of an existing content entry with a new unique slug.
+     * The duplicate always starts as a draft, regardless of the source entry's status.
+     * Media references are copied by default but can be cleared.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Duplicate arguments
+     * @returns The duplicated entry
+     *
+     * @example
+     * ```typescript
+     * // Simple duplication with auto-generated slug
+     * const copy = await cms.contentEntries.duplicate(ctx, {
+     *   sourceEntryId: originalPost._id,
+     *   createdBy: currentUserId,
+     * });
+     *
+     * // Duplicate with custom slug
+     * const copy = await cms.contentEntries.duplicate(ctx, {
+     *   sourceEntryId: templateId,
+     *   slug: "new-post-from-template",
+     *   createdBy: currentUserId,
+     * });
+     *
+     * // Duplicate without media references (for a fresh start)
+     * const copy = await cms.contentEntries.duplicate(ctx, {
+     *   sourceEntryId: originalPost._id,
+     *   copyMediaReferences: false,
+     *   createdBy: currentUserId,
+     * });
+     * ```
+     */
+    duplicate(ctx: ConvexContext, args: DuplicateEntryArgs): Promise<ContentEntry>;
+    /**
+     * Publish multiple content entries in a single transaction.
+     *
+     * This is more efficient than publishing entries one by one. Each entry that
+     * is already published will be skipped (idempotent behavior). Deleted or
+     * archived entries will fail with an error message.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Bulk publish arguments
+     * @returns Bulk operation result with success/failure details for each entry
+     *
+     * @example
+     * ```typescript
+     * const result = await cms.contentEntries.bulkPublish(ctx, {
+     *   ids: [entry1._id, entry2._id, entry3._id],
+     *   changeDescription: "Publishing launch content",
+     *   updatedBy: currentUserId,
+     * });
+     * console.log(`Published ${result.succeeded} of ${result.total} entries`);
+     * if (result.failed > 0) {
+     *   result.results.filter(r => !r.success).forEach(r => {
+     *     console.error(`Failed to publish ${r.id}: ${r.error}`);
+     *   });
+     * }
+     * ```
+     */
+    bulkPublish(ctx: ConvexContext, args: BulkPublishArgs): Promise<BulkOperationResult>;
+    /**
+     * Unpublish multiple content entries in a single transaction.
+     *
+     * Reverts published entries to draft status. Non-published entries are
+     * skipped (idempotent behavior).
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Bulk unpublish arguments
+     * @returns Bulk operation result with success/failure details for each entry
+     *
+     * @example
+     * ```typescript
+     * const result = await cms.contentEntries.bulkUnpublish(ctx, {
+     *   ids: [entry1._id, entry2._id],
+     *   updatedBy: currentUserId,
+     * });
+     * ```
+     */
+    bulkUnpublish(ctx: ConvexContext, args: BulkUnpublishArgs): Promise<BulkOperationResult>;
+    /**
+     * Delete multiple content entries in a single transaction.
+     *
+     * By default, performs soft delete (entries can be restored later).
+     * When hardDelete is true, permanently removes entries and all their versions.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Bulk delete arguments
+     * @returns Bulk operation result with success/failure details for each entry
+     *
+     * @example
+     * ```typescript
+     * // Soft delete (default)
+     * const result = await cms.contentEntries.bulkDelete(ctx, {
+     *   ids: [entry1._id, entry2._id],
+     *   deletedBy: currentUserId,
+     * });
+     *
+     * // Hard delete (permanent)
+     * const result = await cms.contentEntries.bulkDelete(ctx, {
+     *   ids: [entry1._id, entry2._id],
+     *   deletedBy: currentUserId,
+     *   hardDelete: true,
+     * });
+     * ```
+     */
+    bulkDelete(ctx: ConvexContext, args: BulkDeleteArgs): Promise<BulkOperationResult>;
+    /**
+     * Update multiple content entries with the same changes in a single transaction.
+     *
+     * Applies the same data updates and/or status change to all specified entries.
+     * Data is merged with existing data for each entry (partial updates).
+     * Each entry is validated against its content type schema.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Bulk update arguments
+     * @returns Bulk operation result with success/failure details for each entry
+     *
+     * @example
+     * ```typescript
+     * // Update data for multiple entries
+     * const result = await cms.contentEntries.bulkUpdate(ctx, {
+     *   ids: [entry1._id, entry2._id, entry3._id],
+     *   data: { featured: true, category: "news" },
+     *   updatedBy: currentUserId,
+     * });
+     *
+     * // Change status for multiple entries
+     * const result = await cms.contentEntries.bulkUpdate(ctx, {
+     *   ids: [entry1._id, entry2._id],
+     *   status: "archived",
+     *   updatedBy: currentUserId,
+     * });
+     * ```
+     */
+    bulkUpdate(ctx: ConvexContext, args: BulkUpdateArgs): Promise<BulkOperationResult>;
+    /**
+     * Restore multiple soft-deleted content entries in a single transaction.
+     *
+     * Removes the deletedAt marker from entries, making them active again.
+     * Only works for soft-deleted entries. Non-deleted entries are skipped
+     * (idempotent behavior).
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Bulk restore arguments
+     * @returns Bulk operation result with success/failure details for each entry
+     *
+     * @example
+     * ```typescript
+     * const result = await cms.contentEntries.bulkRestore(ctx, {
+     *   ids: [deletedEntry1._id, deletedEntry2._id],
+     *   restoredBy: currentUserId,
+     * });
+     * ```
+     */
+    bulkRestore(ctx: ConvexContext, args: BulkRestoreArgs): Promise<BulkOperationResult>;
+}
+/**
+ * Wrapper for content version operations.
+ *
+ * Provides comprehensive version management including:
+ * - Version history retrieval with pagination
+ * - Getting specific versions by ID or number
+ * - Version comparison and diff generation
+ * - Rollback functionality
+ * - Finding latest and published versions
+ *
+ * @example
+ * ```typescript
+ * // Get version history for an entry
+ * const history = await cms.versions.getHistory(ctx, {
+ *   entryId: entry._id,
+ *   paginationOpts: { numItems: 10 },
+ * });
+ *
+ * // Compare two versions
+ * const diff = await cms.versions.compare(ctx, {
+ *   entryId: entry._id,
+ *   fromVersionNumber: 1,
+ *   toVersionNumber: 5,
+ * });
+ *
+ * // Rollback to a previous version
+ * await cms.versions.rollback(ctx, {
+ *   entryId: entry._id,
+ *   versionNumber: 3,
+ * });
+ * ```
+ */
+export declare class VersionsApi {
+    private readonly api;
+    private readonly config;
+    private readonly authHelper?;
+    private readonly rateLimitHelper?;
+    constructor(api: TypedComponentApi, config: ResolvedComponentConfig, authHelper?: AuthorizationHelper | undefined, rateLimitHelper?: RateLimitHelper | undefined);
+    /**
+     * Check if versioning feature is enabled.
+     * @throws Error if versioning is not enabled
+     */
+    private ensureVersioningEnabled;
+    /**
+     * Perform authorization check for version operations.
+     * @param ctx - The Convex context (passed to authorization hooks for database access)
+     * @param operation - The CMS operation being performed
+     * @param userId - The user performing the operation
+     * @param resourceId - Optional resource ID (entry ID for version operations)
+     * @throws AuthorizationNotConfiguredError if authorization is not configured and permissiveMode is false
+     */
+    private authorize;
+    /**
+     * Enforce rate limit for version operations.
+     * @param ctx - The Convex context (for database access)
+     * @param operation - The CMS operation being performed
+     * @param userId - The user performing the operation
+     */
+    private rateLimit;
+    /**
+     * Get version history with standard Convex pagination.
+     *
+     * Returns versions in reverse chronological order (newest first).
+     * Compatible with `usePaginatedQuery` React hook.
+     *
+     * @param ctx - Convex query context
+     * @param args - History query arguments with pagination
+     * @returns Paginated version history or null if entry not found
+     *
+     * @example
+     * ```typescript
+     * // Get first page of version history
+     * const { page, continueCursor, isDone } = await cms.versions.getHistory(ctx, {
+     *   entryId: entry._id,
+     *   paginationOpts: { numItems: 10 },
+     * });
+     *
+     * // Get next page
+     * if (!isDone && continueCursor) {
+     *   const nextPage = await cms.versions.getHistory(ctx, {
+     *     entryId: entry._id,
+     *     paginationOpts: { numItems: 10, cursor: continueCursor },
+     *   });
+     * }
+     * ```
+     */
+    getHistory(ctx: ConvexContext, args: GetVersionHistoryArgs): Promise<PaginationResult<ContentVersion> | null>;
+    /**
+     * Get a specific version by ID or version number.
+     *
+     * @param ctx - Convex query context
+     * @param args - Get arguments (entryId required, plus versionId or versionNumber)
+     * @returns The version or null if not found
+     *
+     * @example
+     * ```typescript
+     * // Get by version number
+     * const version = await cms.versions.get(ctx, {
+     *   entryId: entry._id,
+     *   versionNumber: 3,
+     * });
+     *
+     * // Get by version ID
+     * const version = await cms.versions.get(ctx, {
+     *   entryId: entry._id,
+     *   versionId: "abc123",
+     * });
+     * ```
+     */
+    get(ctx: ConvexContext, args: GetVersionArgs): Promise<ContentVersion | null>;
+    /**
+     * Get a version by its version number (convenience method).
+     *
+     * @param ctx - Convex query context
+     * @param entryId - The content entry ID
+     * @param versionNumber - The version number to retrieve
+     * @returns The version or null if not found
+     *
+     * @example
+     * ```typescript
+     * const version3 = await cms.versions.getByNumber(ctx, entry._id, 3);
+     * ```
+     */
+    getByNumber(ctx: ConvexContext, entryId: string, versionNumber: number): Promise<ContentVersion | null>;
+    /**
+     * Get a version by its document ID (convenience method).
+     *
+     * @param ctx - Convex query context
+     * @param entryId - The content entry ID
+     * @param versionId - The version document ID
+     * @returns The version or null if not found
+     *
+     * @example
+     * ```typescript
+     * const version = await cms.versions.getById(ctx, entry._id, versionDocId);
+     * ```
+     */
+    getById(ctx: ConvexContext, entryId: string, versionId: string): Promise<ContentVersion | null>;
+    /**
+     * Get the latest (most recent) version snapshot for an entry.
+     *
+     * @param ctx - Convex query context
+     * @param entryId - The content entry ID
+     * @returns The latest version or null if no versions exist
+     *
+     * @example
+     * ```typescript
+     * const latest = await cms.versions.getLatest(ctx, entry._id);
+     * console.log(`Current version: ${latest?.versionNumber}`);
+     * ```
+     */
+    getLatest(ctx: ConvexContext, entryId: string): Promise<ContentVersion | null>;
+    /**
+     * Get the latest published version for an entry.
+     *
+     * Searches through version history to find the most recent version
+     * that was published (wasPublished = true).
+     *
+     * @param ctx - Convex query context
+     * @param entryId - The content entry ID
+     * @returns The latest published version or null if none published
+     *
+     * @example
+     * ```typescript
+     * const published = await cms.versions.getLatestPublished(ctx, entry._id);
+     * if (published) {
+     *   console.log(`Published at: ${new Date(published.publishedAt!)}`);
+     * }
+     * ```
+     */
+    getLatestPublished(ctx: ConvexContext, entryId: string): Promise<ContentVersion | null>;
+    /**
+     * Get all published versions for an entry.
+     *
+     * @param ctx - Convex query context
+     * @param entryId - The content entry ID
+     * @param limit - Maximum number of published versions to return (default: 10)
+     * @returns Array of published versions (newest first)
+     *
+     * @example
+     * ```typescript
+     * const publishedVersions = await cms.versions.getPublishedHistory(ctx, entry._id, 5);
+     * console.log(`Found ${publishedVersions.length} published versions`);
+     * ```
+     */
+    getPublishedHistory(ctx: ConvexContext, entryId: string, limit?: number): Promise<ContentVersion[]>;
+    /**
+     * Compare two versions and generate a detailed diff.
+     *
+     * Analyzes field-level changes between two versions, identifying:
+     * - Added fields (present in toVersion but not fromVersion)
+     * - Removed fields (present in fromVersion but not toVersion)
+     * - Modified fields (present in both but with different values)
+     *
+     * @param ctx - Convex query context
+     * @param args - Comparison arguments
+     * @returns Detailed version comparison or null if versions not found
+     *
+     * @example
+     * ```typescript
+     * const diff = await cms.versions.compare(ctx, {
+     *   entryId: entry._id,
+     *   fromVersionNumber: 1,
+     *   toVersionNumber: 5,
+     * });
+     *
+     * if (diff) {
+     *   console.log(`${diff.summary.totalChanges} changes detected`);
+     *   for (const change of diff.changes) {
+     *     console.log(`${change.field}: ${change.changeType}`);
+     *   }
+     * }
+     * ```
+     */
+    compare(ctx: ConvexContext, args: CompareVersionsArgs): Promise<VersionComparison | null>;
+    /**
+     * Compare the current entry state with a specific version.
+     *
+     * Useful for seeing what has changed since a particular point in time.
+     *
+     * @param ctx - Convex query context
+     * @param entryId - The content entry ID
+     * @param versionNumber - The version number to compare against
+     * @returns Comparison between the version and current state, or null
+     *
+     * @example
+     * ```typescript
+     * // See what changed since version 3
+     * const diff = await cms.versions.compareWithCurrent(ctx, entry._id, 3);
+     * ```
+     */
+    compareWithCurrent(ctx: ConvexContext, entryId: string, versionNumber: number): Promise<VersionComparison | null>;
+    /**
+     * Check if a specific version exists.
+     *
+     * @param ctx - Convex query context
+     * @param entryId - The content entry ID
+     * @param versionNumber - The version number to check
+     * @returns true if the version exists
+     *
+     * @example
+     * ```typescript
+     * if (await cms.versions.exists(ctx, entry._id, 5)) {
+     *   // Version 5 exists
+     * }
+     * ```
+     */
+    exists(ctx: ConvexContext, entryId: string, versionNumber: number): Promise<boolean>;
+    /**
+     * Count total number of versions for an entry.
+     *
+     * @param ctx - Convex query context
+     * @param entryId - The content entry ID
+     * @returns Total number of version snapshots
+     *
+     * @example
+     * ```typescript
+     * const count = await cms.versions.count(ctx, entry._id);
+     * console.log(`Entry has ${count} versions`);
+     * ```
+     */
+    count(ctx: ConvexContext, entryId: string): Promise<number>;
+    /**
+     * Rollback a content entry to a previous version.
+     *
+     * This is a non-destructive operation that:
+     * 1. Creates a snapshot of the current state (for undo capability)
+     * 2. Restores data and slug from the target version
+     * 3. Increments the version number
+     * 4. Creates a new snapshot documenting the rollback
+     *
+     * The entry's status, scheduled publish time, and publishing timestamps
+     * are preserved (not restored from the target version).
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Rollback arguments
+     * @returns The updated entry with rolled back content
+     *
+     * @example
+     * ```typescript
+     * // Rollback to version 3
+     * const entry = await cms.versions.rollback(ctx, {
+     *   entryId: entry._id,
+     *   versionNumber: 3,
+     *   updatedBy: currentUserId,
+     * });
+     *
+     * // The entry is now at a new version number (e.g., 7)
+     * // but with content from version 3
+     * console.log(`Rolled back, now at version ${entry.version}`);
+     * ```
+     */
+    rollback(ctx: ConvexContext, args: RollbackVersionArgs): Promise<ContentEntry>;
+    /**
+     * Generate a detailed comparison between two versions.
+     */
+    private generateComparison;
+    /**
+     * Deep equality check for comparing field values.
+     */
+    private deepEqual;
+}
+/**
+ * Wrapper for media asset operations.
+ */
+export declare class MediaAssetsApi {
+    private readonly api;
+    private readonly config;
+    private readonly authHelper?;
+    private readonly rateLimitHelper?;
+    constructor(api: TypedComponentApi, config: ResolvedComponentConfig, authHelper?: AuthorizationHelper | undefined, rateLimitHelper?: RateLimitHelper | undefined);
+    /**
+     * Perform authorization check for media asset operations.
+     * @param ctx - The Convex context (passed to authorization hooks for database access)
+     * @param operation - The CMS operation being performed
+     * @param userId - The user performing the operation
+     * @param resourceId - Optional resource ID (for update/delete operations)
+     * @param resourceOwnerId - Optional owner ID for ownership-based permissions
+     * @throws AuthorizationNotConfiguredError if authorization is not configured and permissiveMode is false
+     */
+    private authorize;
+    /**
+     * Enforce rate limit for media asset operations.
+     * @param ctx - The Convex context (for database access)
+     * @param operation - The CMS operation being performed
+     * @param userId - The user performing the operation
+     */
+    private rateLimit;
+    /**
+     * Create a new media asset record.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Asset creation arguments
+     * @returns The created asset
+     *
+     * @example
+     * ```typescript
+     * // After uploading to Convex storage
+     * const asset = await cms.mediaAssets.create(ctx, {
+     *   storageId: storageId,
+     *   filename: "photo.jpg",
+     *   mimeType: "image/jpeg",
+     *   size: 102400,
+     *   type: "image",
+     *   width: 1920,
+     *   height: 1080,
+     * });
+     * ```
+     */
+    create(ctx: ConvexContext, args: CreateMediaAssetArgs): Promise<MediaAsset>;
+    /**
+     * Update media asset metadata.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Asset update arguments
+     * @returns The updated asset
+     */
+    update(ctx: ConvexContext, args: UpdateMediaAssetArgs): Promise<MediaAsset>;
+    /**
+     * Soft delete a media asset.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Delete arguments
+     * @returns The deleted asset
+     */
+    delete(ctx: ConvexContext, args: DeleteMediaAssetArgs): Promise<MediaAsset>;
+    /**
+     * Get a media asset by ID.
+     *
+     * @param ctx - Convex query context
+     * @param args - Get arguments
+     * @returns The asset or null if not found
+     */
+    get(ctx: ConvexContext, args: GetMediaAssetArgs): Promise<MediaAsset | null>;
+    /**
+     * List media assets with optional filters.
+     *
+     * @param ctx - Convex query context
+     * @param args - Query options
+     * @returns Paginated list of assets
+     */
+    list(ctx: ConvexContext, args?: ListMediaAssetsArgs): Promise<PaginationResult<MediaAsset>>;
+    /**
+     * Generate a temporary upload URL for client-side file uploads.
+     *
+     * The upload flow works as follows:
+     * 1. Call this method to get a temporary upload URL
+     * 2. POST the file to the URL with Content-Type header set to the file's MIME type
+     * 3. The response contains a `storageId` that references the uploaded file
+     * 4. Call create() to save metadata and link the storageId
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Upload configuration options
+     * @returns Upload URL and constraints
+     *
+     * @example
+     * ```typescript
+     * // Generate URL for image uploads
+     * const { uploadUrl, expiresAt, maxFileSize } = await cms.mediaAssets.generateUploadUrl(ctx, {
+     *   maxFileSize: 10 * 1024 * 1024, // 10 MB
+     *   allowedMimeTypes: ["image/jpeg", "image/png", "image/webp"],
+     * });
+     *
+     * // Client-side upload:
+     * const response = await fetch(uploadUrl, {
+     *   method: "POST",
+     *   headers: { "Content-Type": file.type },
+     *   body: file,
+     * });
+     * const { storageId } = await response.json();
+     *
+     * // Then save metadata
+     * const asset = await cms.mediaAssets.create(ctx, {
+     *   storageId,
+     *   filename: file.name,
+     *   mimeType: file.type,
+     *   size: file.size,
+     *   type: "image",
+     * });
+     * ```
+     */
+    generateUploadUrl(ctx: ConvexContext, args?: GenerateUploadUrlArgs): Promise<GenerateUploadUrlResult>;
+    /**
+     * Restore a soft-deleted media asset.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Restore arguments
+     * @returns The restored asset
+     *
+     * @example
+     * ```typescript
+     * // Restore a previously deleted asset
+     * const restoredAsset = await cms.mediaAssets.restore(ctx, {
+     *   id: assetId,
+     * });
+     * ```
+     */
+    restore(ctx: ConvexContext, args: RestoreMediaAssetArgs): Promise<MediaAsset>;
+    /**
+     * Find content entries that reference a media asset.
+     *
+     * Useful for checking references before deletion or for understanding asset usage.
+     *
+     * @param ctx - Convex query context
+     * @param args - Query arguments
+     * @returns Array of references with entry and field information
+     *
+     * @example
+     * ```typescript
+     * // Check if asset is used before deleting
+     * const references = await cms.mediaAssets.findReferences(ctx, {
+     *   id: assetId,
+     * });
+     *
+     * if (references.length > 0) {
+     *   console.log(`Asset is used in ${references.length} entries`);
+     *   // Maybe show a warning to the user
+     * }
+     * ```
+     */
+    findReferences(ctx: ConvexContext, args: FindMediaAssetReferencesArgs): Promise<MediaAssetReference[]>;
+    /**
+     * Get taxonomy terms associated with a media asset.
+     *
+     * @param ctx - Convex query context
+     * @param args - Query arguments
+     * @returns Array of terms associated with the media asset
+     *
+     * @example
+     * ```typescript
+     * const tags = await cms.mediaAssets.getTerms(ctx, {
+     *   mediaId: imageId,
+     * });
+     * ```
+     */
+    getTerms(ctx: ConvexContext, args: {
+        mediaId: string;
+        taxonomyId?: string;
+    }): Promise<unknown[]>;
+    /**
+     * Set terms for a media asset in a taxonomy (replaces existing terms).
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Mutation arguments
+     *
+     * @example
+     * ```typescript
+     * await cms.mediaAssets.setTerms(ctx, {
+     *   mediaId: imageId,
+     *   taxonomyId: categoriesTaxonomyId,
+     *   termIds: [landscapeId, natureId],
+     *   userId: currentUserId,
+     * });
+     * ```
+     */
+    setTerms(ctx: ConvexContext, args: {
+        mediaId: string;
+        taxonomyId: string;
+        termIds: string[];
+        userId?: string;
+    }): Promise<void>;
+    /**
+     * Add a single term to a media asset.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Mutation arguments
+     *
+     * @example
+     * ```typescript
+     * await cms.mediaAssets.addTerm(ctx, {
+     *   mediaId: imageId,
+     *   termId: landscapeId,
+     *   userId: currentUserId,
+     * });
+     * ```
+     */
+    addTerm(ctx: ConvexContext, args: {
+        mediaId: string;
+        termId: string;
+        userId?: string;
+    }): Promise<void>;
+    /**
+     * Remove a term from a media asset.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Mutation arguments
+     *
+     * @example
+     * ```typescript
+     * await cms.mediaAssets.removeTerm(ctx, {
+     *   mediaId: imageId,
+     *   termId: landscapeId,
+     *   userId: currentUserId,
+     * });
+     * ```
+     */
+    removeTerm(ctx: ConvexContext, args: {
+        mediaId: string;
+        termId: string;
+        userId?: string;
+    }): Promise<void>;
+    /**
+     * Create a term inline and add it to a media asset.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Mutation arguments
+     * @returns The created or existing term ID
+     *
+     * @example
+     * ```typescript
+     * const termId = await cms.mediaAssets.createAndAddTerm(ctx, {
+     *   taxonomyId: tagsTaxonomyId,
+     *   name: "Nature",
+     *   mediaId: imageId,
+     *   userId: currentUserId,
+     * });
+     * ```
+     */
+    createAndAddTerm(ctx: ConvexContext, args: {
+        taxonomyId: string;
+        name: string;
+        mediaId: string;
+        userId?: string;
+    }): Promise<string>;
+}
+/**
+ * Wrapper for media folder operations.
+ */
+export declare class MediaFoldersApi {
+    private readonly api;
+    private readonly config;
+    private readonly authHelper?;
+    private readonly rateLimitHelper?;
+    constructor(api: TypedComponentApi, config: ResolvedComponentConfig, authHelper?: AuthorizationHelper | undefined, rateLimitHelper?: RateLimitHelper | undefined);
+    /**
+     * Perform authorization check for media folder operations.
+     * @param ctx - The Convex context (passed to authorization hooks for database access)
+     * @param operation - The CMS operation being performed
+     * @param userId - The user performing the operation
+     * @param resourceId - Optional resource ID (for update/delete operations)
+     * @param resourceOwnerId - Optional owner ID for ownership-based permissions
+     */
+    private authorize;
+    /**
+     * Enforce rate limit for media folder operations.
+     * @param ctx - The Convex context (for database access)
+     * @param operation - The CMS operation being performed
+     * @param userId - The user performing the operation
+     */
+    private rateLimit;
+    /**
+     * Create a new media folder.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Folder creation arguments
+     * @returns The created folder
+     */
+    create(ctx: ConvexContext, args: CreateMediaFolderArgs): Promise<MediaFolder>;
+    /**
+     * Update a media folder.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Folder update arguments
+     * @returns The updated folder
+     */
+    update(ctx: ConvexContext, args: UpdateMediaFolderArgs): Promise<MediaFolder>;
+    /**
+     * Soft delete a media folder.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Delete arguments
+     * @returns The deleted folder
+     */
+    delete(ctx: ConvexContext, args: DeleteMediaFolderArgs): Promise<MediaFolder>;
+    /**
+     * Get a media folder by ID.
+     *
+     * @param ctx - Convex query context
+     * @param args - Get arguments
+     * @returns The folder or null if not found
+     */
+    get(ctx: ConvexContext, args: GetMediaFolderArgs): Promise<MediaFolder | null>;
+    /**
+     * List media folders.
+     *
+     * @param ctx - Convex query context
+     * @param args - Optional filter arguments
+     * @returns Array of folders
+     */
+    list(ctx: ConvexContext, args?: ListMediaFoldersArgs): Promise<MediaFolder[]>;
+    /**
+     * Move a folder to a new parent.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Move arguments
+     * @returns The moved folder with updated path
+     */
+    move(ctx: ConvexContext, args: MoveFolderArgs): Promise<MediaFolder>;
+    /**
+     * Restore a soft-deleted media folder.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Restore arguments
+     * @returns The restored folder
+     *
+     * @example
+     * ```typescript
+     * // Restore a folder and all its contents
+     * const restoredFolder = await cms.mediaFolders.restore(ctx, {
+     *   id: folderId,
+     *   recursive: true,
+     * });
+     * ```
+     */
+    restore(ctx: ConvexContext, args: RestoreMediaFolderArgs): Promise<MediaFolder>;
+    /**
+     * Get a folder by its path.
+     *
+     * @param ctx - Convex query context
+     * @param args - Query arguments with path
+     * @returns The folder or null if not found
+     *
+     * @example
+     * ```typescript
+     * // Find folder by path
+     * const folder = await cms.mediaFolders.getByPath(ctx, {
+     *   path: "/Images/Blog/2026",
+     * });
+     * ```
+     */
+    getByPath(ctx: ConvexContext, args: GetMediaFolderByPathArgs): Promise<MediaFolder | null>;
+    /**
+     * Get the entire folder tree as a flat list sorted by path.
+     *
+     * Useful for building folder navigation or selectors.
+     *
+     * @param ctx - Convex query context
+     * @param args - Optional filter arguments
+     * @returns Array of all folders sorted hierarchically by path
+     *
+     * @example
+     * ```typescript
+     * // Get all folders for a tree view
+     * const folders = await cms.mediaFolders.getTree(ctx, {});
+     *
+     * // Build a nested structure
+     * const rootFolders = folders.filter(f => !f.parentId);
+     * ```
+     */
+    getTree(ctx: ConvexContext, args?: GetFolderTreeArgs): Promise<MediaFolder[]>;
+}
+/**
+ * Wrapper for media variant operations.
+ *
+ * Media variants are optimized versions of media assets (thumbnails, responsive
+ * sizes, format conversions). This API provides methods for creating, listing,
+ * and managing variants.
+ *
+ * @example
+ * ```typescript
+ * // Get all variants for an asset
+ * const variants = await cms.mediaVariants.list(ctx, {
+ *   assetId: assetId,
+ *   status: "completed",
+ * });
+ *
+ * // Get responsive srcset for an image
+ * const srcset = await cms.mediaVariants.getResponsiveSrcset(ctx, {
+ *   assetId: assetId,
+ *   format: "webp",
+ * });
+ * // Use: <img src={srcset.src} srcset={srcset.srcset} sizes="100vw" />
+ * ```
+ */
+export declare class MediaVariantsApi {
+    private readonly api;
+    private readonly config;
+    constructor(api: TypedComponentApi, config: ResolvedComponentConfig);
+    /**
+     * Create a media variant after external processing.
+     *
+     * Use this when variant processing happens externally (e.g., in a serverless
+     * function or image processing service) and you need to register the
+     * completed variant.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Variant creation arguments
+     * @returns The created variant with URL
+     *
+     * @example
+     * ```typescript
+     * // After processing image externally and uploading result
+     * const variant = await cms.mediaVariants.create(ctx, {
+     *   assetId: assetId,
+     *   storageId: processedStorageId,
+     *   variantType: "responsive",
+     *   width: 480,
+     *   height: 320,
+     *   format: "webp",
+     *   mimeType: "image/webp",
+     *   size: 25600,
+     *   quality: 80,
+     *   preset: "small",
+     * });
+     * ```
+     */
+    create(ctx: ConvexContext, args: CreateMediaVariantArgs): Promise<MediaVariantWithUrl>;
+    /**
+     * Request async generation of a variant.
+     *
+     * Creates a variant record with "pending" status. An external processing
+     * system should pick up pending variants, process them, and update the status.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Generation request arguments
+     * @returns The pending variant
+     */
+    requestGeneration(ctx: ConvexContext, args: RequestVariantGenerationArgs): Promise<MediaVariant>;
+    /**
+     * Get a variant by ID.
+     *
+     * @param ctx - Convex query context
+     * @param args - Query arguments
+     * @returns The variant with URL or null
+     */
+    get(ctx: ConvexContext, args: {
+        id: string;
+        includeDeleted?: boolean;
+    }): Promise<MediaVariantWithUrl | null>;
+    /**
+     * List variants for an asset.
+     *
+     * @param ctx - Convex query context
+     * @param args - Query arguments with filters
+     * @returns Array of variants with URLs
+     *
+     * @example
+     * ```typescript
+     * // Get all completed responsive variants
+     * const variants = await cms.mediaVariants.list(ctx, {
+     *   assetId: assetId,
+     *   variantType: "responsive",
+     *   status: "completed",
+     * });
+     * ```
+     */
+    list(ctx: ConvexContext, args: ListMediaVariantsArgs): Promise<MediaVariantWithUrl[]>;
+    /**
+     * Find the best matching variant for target dimensions.
+     *
+     * @param ctx - Convex query context
+     * @param args - Target size and preferences
+     * @returns Best matching variant or null
+     *
+     * @example
+     * ```typescript
+     * // Get best variant for 400px wide container
+     * const variant = await cms.mediaVariants.getBestVariant(ctx, {
+     *   assetId: assetId,
+     *   targetWidth: 400,
+     *   preferredFormat: "webp",
+     * });
+     * ```
+     */
+    getBestVariant(ctx: ConvexContext, args: GetBestVariantArgs): Promise<(MediaVariantWithUrl & {
+        isOriginal: boolean;
+    }) | null>;
+    /**
+     * Get responsive srcset data for HTML img/picture tags.
+     *
+     * @param ctx - Convex query context
+     * @param args - Asset ID and optional format filter
+     * @returns Srcset data for responsive images
+     *
+     * @example
+     * ```typescript
+     * const srcset = await cms.mediaVariants.getResponsiveSrcset(ctx, {
+     *   assetId: assetId,
+     *   format: "webp",
+     * });
+     *
+     * // In React:
+     * <img src={srcset.src} srcset={srcset.srcset} sizes="100vw" />
+     * ```
+     */
+    getResponsiveSrcset(ctx: ConvexContext, args: {
+        assetId: string;
+        format?: string;
+    }): Promise<ResponsiveSrcsetResult>;
+    /**
+     * Get an asset with all its variants organized by type.
+     *
+     * @param ctx - Convex query context
+     * @param args - Asset ID
+     * @returns Asset with variants or null
+     */
+    getAssetWithVariants(ctx: ConvexContext, args: {
+        assetId: string;
+    }): Promise<AssetWithVariants | null>;
+    /**
+     * Get available variant presets.
+     *
+     * @param ctx - Convex query context
+     * @returns Array of preset configurations
+     */
+    getPresets(ctx: ConvexContext): Promise<VariantPreset[]>;
+    /**
+     * Generate variants from preset configurations.
+     *
+     * Queues multiple variants for async processing.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Asset ID and preset names
+     * @returns Summary of created variant requests
+     *
+     * @example
+     * ```typescript
+     * // Generate standard responsive set
+     * const result = await cms.mediaVariants.generateFromPresets(ctx, {
+     *   assetId: assetId,
+     *   presets: ["thumbnail", "small", "medium", "large"],
+     * });
+     * console.log(`Queued ${result.succeeded} variants`);
+     * ```
+     */
+    generateFromPresets(ctx: ConvexContext, args: GenerateFromPresetsArgs): Promise<GenerateVariantsResult>;
+    /**
+     * Delete a variant.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Delete arguments
+     * @returns The deleted variant
+     */
+    delete(ctx: ConvexContext, args: DeleteMediaVariantArgs): Promise<MediaVariant>;
+    /**
+     * Delete all variants for an asset.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Asset ID and delete options
+     * @returns Summary of deleted variants
+     */
+    deleteAllForAsset(ctx: ConvexContext, args: DeleteAssetVariantsArgs): Promise<{
+        deleted: number;
+        assetId: string;
+    }>;
+    /**
+     * Restore a soft-deleted variant.
+     *
+     * @param ctx - Convex mutation context
+     * @param args - Variant ID to restore
+     * @returns The restored variant
+     */
+    restore(ctx: ConvexContext, args: {
+        id: string;
+        restoredBy?: string;
+    }): Promise<MediaVariant>;
+}
+/**
+ * Enhanced CMS client with typed method wrappers for all component operations.
+ *
+ * This client provides an ergonomic, type-safe API for interacting with the
+ * Convex CMS component. All methods accept a Convex context and return
+ * properly typed results.
+ *
+ * @example
+ * ```typescript
+ * import { createCmsClient } from "@convex-cms/core";
+ * import { components } from "./_generated/api";
+ *
+ * export const cms = createCmsClient(components.convexCms, {
+ *   defaultLocale: "en-US",
+ *   features: {
+ *     versioning: true,
+ *     localization: true,
+ *   },
+ * });
+ *
+ * // In a mutation:
+ * export const createBlogPost = mutation({
+ *   args: { title: v.string(), content: v.string() },
+ *   handler: async (ctx, args) => {
+ *     return await cms.contentEntries.create(ctx, {
+ *       contentTypeId: "blog_post_type_id",
+ *       data: { title: args.title, content: args.content },
+ *     });
+ *   },
+ * });
+ * ```
+ */
+/**
+ * Options for permission checks.
+ */
+export interface PermissionCheckOptions {
+    /**
+     * Custom role definitions to check in addition to built-in roles.
+     * Use this when you have defined custom roles beyond the defaults.
+     */
+    customRoles?: Record<string, RoleDefinition>;
+}
+/**
+ * Result from checking user permissions.
+ */
+export interface UserPermissionResult {
+    /**
+     * Whether the user has the requested permission.
+     */
+    allowed: boolean;
+    /**
+     * The role that was resolved for the user.
+     * Null if the getUserRole hook returned null.
+     */
+    role: string | null;
+    /**
+     * The permission that was checked.
+     */
+    permission: {
+        resource: Resource;
+        action: Action;
+        scope?: OwnershipScope;
+    };
+}
+export interface CmsClient {
+    /**
+     * The resolved configuration for this client instance.
+     */
+    readonly config: ResolvedComponentConfig;
+    /**
+     * The underlying component API reference.
+     */
+    readonly api: TypedComponentApi;
+    /**
+     * Content type management operations.
+     */
+    readonly contentTypes: ContentTypesApi;
+    /**
+     * Content entry CRUD and workflow operations.
+     */
+    readonly contentEntries: ContentEntriesApi;
+    /**
+     * Content version history operations.
+     */
+    readonly versions: VersionsApi;
+    /**
+     * Media asset management operations.
+     */
+    readonly mediaAssets: MediaAssetsApi;
+    /**
+     * Media folder organization operations.
+     */
+    readonly mediaFolders: MediaFoldersApi;
+    /**
+     * Media variant operations (thumbnails, responsive sizes, format conversions).
+     */
+    readonly mediaVariants: MediaVariantsApi;
+    /**
+     * Check if a specific feature is enabled.
+     * @param feature - The feature flag to check
+     * @returns true if the feature is enabled
+     */
+    isFeatureEnabled(feature: keyof FeatureFlags): boolean;
+    /**
+     * Check if a locale is supported by this configuration.
+     * @param locale - The locale code to check
+     * @returns true if the locale is in the supported locales list
+     */
+    isLocaleSupported(locale: LocaleCode): boolean;
+    /**
+     * Get the CMS role for a user.
+     *
+     * Uses the getUserRole hook configured in ComponentConfig to map
+     * user IDs from your auth system to CMS roles.
+     *
+     * @param ctx - Convex context (passed to getUserRole hook for database access)
+     * @param userId - The user ID to look up
+     * @returns The role name or null if the user has no CMS role
+     * @throws Error if no getUserRole hook is configured
+     *
+     * @example
+     * ```typescript
+     * const role = await cms.getUserRole(ctx, "user_123");
+     * if (role === "admin") {
+     *   // Allow admin-only operations
+     * }
+     * ```
+     */
+    getUserRole(ctx: ConvexContext, userId: string): Promise<GetUserRoleResult>;
+    /**
+     * Check if a user has a specific permission.
+     *
+     * This is a convenience method that combines getUserRole + hasPermission
+     * into a single call. It first resolves the user's role using the
+     * configured getUserRole hook, then checks if that role has the
+     * requested permission.
+     *
+     * @param ctx - Convex context (passed to getUserRole hook for database access)
+     * @param userId - The user ID to check
+     * @param permission - The permission to check (resource + action + optional scope)
+     * @param options - Optional configuration like custom roles
+     * @returns UserPermissionResult with allowed status and resolved role
+     * @throws Error if no getUserRole hook is configured
+     *
+     * @example
+     * ```typescript
+     * // Check if user can create content entries
+     * const result = await cms.hasPermissionForUser(ctx, "user_123", {
+     *   resource: "contentEntries",
+     *   action: "create",
+     * });
+     *
+     * if (!result.allowed) {
+     *   throw new Error(`User with role ${result.role} cannot create content entries`);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Check with ownership scope
+     * const canUpdateOwn = await cms.hasPermissionForUser(ctx, "user_123", {
+     *   resource: "contentEntries",
+     *   action: "update",
+     *   scope: "own",
+     * });
+     * ```
+     */
+    hasPermissionForUser(ctx: ConvexContext, userId: string, permission: {
+        resource: Resource;
+        action: Action;
+        scope?: OwnershipScope;
+    }, options?: PermissionCheckOptions): Promise<UserPermissionResult>;
+    /**
+     * Check if the getUserRole hook is configured.
+     *
+     * Use this to conditionally enable RBAC features in your application.
+     *
+     * @returns true if a getUserRole hook is configured
+     *
+     * @example
+     * ```typescript
+     * if (cms.hasUserRoleHook()) {
+     *   const allowed = await cms.hasPermissionForUser(userId, permission);
+     *   if (!allowed.allowed) throw new Error("Unauthorized");
+     * }
+     * ```
+     */
+    hasUserRoleHook(): boolean;
+    /**
+     * Check if authorization hooks are configured.
+     *
+     * @returns true if any authorization hooks are configured
+     */
+    hasAuthorizationHooks(): boolean;
+    /**
+     * Execute authorization for a CMS operation.
+     *
+     * This method runs the full authorization chain including:
+     * 1. beforeRbac hook (if configured)
+     * 2. Built-in RBAC checks (unless skipRbac is true)
+     * 3. afterRbac hook (if configured)
+     * 4. Operation-specific hooks (if configured)
+     * 5. onDeny hook for denied operations (if configured)
+     *
+     * Use this method to check authorization before performing operations,
+     * especially when you need custom authorization logic beyond RBAC.
+     *
+     * @param context - The authorization context (operation, user, resource info)
+     * @returns AuthorizationResult with allowed status and any modified data
+     *
+     * @example
+     * ```typescript
+     * // Check authorization before publishing
+     * const authResult = await cms.authorize({
+     *   operation: "contentEntries.publish",
+     *   userId: currentUser,
+     *   role: await cms.getUserRole(currentUser),
+     *   resourceId: entryId,
+     *   resourceOwnerId: entry.createdBy,
+     *   contentTypeId: entry.contentTypeId,
+     *   operationData: { id: entryId },
+     * });
+     *
+     * if (!authResult.allowed) {
+     *   throw new Error(authResult.reason ?? "Not authorized to publish");
+     * }
+     *
+     * // Proceed with operation
+     * await cms.contentEntries.publish(ctx, { id: entryId });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // With modified data from hooks
+     * const authResult = await cms.authorize({
+     *   operation: "contentEntries.create",
+     *   userId: currentUser,
+     *   role: userRole,
+     *   operationData: entryData,
+     * });
+     *
+     * if (authResult.allowed && authResult.modifiedData) {
+     *   // Use the modified data from hooks
+     *   await cms.contentEntries.create(ctx, authResult.modifiedData);
+     * }
+     * ```
+     */
+    authorize(context: AuthorizationHookContext): Promise<AuthorizationResult>;
+    /**
+     * Execute authorization and throw if denied.
+     *
+     * Convenience method that calls `authorize()` and throws an UnauthorizedError
+     * if the operation is not allowed.
+     *
+     * @param context - The authorization context
+     * @throws UnauthorizedError if the operation is denied
+     * @returns The authorization result (if allowed)
+     *
+     * @example
+     * ```typescript
+     * // Will throw if not authorized
+     * await cms.requireAuthorization({
+     *   operation: "contentEntries.delete",
+     *   userId: currentUser,
+     *   role: userRole,
+     *   resourceId: entryId,
+     *   resourceOwnerId: entry.createdBy,
+     * });
+     *
+     * // Only reached if authorized
+     * await cms.contentEntries.delete(ctx, { id: entryId });
+     * ```
+     */
+    requireAuthorization(context: AuthorizationHookContext): Promise<AuthorizationResult>;
+    /**
+     * Consolidated locale API with simplified methods.
+     *
+     * @example
+     * ```typescript
+     * // Get locale configuration
+     * const config = cms.locale.getConfig();
+     *
+     * // Get fallback chain for a locale
+     * const chain = cms.locale.getFallbackChain("es-MX");
+     *
+     * // Resolve locale with full metadata
+     * const resolved = cms.locale.resolve("es-MX");
+     * ```
+     */
+    readonly locale: {
+        /**
+         * Get the full locale configuration.
+         */
+        getConfig(): LocaleFallbackConfig;
+        /**
+         * Get the fallback chain for a locale.
+         */
+        getFallbackChain(locale: LocaleCode): LocaleCode[];
+        /**
+         * Resolve a locale with full metadata.
+         */
+        resolve(locale: LocaleCode): ResolvedFallbackChain;
+    };
+    /**
+     * Get all configured custom roles.
+     *
+     * Returns a record of custom role definitions that were configured when
+     * creating the CMS client. Does not include built-in roles.
+     *
+     * @returns Record of custom role name to definition
+     *
+     * @example
+     * ```typescript
+     * const customRoles = cms.getCustomRoles();
+     * for (const [name, role] of Object.entries(customRoles)) {
+     *   console.log(`${name}: ${role.displayName}`);
+     * }
+     * ```
+     */
+    getCustomRoles(): Record<string, import("./types.js").CustomRoleDefinition>;
+    /**
+     * Get a specific custom role by name.
+     *
+     * @param roleName - The name of the custom role to get
+     * @returns The custom role definition, or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const blogAuthor = cms.getCustomRole("blog-author");
+     * if (blogAuthor) {
+     *   console.log(blogAuthor.displayName); // "Blog Author"
+     * }
+     * ```
+     */
+    getCustomRole(roleName: string): import("./types.js").CustomRoleDefinition | undefined;
+    /**
+     * Check if a custom role exists.
+     *
+     * @param roleName - The name of the role to check
+     * @returns True if the role is a custom role (not built-in)
+     *
+     * @example
+     * ```typescript
+     * cms.isCustomRole("blog-author"); // true (if configured)
+     * cms.isCustomRole("admin"); // false (built-in)
+     * cms.isCustomRole("unknown"); // false
+     * ```
+     */
+    isCustomRole(roleName: string): boolean;
+    /**
+     * Check if a user can perform an action on a specific content type.
+     *
+     * This is similar to `hasPermissionForUser` but additionally checks
+     * content-type-specific permission restrictions that may be configured
+     * on custom roles.
+     *
+     * @param userId - The user ID to check
+     * @param permission - The permission to check
+     * @param contentTypeName - The content type to check permissions for
+     * @returns UserPermissionResult with allowed status
+     *
+     * @example
+     * ```typescript
+     * // Check if user can create blog posts (may be restricted by custom role)
+     * const result = await cms.hasContentTypePermissionForUser(
+     *   ctx,
+     *   "user_123",
+     *   { resource: "contentEntries", action: "create" },
+     *   "blog_post"
+     * );
+     *
+     * if (result.allowed) {
+     *   // User can create blog posts
+     * }
+     * ```
+     */
+    hasContentTypePermissionForUser(ctx: ConvexContext, userId: string, permission: {
+        resource: Resource;
+        action: Action;
+        scope?: OwnershipScope;
+    }, contentTypeName: string): Promise<UserPermissionResult>;
+    /**
+     * Get all content types a user can perform an action on.
+     *
+     * Returns an array of content type names that the user has permission to
+     * perform the specified action on, based on their role's permissions.
+     *
+     * @param userId - The user ID to check
+     * @param action - The action to check (e.g., "create", "update", "publish")
+     * @returns Array of content type names, ["*"] if unrestricted, or [] if no permission
+     *
+     * @example
+     * ```typescript
+     * // Get content types the user can create
+     * const types = await cms.getPermittedContentTypesForUser(ctx, "user_123", "create");
+     *
+     * if (types.includes("*")) {
+     *   // User can create any content type
+     * } else if (types.includes("blog_post")) {
+     *   // User can create blog posts
+     * }
+     * ```
+     */
+    getPermittedContentTypesForUser(ctx: ConvexContext, userId: string, action: Action): Promise<string[]>;
+    /**
+     * Get all roles (built-in and custom) merged together.
+     *
+     * Returns a record containing both the default built-in roles and
+     * any custom roles configured on this client. Useful for UI rendering
+     * or iterating over all available roles.
+     *
+     * @returns Record of all role names to definitions
+     *
+     * @example
+     * ```typescript
+     * const allRoles = cms.getAllRoles();
+     * // Includes: admin, editor, author, viewer, blog-author, etc.
+     *
+     * // Render role selector
+     * Object.entries(allRoles).map(([name, role]) => (
+     *   <option key={name} value={name}>{role.displayName}</option>
+     * ));
+     * ```
+     */
+    getAllRoles(): Record<string, RoleDefinition | import("./types.js").CustomRoleDefinition>;
+    /**
+     * Check if a user can perform an action on a specific resource, with ownership verification.
+     *
+     * This is the most comprehensive permission check method. It:
+     * 1. Resolves the user's role via the getUserRole hook
+     * 2. Checks if the role has the required permission
+     * 3. For "own" scope permissions, verifies that the user owns the resource
+     *
+     * Use this when you need to check authorization for a specific resource that may
+     * have ownership-based restrictions (e.g., "can this author update THIS entry?").
+     *
+     * @param userId - The user ID performing the action
+     * @param resource - The resource type (e.g., "contentEntries", "mediaAssets")
+     * @param action - The action being performed (e.g., "update", "delete", "publish")
+     * @param resourceOwnerId - The ID of the user who created/owns the resource
+     * @returns Permission result with ownership verification details
+     *
+     * @example
+     * ```typescript
+     * // Check if an author can update a specific content entry
+     * const entry = await ctx.db.get(entryId);
+     * const result = await cms.canUserPerformOnResource(
+     *   ctx,
+     *   currentUserId,
+     *   "contentEntries",
+     *   "update",
+     *   entry.createdBy // The owner's user ID
+     * );
+     *
+     * if (!result.allowed) {
+     *   if (result.ownershipRequired) {
+     *     throw new Error("You can only update your own entries");
+     *   }
+     *   throw new Error(`Role '${result.role}' cannot update content entries`);
+     * }
+     *
+     * // Proceed with update...
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Check if user can delete a media asset they uploaded
+     * const asset = await ctx.db.get(assetId);
+     * const result = await cms.canUserPerformOnResource(
+     *   ctx,
+     *   userId,
+     *   "mediaAssets",
+     *   "delete",
+     *   asset.createdBy
+     * );
+     *
+     * if (result.allowed && result.grantedScope === "own") {
+     *   console.log("User can delete only because they own this asset");
+     * }
+     * ```
+     */
+    canUserPerformOnResource(ctx: ConvexContext, userId: string, resource: Resource, action: Action, resourceOwnerId?: string): Promise<ResourcePermissionResult>;
+    /**
+     * Require that a user can perform an action on a specific resource.
+     *
+     * This is the throwing version of `canUserPerformOnResource`. If the permission
+     * check fails, it throws an UnauthorizedError with detailed context.
+     *
+     * Use this at the start of mutation handlers to enforce ownership-based access control.
+     *
+     * @param userId - The user ID performing the action
+     * @param resource - The resource type
+     * @param action - The action being performed
+     * @param resourceOwnerId - The ID of the resource owner
+     * @throws UnauthorizedError if permission is denied or ownership verification fails
+     * @returns Permission granted details
+     *
+     * @example
+     * ```typescript
+     * // In a mutation handler - will throw if not authorized
+     * export const deleteEntry = mutation({
+     *   args: { id: v.id("contentEntries"), userId: v.string() },
+     *   handler: async (ctx, args) => {
+     *     const entry = await ctx.db.get(args.id);
+     *     if (!entry) throw new Error("Entry not found");
+     *
+     *     // Throws UnauthorizedError if user can't delete this entry
+     *     await cms.requireUserCanPerformOnResource(
+     *       ctx,
+     *       args.userId,
+     *       "contentEntries",
+     *       "delete",
+     *       entry.createdBy
+     *     );
+     *
+     *     // Safe to proceed - user is authorized
+     *     await ctx.db.delete(args.id);
+     *   },
+     * });
+     * ```
+     */
+    requireUserCanPerformOnResource(ctx: ConvexContext, userId: string, resource: Resource, action: Action, resourceOwnerId?: string): Promise<ResourcePermissionGranted>;
+    /**
+     * Check if a user owns a specific resource.
+     *
+     * Simple helper that compares user ID with resource owner ID.
+     * Does not check permissions - just ownership.
+     *
+     * @param userId - The user ID to check
+     * @param resourceOwnerId - The ID of the resource owner
+     * @returns true if the user owns the resource
+     *
+     * @example
+     * ```typescript
+     * const entry = await ctx.db.get(entryId);
+     * if (cms.isOwner(currentUserId, entry.createdBy)) {
+     *   // User owns this entry
+     * }
+     * ```
+     */
+    isOwner(userId: string | undefined, resourceOwnerId: string | undefined): boolean;
+}
+/**
+ * Result from checking resource permission with ownership verification.
+ */
+export interface ResourcePermissionResult {
+    /**
+     * Whether the user is allowed to perform the action.
+     */
+    allowed: boolean;
+    /**
+     * The user's role (null if no role assigned).
+     */
+    role: string | null;
+    /**
+     * The scope that was granted (if allowed).
+     * "all" means the user can access any resource.
+     * "own" means the user can only access resources they created.
+     */
+    grantedScope?: OwnershipScope;
+    /**
+     * Whether ownership was verified (true if resourceOwnerId was provided and matched userId).
+     */
+    ownershipVerified?: boolean;
+    /**
+     * If denied, indicates whether the denial was due to ownership requirements.
+     * true when the user has "own" scope but doesn't own the resource.
+     */
+    ownershipRequired?: boolean;
+    /**
+     * The reason for denial (if not allowed).
+     */
+    reason?: string;
+    /**
+     * Error code for programmatic handling (if not allowed).
+     */
+    code?: string;
+}
+/**
+ * Result from a successful resource permission check.
+ */
+export interface ResourcePermissionGranted {
+    /**
+     * Always true for granted permissions.
+     */
+    allowed: true;
+    /**
+     * The user's role.
+     */
+    role: string;
+    /**
+     * The scope that was granted.
+     */
+    grantedScope: OwnershipScope;
+    /**
+     * Whether ownership was verified.
+     */
+    ownershipVerified: boolean;
+}
+/**
+ * Creates an enhanced CMS client with typed method wrappers.
+ *
+ * This is the main entry point for using the Convex CMS component.
+ * The returned client provides typed methods for all CMS operations.
+ *
+ * @param componentApi - The component API from `components.convexCms`
+ * @param config - Optional configuration options
+ * @returns An enhanced CMS client instance
+ *
+ * @example
+ * ```typescript
+ * import { createCmsClient } from "@convex-cms/core";
+ * import { components } from "./_generated/api";
+ *
+ * // Create with default configuration
+ * export const cms = createCmsClient(components.convexCms);
+ *
+ * // Create with custom configuration
+ * export const cms = createCmsClient(components.convexCms, {
+ *   defaultLocale: "en-US",
+ *   supportedLocales: ["en-US", "es-ES", "fr-FR"],
+ *   features: {
+ *     versioning: true,
+ *     localization: true,
+ *     scheduling: true,
+ *   },
+ *   maxVersionsPerEntry: 100,
+ * });
+ * ```
+ */
+export declare function createCmsClient(componentApi: TypedComponentApi, config?: ComponentConfig): CmsClient;
+//# sourceMappingURL=wrapper.d.ts.map