@vexcms/core 0.0.20 → 0.1.0-alpha.3

package/dist/index.d.ts

@@ -1,3165 +1,15 @@
-import { ComponentType } from 'react';
-import * as convex_server from 'convex/server';
-import { TableDefinition, GenericDataModel, GenericMutationCtx, GenericQueryCtx, QueryBuilder, RegisteredQuery, TableNamesInDataModel, PaginationOptions } from 'convex/server';
-import { VObject, GenericValidator, ObjectType, PropertyValidators, v } from 'convex/values';
-import { ColumnDef } from '@tanstack/react-table';
-import { ZodTypeAny, z } from 'zod';
-
-/**
- * The style tier identifiers that a block can declare in admin.blockStyles.
- * Each tier corresponds to a section in the style popover and a set of CSS properties.
- */
-type StyleTier = "container" | "text" | "layout" | "media";
-/**
- * Container styles — universal layout/visual properties applied to the block's outer wrapper.
- * All values are Tailwind scale keys (e.g., "4" → 1rem/16px) or color strings.
- */
-interface ContainerStyleConfig {
-    /** Tailwind margin scale value. Shorthand: applies to all sides. */
-    margin?: string;
-    marginTop?: string;
-    marginRight?: string;
-    marginBottom?: string;
-    marginLeft?: string;
-    /** Tailwind padding scale value. */
-    padding?: string;
-    paddingTop?: string;
-    paddingRight?: string;
-    paddingBottom?: string;
-    paddingLeft?: string;
-    /** Tailwind width class key (e.g., "full", "1/2", "screen"). */
-    width?: string;
-    /** Tailwind max-width class key. */
-    maxWidth?: string;
-    /** Background color — CSS color string or CSS variable reference. */
-    backgroundColor?: string;
-    /** Border width — Tailwind border width key (e.g., "", "2", "4"). */
-    borderWidth?: string;
-    /** Border color — CSS color string or CSS variable reference. */
-    borderColor?: string;
-    /** Border style. */
-    borderStyle?: "solid" | "dashed" | "dotted" | "none";
-    /** Tailwind border radius key (e.g., "sm", "md", "lg", "full"). */
-    borderRadius?: string;
-    /** Tailwind box shadow key (e.g., "sm", "md", "lg", "xl", "2xl", "none"). */
-    boxShadow?: string;
-    /** Tailwind opacity value (e.g., "0", "25", "50", "75", "100"). */
-    opacity?: string;
-    /** Display value. */
-    display?: "block" | "flex" | "grid" | "none" | "inline-flex";
-    /** Overflow value. */
-    overflow?: "hidden" | "scroll" | "auto" | "visible";
-}
-/**
- * Text styles — typography properties for text-heavy blocks.
- */
-interface TextStyleConfig {
-    /** Text alignment. */
-    textAlign?: "left" | "center" | "right" | "justify";
-    /** Tailwind font size key (e.g., "sm", "base", "lg", "xl", "2xl"). */
-    fontSize?: string;
-    /** Tailwind font weight key (e.g., "normal", "medium", "semibold", "bold"). */
-    fontWeight?: string;
-    /** Text color — CSS color string or CSS variable reference. */
-    color?: string;
-    /** Tailwind line height key (e.g., "tight", "snug", "normal", "relaxed"). */
-    lineHeight?: string;
-    /** Tailwind letter spacing key (e.g., "tighter", "tight", "normal", "wide"). */
-    letterSpacing?: string;
-}
-/**
- * Layout styles — for blocks that contain child elements in flex/grid layouts.
- */
-interface LayoutStyleConfig {
-    /** Tailwind gap scale value. */
-    gap?: string;
-    /** Flex direction. */
-    flexDirection?: "row" | "column" | "row-reverse" | "column-reverse";
-    /** Align items. */
-    alignItems?: "start" | "center" | "end" | "stretch" | "baseline";
-    /** Justify content. */
-    justifyContent?: "start" | "center" | "end" | "between" | "around" | "evenly";
-    /** Flex wrap. */
-    flexWrap?: "wrap" | "nowrap" | "wrap-reverse";
-}
-/**
- * Media styles — for blocks with background images or media elements.
- */
-interface MediaStyleConfig {
-    /** Object fit for background/media elements. */
-    objectFit?: "cover" | "contain" | "fill" | "none" | "scale-down";
-    /** Aspect ratio (e.g., "video", "square", "auto", or custom like "4/3"). */
-    aspectRatio?: string;
-    /** Object position (e.g., "center", "top", "bottom"). */
-    objectPosition?: string;
-}
-/**
- * Combined style config for a single breakpoint.
- * Which properties are present depends on the block's declared style tiers.
- */
-interface BlockStyleValues extends ContainerStyleConfig, TextStyleConfig, LayoutStyleConfig, MediaStyleConfig {
-}
-/**
- * The full blockStyles structure stored as JSON string.
- * Keys are breakpoint names ("base" is always present, others come from config).
- *
- * @example
- * ```json
- * {
- *   "base": { "margin": "4", "padding": "2", "backgroundColor": "#fff" },
- *   "sm": { "margin": "6" },
- *   "lg": { "margin": "8", "padding": "4" }
- * }
- * ```
- */
-type BlockStylesData = Record<string, BlockStyleValues>;
-
-/**
- * A rich text document is an array of Slate/Plate element nodes.
- * This is the canonical type for all rich text content stored in VEX.
- *
- * Each element has a `type` (e.g., "p", "h1", "img") and `children`
- * (nested elements or text nodes with formatting marks).
- *
- * @example
- * ```ts
- * const doc: RichTextDocument = [
- *   { type: "h1", children: [{ text: "Hello" }] },
- *   { type: "p", children: [{ text: "World", bold: true }] },
- * ];
- * ```
- */
-type RichTextDocument = RichTextElement[];
-/** A single element node in a rich text document. */
-interface RichTextElement {
-    /** Node type identifier (e.g., "p", "h1", "img", "table") */
-    type: string;
-    /** Child nodes — nested elements or text leaves */
-    children: (RichTextElement | RichTextText)[];
-    /** URL for link/image elements */
-    url?: string;
-    /** Alt text for image elements */
-    alt?: string;
-    /** Media collection document ID for image elements (ID-based resolution) */
-    mediaId?: string;
-    /** Additional node-specific properties (alignment, colspan, etc.) */
-    [key: string]: unknown;
-}
-/** A text leaf node with optional formatting marks. */
-interface RichTextText {
-    /** The text content */
-    text: string;
-    /** Bold formatting */
-    bold?: boolean;
-    /** Italic formatting */
-    italic?: boolean;
-    /** Underline formatting */
-    underline?: boolean;
-    /** Strikethrough formatting */
-    strikethrough?: boolean;
-    /** Inline code formatting */
-    code?: boolean;
-}
-/**
- * Adapter interface for rich text editors.
- * Allows swapping Plate for Tiptap, Lexical, or any custom editor.
- *
- * Implement this interface and pass it to `defineConfig({ editor: ... })`
- * or to individual `richtext({ editor: ... })` fields.
- *
- * @example
- * ```ts
- * // Using the built-in Plate adapter
- * import { plateEditor } from "@vexcms/richtext/editor"
- * defineConfig({ editor: plateEditor() })
- *
- * // Building a custom adapter
- * const myAdapter: VexEditorAdapter = {
- *   type: "custom",
- *   editorComponent: MyEditorComponent,
- *   renderComponent: MyRenderComponent,
- * }
- * ```
- */
-interface VexEditorAdapter {
-    /**
-     * Unique identifier for this editor adapter (e.g., "plate", "tiptap", "lexical").
-     * Used for debugging and distinguishing between different editor implementations.
-     */
-    type: string;
-    /**
-     * React component that renders the editor in the admin form.
-     *
-     * Receives the current `RichTextDocument` value and an `onChange` callback.
-     * Must support `readOnly` mode for document preview.
-     * The component manages its own internal editor state and calls `onChange`
-     * when the user makes edits.
-     */
-    editorComponent: ComponentType<VexEditorComponentProps>;
-    /**
-     * React component that renders rich text content on the frontend.
-     *
-     * Receives the stored `RichTextDocument` and renders it as React elements.
-     * Must be safe for server-side rendering (no browser APIs).
-     * Optionally supports `resolveMedia` for image URL resolution.
-     */
-    renderComponent: ComponentType<VexRenderComponentProps>;
-}
-/**
- * Props passed to the editor component in the admin form.
- */
-interface VexEditorComponentProps {
-    /**
-     * Current editor value as a `RichTextDocument` (Slate/Plate JSON array).
-     * May be `null` or empty array `[]` for new documents.
-     */
-    value: RichTextDocument | null;
-    /**
-     * Callback to update the editor value.
-     * Called whenever the user makes edits. The new value replaces the old one entirely.
-     */
-    onChange: (value: RichTextDocument) => void;
-    /**
-     * Whether the field is read-only (e.g., user lacks update permission).
-     * When true, hide the toolbar and disable editing.
-     * @default false
-     */
-    readOnly?: boolean;
-    /** Placeholder text shown when the editor is empty. */
-    placeholder?: string;
-    /** Field label rendered above the editor. */
-    label?: string;
-    /** Helper text rendered below the editor. */
-    description?: string;
-    /** Field name (key) — used for form binding and accessibility. */
-    name: string;
-    /**
-     * Media collection slug for image uploads.
-     * When set, the editor can pick images from the specified media collection.
-     * When not set, only URL input and direct file upload are available.
-     */
-    mediaCollection?: string;
-}
-/**
- * Props passed to the render component on the frontend.
- *
- * @example
- * ```tsx
- * import { RichText } from "@vexcms/richtext/render"
- *
- * <RichText content={document.content} className="prose" />
- *
- * // With media ID resolution
- * <RichText
- *   content={document.content}
- *   resolveMedia={async (id) => getMediaUrl(id)}
- * />
- * ```
- */
-interface VexRenderComponentProps {
-    /**
-     * The stored rich text content as a `RichTextDocument` (Slate/Plate JSON array).
-     * Pass `null` or `[]` for empty content — the component will render nothing.
-     */
-    content: RichTextDocument | null;
-    /**
-     * Optional async resolver for media IDs → URLs.
-     * When provided, image nodes with a `mediaId` property will have their
-     * `url` resolved by calling this function before rendering.
-     *
-     * @param mediaId - The media collection document ID from the image node
-     * @returns The resolved URL, or `null` if the media could not be found
-     */
-    resolveMedia?: (mediaId: string) => Promise<string | null>;
-    /**
-     * CSS class name applied to the root element.
-     * Useful for applying prose styles (e.g., Tailwind's `prose` class).
-     */
-    className?: string;
-}
-
-/** Content alignment for data table cells. */
-type Alignment = "left" | "right" | "center";
-type Labels = {
-    singular: string;
-    plural: string;
-};
-/**
- * Props passed to custom field components.
- * Custom components receive these props and use useVexField() for state.
- *
- * Use the generic parameter to narrow the field type for type-safe access
- * to field-specific properties like `options` on select fields.
- *
- * @example
- * ```tsx
- * // Generic — fieldDef has label, admin, description, required
- * function MyField({ name, fieldDef, readOnly }: FieldComponentProps) { ... }
- *
- * // Narrowed — fieldDef is TextFieldDef with maxLength, minLength, etc.
- * function MyTextField({ name, fieldDef }: FieldComponentProps<TextFieldDef>) { ... }
- * ```
- */
-interface FieldComponentProps<TField extends VexField = VexField> {
-    /** The field key name (e.g., "primaryColor") */
-    name: string;
-    /** The VexField definition for this field */
-    fieldDef: TField;
-    /** Whether the field is read-only (from permissions or config) */
-    readOnly: boolean;
-}
-/**
- * Props passed to custom cell components in the data table.
- */
-interface CellComponentProps<TField extends VexField = VexField> {
-    /** The raw cell value from the document */
-    value: unknown;
-    /** The full row data (document) */
-    row: Record<string, unknown>;
-    /** The VexField definition for this column's field */
-    fieldDef: TField;
-}
-/**
- * Admin panel configuration for individual fields.
- * Controls visibility, layout, and input behavior in the admin UI.
- */
-interface FieldAdminConfig {
-    /**
-     * Hide this field from the admin form.
-     * Hidden fields are still stored in the database.
-     *
-     * Default: `false`
-     */
-    hidden?: boolean;
-    /**
-     * Make this field read-only in the admin form.
-     * The value is displayed but cannot be edited.
-     *
-     * Default: `false`
-     */
-    readOnly?: boolean;
-    /**
-     * Position of the field in the form layout.
-     *
-     * - `"main"` — placed in the main content area
-     * - `"sidebar"` — placed in the sidebar panel
-     *
-     * Default: `"main"`
-     */
-    position?: "main" | "sidebar";
-    /**
-     * Width of the field within its row.
-     *
-     * - `"full"` — spans the full width
-     * - `"half"` — spans half the width (two fields per row)
-     *
-     * Default: `"full"`
-     */
-    width?: "full" | "half";
-    /**
-     * Placeholder text shown in the input when empty.
-     */
-    placeholder?: string;
-    /**
-     * Helper text displayed below the field input.
-     * Use for additional context or formatting hints.
-     */
-    description?: string;
-    /**
-     * Content alignment in data table cells. 'left' | 'right' | 'center'
-     */
-    cellAlignment?: Alignment;
-    /**
-     * Custom components for this field.
-     *
-     * - `Field` replaces the entire field input in the edit form.
-     *   Only allowed on text, number, checkbox, and select fields.
-     *   The component receives FieldComponentProps and uses useVexField() for state.
-     *
-     * - `Cell` replaces the cell renderer in the data table list view.
-     *   Allowed on any field type.
-     */
-    components?: {
-        Field?: ComponentType<FieldComponentProps>;
-        Cell?: ComponentType<CellComponentProps>;
-    };
-}
-/**
- * Properties shared by all field types.
- * Each concrete field type extends this with its `type` discriminant
- * and type-specific options.
- */
-interface BaseField {
-    /** Display label for the field in the admin form. */
-    label?: string;
-    /** Description text shown below the field. */
-    description?: string;
-    /**
-     * Whether this field is required.
-     *
-     * Default: `false`
-     */
-    required?: boolean;
-    /** Admin UI configuration for this field. */
-    admin?: FieldAdminConfig;
-    /**
-     * Create a database index on this field.
-     * The string value becomes the index name in Convex.
-     *
-     * @example
-     * ```ts
-     * slug: { type: "text", index: "by_slug", required: true }
-     * // Generates: .index("by_slug", ["slug"])
-     * ```
-     */
-    index?: string;
-    /**
-     * Create a full-text search index on this field.
-     * The field this is defined on becomes the `searchField`.
-     *
-     * @example
-     * ```ts
-     * title: {
-     *   type: "text",
-     *   searchIndex: { name: "search_title", filterFields: ["status", "author"] },
-     * }
-     * // Generates: .searchIndex("search_title", { searchField: "title", filterFields: ["status", "author"] })
-     * ```
-     */
-    searchIndex?: {
-        /** Search index name (must be unique within the collection). */
-        name: string;
-        /**
-         * Fields to filter search results by.
-         * String array — validated at runtime against collection field names.
-         */
-        filterFields: string[];
-    };
-}
-/** Text field definition. */
-interface TextFieldDef extends BaseField {
-    readonly type: "text";
-    /** Default value for new documents. */
-    defaultValue?: string;
-    /** Minimum character length. */
-    minLength?: number;
-    /** Maximum character length. */
-    maxLength?: number;
-}
-/** Number field definition. */
-interface NumberFieldDef extends BaseField {
-    readonly type: "number";
-    /** Default value for new documents. */
-    defaultValue?: number;
-    /** Minimum allowed value. */
-    min?: number;
-    /** Maximum allowed value. */
-    max?: number;
-    /** Step increment for the input. */
-    step?: number;
-}
-/** Checkbox field definition. */
-interface CheckboxFieldDef extends BaseField {
-    readonly type: "checkbox";
-    /** Default value for new documents. */
-    defaultValue?: boolean;
-}
-/**
- * A single option in a select field.
- */
-interface SelectOption<T extends string = string> {
-    /** The stored value. */
-    readonly value: T;
-    /** The display label shown in the dropdown. */
-    readonly label: string;
-    /** Optional badge color for the data table. Accepts a hex string (e.g. "#3b82f6"). */
-    readonly badgeColor?: string;
-}
-/** Select field — single value variant. */
-interface SelectFieldSingle<T extends string = string> extends BaseField {
-    readonly type: "select";
-    /** The available options for this select field. */
-    options: readonly SelectOption<T>[];
-    /** Default value for new documents. */
-    defaultValue?: T;
-    hasMany?: false;
-}
-/** Select field — multi-value variant. */
-interface SelectFieldMany<T extends string = string> extends BaseField {
-    readonly type: "select";
-    /** The available options for this select field. */
-    options: readonly SelectOption<T>[];
-    /** Default value for new documents. */
-    defaultValue?: T;
-    /** Display labels for the field (singular/plural). */
-    labels?: Labels;
-    hasMany: true;
-}
-/** Select field definition with typed options. Discriminated on `hasMany`. */
-type SelectFieldDef<T extends string = string> = SelectFieldSingle<T> | SelectFieldMany<T>;
-/** Date field definition. Stores epoch milliseconds. */
-interface DateFieldDef extends BaseField {
-    readonly type: "date";
-    /** Default value for new documents (epoch ms). */
-    defaultValue?: number;
-}
-/** Image URL field definition. Stores a URL string, renders as thumbnail. */
-interface ImageUrlFieldDef extends BaseField {
-    readonly type: "imageUrl";
-    /** Default value for new documents. */
-    defaultValue?: string;
-    /** Width (px) of the image */
-    width?: number;
-    /** Height (px) of the image */
-    height?: number;
-}
-/** Relationship field — single reference variant. */
-interface RelationshipFieldSingle extends BaseField {
-    readonly type: "relationship";
-    /** Target table name. */
-    to: string;
-    hasMany?: false;
-}
-/** Relationship field — multi-reference variant. */
-interface RelationshipFieldMany extends BaseField {
-    readonly type: "relationship";
-    /** Target table name. */
-    to: string;
-    /** Display labels for the field (singular/plural). */
-    labels?: Labels;
-    hasMany: true;
-}
-/** Relationship field definition. Discriminated on `hasMany`. */
-type RelationshipFieldDef = RelationshipFieldSingle | RelationshipFieldMany;
-/** Shared upload field properties. */
-interface UploadFieldBase extends BaseField {
-    readonly type: "upload";
-    /** Target media collection slug. */
-    to: string;
-    /**
-     * Accepted MIME types for file uploads.
-     * Supports exact types ("image/png") and wildcards ("image/*").
-     * When not set, all file types are accepted.
-     */
-    accept?: string[];
-    /**
-     * Maximum file size in bytes for uploads.
-     * When not set, no size limit is enforced (beyond storage provider limits).
-     */
-    maxSize?: number;
-}
-/** Upload field — single reference variant. */
-interface UploadFieldSingle extends UploadFieldBase {
-    hasMany?: false;
-}
-/** Upload field — multi-reference variant. */
-interface UploadFieldMany extends UploadFieldBase {
-    /** Display labels for the field (singular/plural). */
-    labels?: Labels;
-    hasMany: true;
-}
-/**
- * Upload field definition. References a media collection document via `v.id()`.
- * Discriminated on `hasMany`.
- */
-type UploadFieldDef = UploadFieldSingle | UploadFieldMany;
-/** JSON field definition. Stores arbitrary data via `v.any()`. */
-interface JsonFieldDef extends BaseField {
-    readonly type: "json";
-}
-/** Object field definition. Stores a named group of sub-fields as `v.object()`. */
-interface ObjectFieldDef extends BaseField {
-    readonly type: "object";
-    /** Named sub-fields that make up this object. */
-    fields: Record<string, VexField>;
-}
-/** Array field definition. Wraps an inner field in `v.array()`. */
-interface ArrayFieldDef extends BaseField {
-    readonly type: "array";
-    /** Display labels for the field (singular/plural). */
-    labels?: Labels;
-    /** The field type for each item in the array. */
-    items: VexField;
-    /** Default value for the array (used when creating new documents/blocks). */
-    defaultValue?: unknown[];
-    /** Minimum number of items. */
-    min?: number;
-    /** Maximum number of items. */
-    max?: number;
-}
-
-/** Rich text field definition. Stores Plate/Slate JSON via `v.any()`. */
-interface RichTextFieldDef extends BaseField {
-    readonly type: "richtext";
-    /**
-     * Editor adapter override for this specific field.
-     * If not set, uses the global editor from `VexConfig.editor`.
-     */
-    editor?: VexEditorAdapter;
-    /**
-     * Media collection slug for image uploads.
-     * When set, the editor can pick images from the specified media collection,
-     * and paste/drop image uploads are auto-saved to this collection.
-     * When not set, images can only be inserted by URL.
-     */
-    mediaCollection?: string;
-}
-/**
- * Color picker field. Stores a color string in the configured format.
- *
- * @example
- * ```ts
- * accentColor: color({ label: "Accent Color", format: "hex" })
- * primaryColor: color({ label: "Primary", format: "oklch", themeColors: true })
- * ```
- */
-interface ColorFieldDef extends BaseField {
-    readonly type: "color";
-    /**
-     * Default color value.
-     * Should be in the configured format (hex, hsl, or oklch).
-     */
-    defaultValue?: string;
-    /**
-     * Output format for the color value.
-     * - "hex" — e.g., "#3b82f6" (default)
-     * - "hsl" — e.g., "hsl(217, 91%, 60%)"
-     * - "oklch" — e.g., "oklch(0.623 0.214 259.1)"
-     */
-    format?: "hex" | "hsl" | "oklch";
-    /**
-     * When true, shows a "Theme Colors" tab in the color picker
-     * that displays CSS variables from the current page's computed styles.
-     * Users can select a theme color variable instead of picking a custom color.
-     *
-     * Default: false
-     */
-    themeColors?: boolean;
-}
-/**
- * A single tab definition within a tabs field.
- */
-interface TabDef<TSlug extends string = string, TFields extends Record<string, VexField> = Record<string, VexField>> {
-    /** Display label for the tab in the admin panel. */
-    label: string;
-    /**
-     * All fields in this tab are nested under this key as an object.
-     * e.g., `slug: "light"` → `{ light: { background: "#fff", ... } }`
-     */
-    slug: TSlug;
-    /** Fields within this tab. */
-    fields: TFields;
-}
-/**
- * Tabs field definition. Groups fields into tabbed UI sections in the admin panel.
- *
- * - Tabs with `slug` create nested objects in the document
- * - Tabs without `slug` flatten their fields onto the parent
- *
- * @example
- * ```ts
- * themeColors: tabs({
- *   label: "Theme Colors",
- *   tabs: [
- *     {
- *       label: "Light",
- *       slug: "light",
- *       fields: {
- *         background: color({ label: "Background" }),
- *         foreground: color({ label: "Foreground" }),
- *       },
- *     },
- *     {
- *       label: "Dark",
- *       slug: "dark",
- *       fields: {
- *         background: color({ label: "Background" }),
- *         foreground: color({ label: "Foreground" }),
- *       },
- *     },
- *   ],
- * })
- * ```
- */
-interface TabsFieldDef<TTabs extends TabDef[] = TabDef[]> extends BaseField {
-    readonly type: "tabs";
-    /** The tab definitions. */
-    tabs: TTabs;
-}
-/**
- * UI field definition. Non-persisted — renders a custom component only.
- * Skipped during schema generation, form validation, and column generation.
- * Requires admin.components.Field to be set.
- */
-interface UIFieldDef extends BaseField {
-    readonly type: "ui";
-    /**
-     * Admin config — components.Field is required for ui fields.
-     */
-    admin: FieldAdminConfig & {
-        components: {
-            Field: ComponentType<FieldComponentProps>;
-        };
-    };
-}
-/**
- * Admin configuration specific to block definitions.
- */
-interface BlockAdminConfig {
-    /** Icon identifier for the block picker UI (e.g., "layout-template"). */
-    icon?: string;
-    /** Custom admin components for this block (future — Spec 09b). */
-    components?: {
-        Editor?: ComponentType<any>;
-    };
-    /**
-     * Enable block style controls in the admin panel.
-     *
-     * - `true` — enables container styles only (equivalent to `["container"]`)
-     * - `StyleTier[]` — enables specific style tiers (e.g., `["container", "text", "media"]`)
-     * - `undefined` / omitted — no style controls shown
-     *
-     * Available tiers: "container", "text", "layout", "media"
-     */
-    blockStyles?: true | StyleTier[];
-}
-/**
- * A block definition created by `defineBlock()`.
- * Blocks are reusable field groups composed into ordered lists via the `blocks()` field type.
- *
- * @example
- * ```ts
- * const heroBlock = defineBlock({
- *   slug: "hero",
- *   label: "Hero Section",
- *   fields: { heading: text({ required: true }), subheading: text() },
- * })
- * ```
- */
-interface BlockDef<TFields extends Record<string, VexField> = Record<string, VexField>> {
-    /** Unique identifier for this block type. Used as the `blockType` discriminant in stored data. */
-    readonly slug: string;
-    /** Display label for the block in the admin picker. */
-    label: string;
-    /** Field definitions for this block's data shape. */
-    fields: TFields;
-    /** Admin UI configuration. */
-    admin?: BlockAdminConfig;
-    /**
-     * TypeScript interface name used in generated `vex.types.ts`.
-     * If not set, auto-generated from slug via PascalCase conversion.
-     * @example "HeroBlock"
-     */
-    interfaceName?: string;
-}
-/** Blocks field definition. Stores an ordered array of block instances. */
-interface BlocksFieldDef extends BaseField {
-    readonly type: "blocks";
-    /** The block definitions allowed in this field. */
-    blocks: BlockDef[];
-    /** Display labels for the field (singular/plural). */
-    labels?: Labels;
-    /** Minimum number of blocks. */
-    min?: number;
-    /** Maximum number of blocks. */
-    max?: number;
-}
-/**
- * Distributive version of `Omit` that preserves union branches.
- * Standard `Omit` collapses unions; this applies `Omit` to each branch individually.
- */
-type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
-/**
- * Discriminated union of all field types. Switch on `field.type` to narrow.
- *
- * @example
- * ```ts
- * function handle(field: VexField) {
- *   switch (field.type) {
- *     case "text":
- *       field.maxLength; // TextFieldDef ✓
- *       break;
- *     case "select":
- *       field.options;   // SelectFieldDef ✓
- *       break;
- *   }
- * }
- * ```
- */
-type VexField = TextFieldDef | NumberFieldDef | CheckboxFieldDef | SelectFieldDef<string> | DateFieldDef | ImageUrlFieldDef | RelationshipFieldDef | UploadFieldDef | JsonFieldDef | ObjectFieldDef | ArrayFieldDef | RichTextFieldDef | UIFieldDef | BlocksFieldDef | ColorFieldDef | TabsFieldDef;
-/**
- * Infer the TypeScript value type from a VexField.
- * Uses the `type` discriminant and field options to determine the type.
- */
-type InferFieldType<F extends VexField> = F extends {
-    type: "text";
-} ? string : F extends {
-    type: "number";
-} ? number : F extends {
-    type: "checkbox";
-} ? boolean : F extends {
-    type: "select";
-    hasMany: true;
-} ? string[] : F extends {
-    type: "select";
-} ? string : F extends {
-    type: "date";
-} ? number : F extends {
-    type: "imageUrl";
-} ? string : F extends {
-    type: "relationship";
-    hasMany: true;
-} ? string[] : F extends {
-    type: "relationship";
-} ? string : F extends {
-    type: "upload";
-    hasMany: true;
-} ? string[] : F extends {
-    type: "upload";
-} ? string : F extends {
-    type: "json";
-} ? unknown : F extends {
-    type: "object";
-} ? Record<string, unknown> : F extends {
-    type: "richtext";
-} ? RichTextDocument : F extends {
-    type: "blocks";
-} ? Array<InferBlockUnion<F>> : F extends {
-    type: "array";
-} ? unknown[] : F extends {
-    type: "ui";
-} ? never : F extends {
-    type: "color";
-} ? string : F extends {
-    type: "tabs";
-} ? Record<string, unknown> : never;
-/**
- * Infer the discriminated union type for a blocks field.
- * Each block becomes an object type with `blockType` literal + `_key` + its field types.
- */
-type InferBlockUnion<F extends VexField> = F extends BlocksFieldDef ? F["blocks"][number] extends infer B ? B extends BlockDef<infer TFields> ? {
-    blockType: B["slug"];
-    blockName?: string;
-    _key: string;
-} & {
-    [K in keyof TFields]: InferFieldType<TFields[K] & VexField>;
-} : never : never : never;
-/**
- * Infer the expanded tab fields from a tabs field definition.
- * Each tab becomes a property keyed by its slug with an object of its inferred fields.
- */
-type InferTabsExpansion<F extends TabsFieldDef> = F["tabs"][number] extends infer T ? T extends TabDef<infer TSlug, infer TFields> ? {
-    [K in TSlug]?: {
-        [FK in keyof TFields]: InferFieldType<TFields[FK] & VexField>;
-    };
-} : {} : {};
-/**
- * Extract keys of fields that are tabs fields.
- */
-type TabsFieldKeys<F extends Record<string, any>> = {
-    [K in keyof F]: (F[K] & VexField) extends {
-        type: "tabs";
-    } ? K : never;
-}[keyof F];
-/**
- * Extract keys of fields that are NOT tabs fields.
- */
-type NonTabsFieldKeys<F extends Record<string, any>> = {
-    [K in keyof F]: (F[K] & VexField) extends {
-        type: "tabs";
-    } ? never : K;
-}[keyof F];
-/**
- * Expand all tabs fields in a record into their tab slug entries.
- * Produces a union of objects (one per tabs field) which gets intersected.
- */
-type ExpandTabsFields<F extends Record<string, any>> = TabsFieldKeys<F> extends infer TK ? TK extends keyof F ? InferTabsExpansion<F[TK] & TabsFieldDef> : {} : {};
-/**
- * Infer the document type from a record of fields.
- * Tabs fields are expanded: instead of `colors: Record<string, unknown>`,
- * produces `light?: { ... }; dark?: { ... }` based on the tab definitions.
- *
- * @example
- * ```ts
- * type Doc = InferFieldsType<{
- *   title: { type: "text"; required: true };
- *   count: { type: "number" };
- * }>;
- * // { title: string; count: number }
- * ```
- */
-type InferFieldsType<F extends Record<string, VexField>> = 0 extends (1 & F) ? {
-    [x: string]: unknown;
-} : {
-    [K in NonTabsFieldKeys<F> & keyof F]: InferFieldType<F[K] & VexField>;
-} & UnionToIntersection<ExpandTabsFields<F>>;
-/**
- * Convert a union to an intersection.
- * Used to merge expanded tab objects into a single type.
- */
-type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
-
-/**
- * Responsive breakpoint for the live preview iframe.
- */
-interface LivePreviewBreakpoint {
-    /** Display label (e.g., "Mobile", "Desktop") */
-    label: string;
-    /** Viewport width in pixels */
-    width: number;
-    /** Viewport height in pixels */
-    height: number;
-    /** Lucide icon name for the breakpoint button */
-    icon?: "smartphone" | "tablet" | "laptop" | "monitor";
-}
-/**
- * Live preview configuration for a collection.
- * Works with or without `versions.drafts` — the admin panel writes
- * a transient preview snapshot on form changes regardless.
- *
- * @typeParam TFields - The collection's field definitions, used to type the `doc`
- *   parameter in the `url` function. Defaults to `Record<string, VexField>`.
- */
-interface LivePreviewConfig<TFields extends Record<string, VexField> = Record<string, VexField>> {
-    /**
-     * URL for the preview iframe.
-     * - String: static URL (e.g., "/preview/pages")
-     * - Function: receives the document data (typed from the collection's fields), returns URL
-     *
-     * @param doc - The current document data including `_id` and all collection fields
-     */
-    url: string | ((doc: {
-        _id: string;
-    } & InferFieldsType<TFields>) => string);
-    /**
-     * Breakpoints for responsive preview.
-     * Overrides `admin.livePreview.breakpoints` if set.
-     */
-    breakpoints?: LivePreviewBreakpoint[];
-    /**
-     * Fields that trigger URL recomputation when changed.
-     * - Not set: URL recomputes on every save
-     * - Set: URL only recomputes when these fields change
-     * - Empty array: URL never recomputes (only content refreshes)
-     */
-    reloadOnFields?: string[];
-}
-/**
- * Global live preview configuration on the admin config.
- * Provides defaults that individual collections can override.
- */
-interface AdminLivePreviewConfig {
-    /** Default breakpoints for all collections with live preview */
-    breakpoints?: LivePreviewBreakpoint[];
-}
-
-/**
- * System field keys injected into all user collection schemas.
- * `vex_status` is always present; `vex_version` and `vex_publishedAt`
- * are added when `versions.drafts` is enabled.
- */
-type VersioningFieldKeys = "vex_status" | "vex_version" | "vex_publishedAt";
-/**
- * Admin UI configuration for a collection.
- * Controls how the collection appears and behaves in the admin panel.
- */
-interface CollectionAdminConfig<TFields extends Record<string, VexField> = Record<string, VexField>, TExtraKeys extends string = never> {
-    /**
-     * Group this collection under a heading in the sidebar.
-     * Collections with the same group string are grouped together.
-     */
-    group?: string;
-    /**
-     * Icon name for the collection in the sidebar.
-     * Uses Lucide icon names (e.g. `"file-text"`, `"users"`, `"settings"`).
-     */
-    icon?: string;
-    /**
-     * Field key to use as the document title in list views.
-     * Should reference a text-like field from the collection's fields,
-     * or an auth field key when `auth` is provided.
-     */
-    useAsTitle?: keyof TFields | TExtraKeys;
-    /**
-     * Field keys to show as default columns in the list view.
-     * If not set, all fields are shown (with `_id` first).
-     * When set, only the specified fields are shown — `_id` is only
-     * included if explicitly listed.
-     * When `auth` is provided, auth field keys (e.g. `"email"`) are also accepted.
-     */
-    defaultColumns?: ("_id" | keyof TFields | TExtraKeys)[];
-    /**
-     * Disable the "Create New" button in the admin list view.
-     *
-     * Default: `false`
-     */
-    disableCreate?: boolean;
-    /**
-     * Disable the delete action in the admin panel.
-     *
-     * Default: `false`
-     */
-    disableDelete?: boolean;
-    /**
-     * Live preview configuration.
-     * When set, the admin edit view shows a toggleable side-by-side preview panel
-     * with an iframe loading the configured URL.
-     *
-     * Works with or without `versions.drafts` — the admin panel writes a transient
-     * preview snapshot to `vex_versions` on form changes. The preview iframe fetches
-     * this snapshot via `vexQuery` with Convex's real-time subscriptions.
-     */
-    livePreview?: LivePreviewConfig<TFields>;
-}
-/**
- * Index definition for a collection.
- * Compound indexes include multiple fields — order matters.
- */
-interface IndexConfig<TFields extends Record<string, VexField> = Record<string, VexField>, TExtraKeys extends string = never> {
-    /**
-     * Index name (must be unique within the collection).
-     * Convention: `"by_<field>"` for single-field, `"by_<field1>_<field2>"` for compound.
-     */
-    name: string;
-    /**
-     * Field names to include in the index. Order matters for compound indexes.
-     */
-    fields: (keyof TFields & string | TExtraKeys)[];
-}
-/**
- * Search index definition for a collection.
- * Enables full-text search on a field with optional filter fields.
- */
-interface SearchIndexConfig<TFields extends Record<string, VexField> = Record<string, VexField>, TExtraKeys extends string = never> {
-    /**
-     * Search index name (must be unique within the collection).
-     * Convention: `"search_<field>"`.
-     */
-    name: string;
-    /**
-     * The field to perform full-text search on.
-     */
-    searchField: keyof TFields & string | TExtraKeys;
-    /**
-     * Optional fields to filter search results by.
-     */
-    filterFields?: (keyof TFields & string | TExtraKeys)[];
-}
-/**
- * Configuration for versioning and draft/publish workflow on a collection.
- * When `drafts` is enabled, the admin panel shows Save Draft + Publish
- * instead of a simple Save button.
- */
-interface VersionsConfig {
-    /**
-     * Enable the draft/publish workflow.
-     * When true, new documents start as drafts and must be explicitly published.
-     * The schema gets `_status`, `_version`, and `_publishedAt` fields injected.
-     *
-     * Default: `false`
-     */
-    drafts?: boolean;
-    /**
-     * Enable autosave. Requires `drafts: true`.
-     * When `true`, uses a default 2000ms interval.
-     * When an object, specify a custom interval.
-     *
-     * Default: `false`
-     */
-    autosave?: boolean | {
-        /** Interval in milliseconds between autosaves. Default: 2000 */
-        interval: number;
-    };
-    /**
-     * Maximum number of versions to keep per document.
-     * Oldest non-published versions are deleted when exceeded.
-     * `0` means unlimited.
-     *
-     * Default: `100`
-     */
-    maxPerDoc?: number;
-}
-/**
- * A collection definition. Users create these as plain objects
- * with `as const satisfies VexCollection`.
- *
- * @example
- * ```ts
- * const posts = {
- *   slug: "posts",
- *   fields: {
- *     title: { type: "text", label: "Title", required: true },
- *   },
- * } as const satisfies VexCollection;
- * ```
- */
-interface VexCollection<TFields extends Record<string, any> = any, TExtraKeys extends string = string, TSlug extends string = string> {
-    /** The collection identifier, used in URLs and the database. */
-    readonly slug: TSlug;
-    /**
-     * The fields that make up documents in this collection.
-     * Each key becomes a field name, and the value defines
-     * its type (e.g. `{ type: "text" }`, `{ type: "number" }`, `{ type: "select", ... }`).
-     */
-    fields: TFields;
-    /**
-     * The name of the table generated for this collection in the
-     * generated vex schema file. Defaults to the collection slug.
-     */
-    tableName?: string;
-    /**
-     * Display labels for the collection in the admin UI.
-     * If not provided, labels are derived from the collection slug.
-     */
-    labels?: {
-        /** Singular label (e.g. `"Post"`). */
-        singular?: string;
-        /** Plural label (e.g. `"Posts"`). */
-        plural?: string;
-    };
-    /**
-     * Admin UI configuration for this collection.
-     * Controls sidebar grouping, icons, list columns, and permissions.
-     */
-    admin?: CollectionAdminConfig<TFields, TExtraKeys>;
-    /**
-     * Database indexes for this collection.
-     */
-    indexes?: IndexConfig<TFields, TExtraKeys>[];
-    /**
-     * Search indexes for full-text search on this collection.
-     */
-    searchIndexes?: SearchIndexConfig<TFields, TExtraKeys>[];
-    /**
-     * Versioning and draft/publish workflow configuration.
-     * When `versions.drafts` is `true`, the collection gets draft/publish
-     * workflow in the admin panel and version history tracking.
-     *
-     * Only available on user collections (including auth-merged collections).
-     * NOT available on media collections — use VexMediaCollection for those.
-     */
-    versions?: VersionsConfig;
-    /**
-     * When true, the CLI generates typed per-collection query/mutation files
-     * for this collection (`convex/vex/api/{slug}.ts` + `convex/vex/model/api/{slug}.ts`).
-     *
-     * Defaults to `true` for user-defined collections and media collections.
-     * Auth adapter collections default to `false` — set explicitly to opt in.
-     */
-    generateApi?: boolean;
-    /**
-     * Internal marker set by resolveMediaCollection().
-     * When true, ExtractFieldKeys includes DefaultMediaFieldKeys.
-     * @internal — do not set manually.
-     */
-    _isMedia?: true;
-    /**
-     * TypeScript interface name used in generated `vex.types.ts`.
-     * If not set, auto-generated from slug via PascalCase conversion.
-     * @example "BlogPost"
-     */
-    interfaceName?: string;
-    /**
-     * Type helper — use `typeof collection._docType` to get the
-     * inferred document shape for this collection.
-     */
-    readonly _docType?: InferFieldsType<TFields>;
-}
-/**
- * A VexCollection with erased generics, suitable for heterogeneous arrays.
- *
- * @deprecated Use `VexCollection` instead — its default generics accept the
- * same values. This alias is kept only for backwards compatibility.
- */
-type AnyVexCollection = VexCollection<any, any>;
-
-/**
- * Admin UI configuration for a global.
- * Controls how the global appears and behaves in the admin panel.
- */
-interface GlobalAdminConfig<TFields extends Record<string, VexField> = Record<string, VexField>> {
-    /**
-     * Group this global under a heading in the sidebar.
-     * Globals with the same group string are grouped together.
-     */
-    group?: string;
-    /**
-     * Icon name for the global in the sidebar.
-     * Uses Lucide icon names (e.g. `"settings"`, `"globe"`, `"layout"`).
-     */
-    icon?: string;
-    /**
-     * Field key to use as the document title in the admin panel.
-     * Should reference a text-like field from the global's fields.
-     */
-    useAsTitle?: keyof TFields;
-    /**
-     * Live preview configuration.
-     * When set, the admin edit view shows a toggleable side-by-side preview panel
-     * with an iframe loading the configured URL.
-     */
-    livePreview?: LivePreviewConfig<TFields>;
-}
-/**
- * A global definition. Globals are singleton documents — only one
- * document exists per global. The admin panel shows them as a single
- * editable form, not a list view.
- *
- * @example
- * ```ts
- * const siteSettings = defineGlobal({
- *   slug: "site_settings",
- *   label: "Site Settings",
- *   fields: {
- *     siteName: text({ label: "Site Name", required: true }),
- *     description: text({ label: "Description" }),
- *   },
- *   admin: { useAsTitle: "siteName" },
- * });
- * ```
- */
-interface VexGlobal<TFields extends Record<string, VexField> = Record<string, VexField>, TSlug extends string = string> {
-    /** The global identifier, used in URLs and the database. */
-    readonly slug: TSlug;
-    /**
-     * The fields that make up this global document.
-     */
-    fields: TFields;
-    /**
-     * Display label for the global in the admin UI.
-     * If not provided, the label is derived from the global slug.
-     */
-    label?: string;
-    /**
-     * The name of the table generated for this global in the
-     * generated vex schema file. Defaults to the global slug.
-     */
-    tableName?: string;
-    /**
-     * Admin UI configuration for this global.
-     * Controls sidebar grouping, icons, and live preview.
-     */
-    admin?: GlobalAdminConfig<TFields>;
-    /**
-     * Versioning and draft/publish workflow configuration.
-     * When `drafts` is enabled, the admin panel shows Save Draft + Publish
-     * and version history, same as versioned collections.
-     */
-    versions?: VersionsConfig;
-    /**
-     * TypeScript interface name used in generated `vex.types.ts`.
-     * If not set, auto-generated from slug via PascalCase conversion.
-     * @example "SiteSettings"
-     */
-    interfaceName?: string;
-    /**
-     * Type helper — use `typeof global._docType` to get the
-     * inferred document shape for this global.
-     */
-    readonly _docType?: InferFieldsType<TFields>;
-}
-
-/**
- * A resolved index ready for code generation.
- */
-interface ResolvedIndex {
-    /** Index name (e.g., "by_slug") */
-    name: string;
-    /** Field names included in the index */
-    fields: string[];
-}
-/**
- * A resolved search index ready for code generation.
- */
-interface ResolvedSearchIndex {
-    /** Search index name (e.g., "search_title") */
-    name: string;
-    /** The field to perform full-text search on (must be a string field) */
-    searchField: string;
-    /** Fields that can be used to filter search results */
-    filterFields: string[];
-}
-/**
- * A type-level map from collection slug to field key union.
- * Used by auth adapters to provide LSP autocomplete for auth field keys
- * in `defaultColumns`, `useAsTitle`, etc.
- *
- * @example
- * ```ts
- * type MyMap = {
- *   user: "email" | "createdAt" | "updatedAt";
- *   session: "userId" | "token" | "expiresAt";
- * };
- * ```
- */
-type AuthFieldKeyMap = Record<string, string>;
-/**
- * The auth adapter object stored in `VexConfig.auth`.
- * Returned by `vexBetterAuth()`.
- *
- * Uses VexCollection[] — auth tables are defined with the same
- * VexField system as user collections, enabling uniform schema
- * generation, column rendering, and admin UI support.
- *
- * @typeParam TFieldKeyMap - Type-level map from collection slug to field key union.
- *   Enables LSP autocomplete for auth field keys in `defaultColumns`, `useAsTitle`, etc.
- */
-interface VexAuthAdapter<TFieldKeyMap extends AuthFieldKeyMap = AuthFieldKeyMap> {
-    /** Auth provider identifier (e.g., "better-auth") */
-    readonly name: string;
-    /**
-     * All auth collections (user, session, account, verification, plugin tables, etc.).
-     * Already includes plugin-contributed tables and field extensions.
-     * Core's schema generator uses these as the base, then merges any
-     * user-defined collection configs on top for admin UI customization.
-     */
-    collections: VexCollection[];
-    /**
-     * Phantom property — never set at runtime.
-     * Carries the type-level field key map for LSP autocomplete.
-     */
-    readonly _fieldKeyMap?: TFieldKeyMap;
-}
-/**
- * Extract field keys from an auth adapter's collection that matches a given slug.
- * Looks up from the adapter's `_fieldKeyMap` phantom type.
- *
- * @example
- * type UserAuthFields = AuthCollectionFieldKeys<typeof auth, "user">;
- * // => "email" | "emailVerified" | "image" | "createdAt" | "updatedAt"
- */
-type AuthCollectionFieldKeys<TAuth extends VexAuthAdapter<any>, TSlug extends string> = TAuth extends VexAuthAdapter<infer TMap> ? TSlug extends keyof TMap ? TMap[TSlug] & string : never : never;
-/**
- * @deprecated Use AuthCollectionFieldKeys instead.
- */
-type AuthTableFieldKeys<TAuth extends VexAuthAdapter<any>, TSlug extends string> = AuthCollectionFieldKeys<TAuth, TSlug>;
-
-/** Resolved admin panel configuration */
-interface AdminConfig {
-    /** Collection slug used for user authentication */
-    user: string;
-    /** Page metadata */
-    meta: {
-        /** Suffix appended to the page title in the browser tab */
-        titleSuffix: string;
-        /** Path to the favicon for the admin panel */
-        favicon: string;
-    };
-    /** Sidebar navigation configuration */
-    sidebar: {
-        /** Whether global collections are hidden from the sidebar */
-        hideGlobals: boolean;
-    };
-    /** Global live preview defaults */
-    livePreview?: AdminLivePreviewConfig;
-    /** Onboarding tour configuration */
-    onboarding: {
-        /** Whether the onboarding tour is disabled. Default: false (tour enabled) */
-        disabled: boolean;
-    };
-}
-/**
- * Admin page metadata configuration.
- *
- * Default:
- * ```
- * titleSuffix: "| Admin"
- * favicon:     "/favicon.ico"
- * ```
- */
-interface AdminMetaInput {
-    /**
-     * Suffix appended to the page title in the browser tab.
-     *
-     * Default: `"| Admin"`
-     */
-    titleSuffix?: string;
-    /**
-     * Path to the favicon for the admin panel.
-     *
-     * Default: `"/favicon.ico"`
-     */
-    favicon?: string;
-}
-/**
- * Admin sidebar configuration.
- *
- * Default:
- * ```
- * hideGlobals: false
- * ```
- */
-interface AdminSidebarInput {
-    /**
-     * Hide global collections from the sidebar navigation.
-     *
-     * Default: `false`
-     */
-    hideGlobals?: boolean;
-}
-/**
- * Admin panel configuration.
- *
- * Default:
- * ```
- * user: "users"
- * meta:
- *   titleSuffix: "| Admin"
- *   favicon:     "/favicon.ico"
- * sidebar:
- *   hideGlobals: false
- * ```
- */
-interface AdminConfigInput {
-    /**
-     * Collection slug to use for user authentication.
-     *
-     * Default: `"users"`
-     */
-    user?: string;
-    /**
-     * Admin page metadata configuration.
-     *
-     * Default:
-     * ```
-     * titleSuffix: "| Admin"
-     * favicon:     "/favicon.ico"
-     * ```
-     */
-    meta?: AdminMetaInput;
-    /**
-     * Sidebar navigation configuration.
-     *
-     * Default:
-     * ```
-     * hideGlobals: false
-     * ```
-     */
-    sidebar?: AdminSidebarInput;
-    /**
-     * Global live preview defaults.
-     * Individual collections can override these breakpoints.
-     */
-    livePreview?: AdminLivePreviewConfig;
-    /**
-     * Onboarding tour configuration.
-     *
-     * Default:
-     * ```
-     * disabled: false
-     * ```
-     */
-    onboarding?: {
-        /**
-         * Disable the onboarding tour for all users.
-         *
-         * Default: `false`
-         */
-        disabled?: boolean;
-    };
-}
-
-/** Schema generation configuration. */
-interface SchemaConfig {
-    /**
-     * Output path for the generated schema file, relative to project root.
-     *
-     * Default: `"convex/vex.schema.ts"`
-     */
-    outputPath: string;
-    /**
-     * Output path for the generated TypeScript types file, relative to project root.
-     * Contains typed interfaces for all collections, blocks, and globals.
-     *
-     * Default: `"convex/vex.types.ts"`
-     */
-    typesOutputPath: string;
-    /**
-     * Automatically backfill existing documents when a new required field
-     * with a `defaultValue` is added.
-     *
-     * Default: `true`
-     */
-    autoMigrate: boolean;
-    /**
-     * Automatically remove table entries from `schema.ts` when collections
-     * or globals are removed from `vex.config.ts`.
-     *
-     * Only removes simple entries (bare `exportName,` lines). Entries using
-     * `extendTable()`, constant keys, or other custom patterns are left
-     * untouched with a warning.
-     *
-     * Default: `false`
-     */
-    autoRemove: boolean;
-}
-/** Schema generation configuration input (all fields optional). */
-interface SchemaConfigInput {
-    /**
-     * Output path for the generated schema file, relative to project root.
-     * Can change the filename (e.g., `"convex/generated-schema.ts"`) or
-     * the directory (e.g., `"src/convex/vex.schema.ts"`).
-     *
-     * Default: `"convex/vex.schema.ts"`
-     */
-    outputPath?: string;
-    /**
-     * Output path for the generated TypeScript types file, relative to project root.
-     * Contains typed interfaces for all collections, blocks, and globals.
-     *
-     * Default: `"convex/vex.types.ts"`
-     */
-    typesOutputPath?: string;
-    /**
-     * Automatically backfill existing documents when a new required field
-     * with a `defaultValue` is added.
-     *
-     * Default: `true`
-     */
-    autoMigrate?: boolean;
-    /**
-     * Automatically remove table entries from `schema.ts` when collections
-     * or globals are removed from `vex.config.ts`.
-     *
-     * Only removes simple entries (bare `exportName,` lines). Entries using
-     * `extendTable()`, constant keys, or other custom patterns are left
-     * untouched with a warning.
-     *
-     * Default: `false`
-     */
-    autoRemove?: boolean;
-}
-
-/**
- * Interface that file storage plugins must implement.
- * Each method operates on the storage provider (e.g., Convex file storage, S3, Cloudinary).
- */
-interface FileStorageAdapter {
-    /** Identifier for the storage provider (e.g., "convex", "s3", "cloudinary"). */
-    readonly name: string;
-    /**
-     * The Convex value type string for the storageId field in media collections.
-     * Determines the schema type at generation time.
-     *
-     * - Convex adapter: `'v.id("_storage")'` — typed reference to Convex file storage
-     * - Generic adapters: `'v.string()'` — plain string for external storage URLs/IDs
-     */
-    readonly storageIdValueType: string;
-    /**
-     * Get a presigned upload URL from the storage provider.
-     * Called by the admin panel before uploading a file.
-     *
-     * @returns A URL string that accepts file uploads via PUT/POST.
-     */
-    getUploadUrl: () => Promise<string>;
-    /**
-     * Resolve a storage ID to an accessible URL.
-     *
-     * @param props.storageId - The storage provider's file identifier.
-     * @returns A URL string for accessing the file, or null if the file doesn't exist.
-     */
-    getUrl: (props: {
-        storageId: string;
-    }) => Promise<string | null>;
-    /**
-     * Delete a file from the storage provider.
-     *
-     * @param props.storageId - The storage provider's file identifier.
-     */
-    deleteFile: (props: {
-        storageId: string;
-    }) => Promise<void>;
-}
-/**
- * Fields that are auto-injected into every media collection and cannot be overridden.
- */
-declare const LOCKED_MEDIA_FIELDS: readonly ["storageId", "filename", "mimeType", "size"];
-type LockedMediaField = (typeof LOCKED_MEDIA_FIELDS)[number];
-/**
- * Fields that are auto-injected but CAN be overridden by the user.
- */
-declare const OVERRIDABLE_MEDIA_FIELDS: readonly ["url", "alt", "width", "height"];
-type OverridableMediaField = (typeof OVERRIDABLE_MEDIA_FIELDS)[number];
-/**
- * Keys of all default media fields auto-injected by `defineConfig()`.
- * Used as extra autocomplete keys in `CollectionAdminConfig` so that
- * `useAsTitle`, `defaultColumns`, etc. suggest both user fields and preset fields.
- */
-type DefaultMediaFieldKeys = LockedMediaField | OverridableMediaField;
-/**
- * A media collection definition. Users create these as plain objects.
- * Default media fields (storageId, filename, mimeType, size, url, alt, width, height)
- * are injected automatically by `defineConfig()`.
- *
- * The `fields` record contains ONLY user-defined additional fields or overrides
- * of overridable defaults (url, alt, width, height).
- */
-interface VexMediaCollection<TFields extends Record<string, VexField> = any, TSlug extends string = string> {
-    readonly slug: TSlug;
-    fields?: TFields;
-    tableName?: string;
-    labels?: {
-        singular?: string;
-        plural?: string;
-    };
-    admin?: CollectionAdminConfig<TFields, DefaultMediaFieldKeys>;
-}
-/**
- * The resolved media configuration on VexConfig.
- */
-interface MediaConfig {
-    collections: VexCollection[];
-    storageAdapter: FileStorageAdapter;
-}
-/**
- * Client-safe media configuration with non-serializable parts stripped.
- * Used when passing config across RSC serialization boundaries (e.g., to client components).
- */
-interface ClientMediaConfig {
-    collections: VexCollection[];
-}
-/**
- * Input shape for the `media` field on VexConfigInput.
- */
-interface MediaConfigInput {
-    collections: VexMediaCollection[];
-    storageAdapter: FileStorageAdapter;
-}
-
-/**
- * Extract the slug literal type from a VexCollection or VexGlobal.
- *
- * @example
- * type S = ExtractSlug<typeof posts>; // "posts"
- */
-type ExtractSlug<T> = T extends {
-    slug: infer S extends string;
-} ? S : never;
-/**
- * Expand field keys from a fields record, replacing tabs field keys with their tab slugs.
- */
-type ExpandedFieldKeys<TFields extends Record<string, any>> = {
-    [K in keyof TFields & string]: (TFields[K] & VexField) extends {
-        type: "tabs";
-    } ? (TFields[K] & TabsFieldDef)["tabs"][number] extends TabDef<infer TSlug> ? TSlug : never : K;
-}[keyof TFields & string];
-/**
- * Extract field keys from a VexCollection (including auth extra keys) or VexGlobal.
- * Tabs fields are expanded: instead of the tabs field name, the tab slugs are returned.
- *
- * @example
- * type K = ExtractFieldKeys<typeof posts>; // "title" | "slug" | "status" | "featured"
- */
-type ExtractFieldKeys<T> = T extends VexCollection<infer TFields, infer TExtraKeys> ? T extends {
-    _isMedia: true;
-} ? ExpandedFieldKeys<TFields> | (TExtraKeys & string) | DefaultMediaFieldKeys : ExpandedFieldKeys<TFields> | (TExtraKeys & string) : T extends VexMediaCollection<infer TFields> ? ExpandedFieldKeys<TFields> | DefaultMediaFieldKeys : T extends VexGlobal<infer TFields> ? ExpandedFieldKeys<TFields> : never;
-/**
- * Extract the inferred document type from a VexCollection or VexGlobal.
- * Includes `_id` (system field) and auth extra keys (typed as `string`).
- */
-type ExtractDocType<T> = T extends VexCollection<infer TFields, infer TExtraKeys> ? {
-    _id: string;
-} & InferFieldsType<TFields> & {
-    [K in TExtraKeys & string]: string;
-} : T extends VexMediaCollection<infer TFields> ? {
-    _id: string;
-} & InferFieldsType<TFields> & {
-    [K in DefaultMediaFieldKeys]: string | number;
-} : T extends VexGlobal<infer TFields> ? {
-    _id: string;
-} & InferFieldsType<TFields> : never;
-/**
- * Lookup a resource (collection or global) by slug from a tuple of resources.
- *
- * @example
- * type P = LookupBySlug<[typeof posts, typeof users], "posts">; // typeof posts
- */
-type LookupBySlug<TResources extends readonly any[], TSlug extends string> = TResources extends readonly [infer Head, ...infer Tail] ? Head extends {
-    slug: TSlug;
-} ? Head : LookupBySlug<Tail, TSlug> : never;
-/**
- * Extract all slugs from a tuple of resources.
- */
-type ExtractSlugs<TResources extends readonly any[]> = TResources extends readonly [infer Head, ...infer Tail] ? ExtractSlug<Head> | ExtractSlugs<Tail> : never;
-/**
- * The return type for a permission check on a resource.
- * - `boolean` — applies uniformly to all fields (true = all allowed, false = all denied)
- * - `{ mode: 'allow', fields: FieldKey[] }` — only listed fields are allowed; unlisted are denied
- * - `{ mode: 'deny', fields: FieldKey[] }` — listed fields are denied; unlisted are allowed
- */
-type FieldPermissionResult<TFieldKeys extends string> = boolean | {
-    mode: "allow";
-    fields: TFieldKeys[];
-} | {
-    mode: "deny";
-    fields: TFieldKeys[];
-};
-/**
- * A permission check can be a static value or a dynamic function.
- * Dynamic functions receive document data, user, and optional organization for
- * context-aware checks.
- *
- * @typeParam TFieldKeys - Union of field key strings for this resource
- * @typeParam TDocType - The document type for this resource
- * @typeParam TUser - The user type (inferred from user collection or explicit override)
- * @typeParam TOrg - The organization type (inferred from org collection, or never)
- */
-type PermissionCheck<TFieldKeys extends string, TDocType = Record<string, any>, TUser = Record<string, any>, TOrg = never> = FieldPermissionResult<TFieldKeys> | ((props: PermissionCallbackProps<TDocType, TUser, TOrg>) => FieldPermissionResult<TFieldKeys>);
-/**
- * Props passed to dynamic permission check callbacks.
- * When TOrg is `never`, the `organization` field is omitted entirely.
- */
-type PermissionCallbackProps<TDocType = Record<string, any>, TUser = Record<string, any>, TOrg = never> = [TOrg] extends [never] ? {
-    data: TDocType;
-    user: TUser;
-} : {
-    data: TDocType;
-    user: TUser;
-    organization: TOrg;
-};
-/** The four CRUD actions supported by the permission system. */
-type AccessAction = "create" | "read" | "update" | "delete";
-/**
- * Permission map for a single role on a single resource.
- * Each action is optional — missing actions default to permissive (all-true).
- */
-type ResourcePermissions<TFieldKeys extends string, TDocType = Record<string, any>, TUser = Record<string, any>, TOrg = never> = Partial<{
-    [Action in AccessAction]: PermissionCheck<TFieldKeys, TDocType, TUser, TOrg>;
-}>;
-/**
- * Build a permission entry for a single resource element.
- * Produces `{ [slug]?: boolean | ResourcePermissions<...> }`.
- */
-type SingleResourceEntry<R, TUser, TOrg> = R extends {
-    readonly slug: infer S extends string;
-} ? {
-    [K in S]?: boolean | ResourcePermissions<ExtractFieldKeys<R>, ExtractDocType<R>, TUser, TOrg>;
-} : {};
-/**
- * Recursively intersect per-resource permission entries from a tuple.
- * Builds `{ articles?: ... } & { posts?: ... } & { users?: ... }` etc.
- * TS eagerly resolves intersection members for LSP autocomplete.
- */
-type ResourcePermissionMap<TResources extends readonly any[], TUser, TOrg> = TResources extends readonly [infer Head, ...infer Tail] ? SingleResourceEntry<Head, TUser, TOrg> & ResourcePermissionMap<Tail, TUser, TOrg> : {};
-/**
- * Permission check for admin panel access.
- * - `boolean` — static allow/deny
- * - `(props) => boolean` — dynamic check based on user (and org if configured)
- *
- * Defaults to `false` if not specified for a role.
- */
-type AdminPermissionCheck<TUser = Record<string, any>, TOrg = never> = boolean | (([TOrg] extends [never] ? (props: {
-    user: TUser;
-}) => boolean : (props: {
-    user: TUser;
-    organization: TOrg;
-}) => boolean));
-type RolesWithPermissions<TRoles extends string, TResources extends readonly any[], TUser = Record<string, any>, TOrg = never> = {
-    [Role in TRoles]: ResourcePermissionMap<TResources, TUser, TOrg> & {
-        /** Whether this role can access the admin panel. Defaults to false if not specified. */
-        admin?: AdminPermissionCheck<TUser, TOrg>;
-    };
-};
-/**
- * Input shape for `defineAccess()` WITHOUT organization support.
- * Carries generics for full type inference of roles, resources, and field keys.
- */
-interface VexAccessInputBase<TRoles extends readonly string[], TResources extends readonly any[], TUserCollection extends VexCollection<any, any, any>, TUser> {
-    /** Array of role name strings. Use `as const` for literal type inference. */
-    roles: TRoles;
-    /**
-     * Roles that can access the admin panel and impersonate other users.
-     * Must be a subset of `roles`. Defaults to all roles if not specified.
-     */
-    adminRoles?: readonly (TRoles[number] & string)[];
-    /**
-     * The resources (collections, media collections, globals) that become entries
-     * in the permission matrix. When omitted, all collections and globals in the
-     * config are available — but type inference only works for explicitly listed resources.
-     */
-    resources?: TResources;
-    /**
-     * The user collection. Used to infer the user type for dynamic permission
-     * callbacks `({ data, user })`. Must be a collection created with `defineCollection`.
-     */
-    userCollection: TUserCollection;
-    /**
-     * Optional explicit user type override. When provided, this type is used
-     * for the `user` param in permission callbacks instead of inferring from
-     * the user collection's fields.
-     */
-    userType?: TUser;
-    /** The role-to-resource-to-action permission matrix. */
-    permissions: RolesWithPermissions<TRoles[number] & string, TResources, TUser extends undefined ? ExtractDocType<TUserCollection> : NonNullable<TUser>, never>;
-}
-/**
- * Input shape for `defineAccess()` WITH organization support.
- * Extends the base input with org collection and user org field.
- */
-interface VexAccessInputWithOrg<TRoles extends readonly string[], TResources extends readonly any[], TUserCollection extends VexCollection<any, any, any>, TUser, TOrgCollection extends VexCollection<any, any, any>, TOrg> {
-    roles: TRoles;
-    /**
-     * Roles that can access the admin panel and impersonate other users.
-     * Must be a subset of `roles`. Defaults to all roles if not specified.
-     */
-    adminRoles?: readonly (TRoles[number] & string)[];
-    resources?: TResources;
-    userCollection: TUserCollection;
-    userType?: TUser;
-    /**
-     * The organization collection. Used to infer the organization type for
-     * dynamic permission callbacks `({ data, user, organization })`.
-     */
-    orgCollection: TOrgCollection;
-    /**
-     * Optional explicit organization type override. When provided, this type is
-     * used for the `organization` param in callbacks instead of inferring from
-     * the org collection's fields.
-     */
-    orgType?: TOrg;
-    /**
-     * The field key on the user collection that relates to the organization collection.
-     * Used at runtime by callers to resolve the organization from the user object.
-     * Must be a field key on the user collection.
-     */
-    userOrgField: ExtractFieldKeys<TUserCollection>;
-    permissions: RolesWithPermissions<TRoles[number] & string, TResources, TUser extends undefined ? ExtractDocType<TUserCollection> : NonNullable<TUser>, TOrg extends undefined ? ExtractDocType<TOrgCollection> : NonNullable<TOrg>>;
-}
-/**
- * Union of both input shapes. TypeScript will narrow based on presence of `orgCollection`.
- */
-type VexAccessInput<TRoles extends readonly string[], TResources extends readonly any[], TUserCollection extends VexCollection<any, any, any>, TUser = undefined, TOrgCollection extends VexCollection<any, any, any> = never, TOrg = undefined> = [TOrgCollection] extends [never] ? VexAccessInputBase<TRoles, TResources, TUserCollection, TUser> : VexAccessInputWithOrg<TRoles, TResources, TUserCollection, TUser, TOrgCollection, TOrg>;
-/**
- * Resolved access config stored on `VexConfig.access`.
- * Type-erased version for storage in the config object.
- * Use `hasPermission()` for type-safe runtime access.
- */
-interface VexAccessConfig {
-    /** The role name strings. */
-    roles: readonly string[];
-    /** Roles that can access the admin panel and impersonate. */
-    adminRoles: readonly string[];
-    /** Slug of the user collection. */
-    userCollection: string;
-    /**
-     * Slug of the organization collection, if org support is enabled.
-     */
-    orgCollection?: string;
-    /**
-     * The field key on the user collection that relates to the org collection.
-     * Present only when orgCollection is set.
-     */
-    userOrgField?: string;
-    /**
-     * The permission matrix.
-     * Type-erased to `Record<string, ...>` for runtime consumption.
-     * Use `hasPermission()` for type-safe access.
-     */
-    permissions: Record<string, // role
-    Record<string, // resource slug
-    boolean | Partial<Record<AccessAction, PermissionCheck<string, any, any, any>>>> | undefined>;
-}
-
-/**
- * Responsive breakpoint configuration for block style controls.
- * Keys are breakpoint names (used as Tailwind prefixes), values are min-width in pixels.
- *
- * @example
- * ```ts
- * breakpoints: {
- *   sm: 640,
- *   md: 768,
- *   lg: 1024,
- *   xl: 1280,
- * }
- * ```
- */
-type BreakpointConfig = Record<string, number>;
-/** Resolved Vex CMS configuration */
-interface VexConfig {
-    /** Base URL path for the admin panel */
-    basePath: string;
-    /** Array of collection definitions */
-    collections: VexCollection[];
-    /** Array of global definitions */
-    globals: VexGlobal[];
-    /** Admin panel configuration */
-    admin: AdminConfig;
-    /** Auth adapter — required. Use `vexBetterAuth(authConfig)` to create. */
-    auth: VexAuthAdapter;
-    /** Schema generation config */
-    schema: SchemaConfig;
-    /** Media collection configuration */
-    media?: MediaConfig;
-    /** RBAC access permissions config. Optional — if not set, all actions are allowed. */
-    access?: VexAccessConfig;
-    /** Global rich text editor adapter. Used by all richtext fields unless overridden. */
-    editor?: VexEditorAdapter;
-    /** Responsive breakpoints for block style controls. If not set, styles apply to all viewports. */
-    breakpoints?: BreakpointConfig;
-}
-/**
- * Client-safe version of VexConfig with all non-serializable values stripped.
- * Use this when passing config across RSC serialization boundaries
- * (e.g., from a server component to a client component).
- *
- * Created via `sanitizeConfigForClient(config)`.
- */
-interface ClientVexConfig {
-    basePath: string;
-    collections: VexCollection[];
-    globals: VexGlobal[];
-    admin: AdminConfig;
-    auth: VexAuthAdapter;
-    schema: SchemaConfig;
-    media?: ClientMediaConfig;
-    /** Global rich text editor adapter. */
-    editor?: VexEditorAdapter;
-    /** Responsive breakpoints for block style controls. If not set, styles apply to all viewports. */
-    breakpoints?: BreakpointConfig;
-}
-/**
- * Input configuration for `defineConfig`. All fields are optional
- * and merged with defaults at runtime.
- */
-interface VexConfigInput {
-    /**
-     * Base URL path for the admin panel.
-     *
-     * Default: `"/admin"`
-     */
-    basePath?: string;
-    /**
-     * Array of collection definitions.
-     *
-     * Default: []
-     */
-    collections?: VexCollection[];
-    /**
-     * Array of global definitions.
-     *
-     * Default: []
-     */
-    globals?: VexGlobal<any>[];
-    /**
-     * Admin panel configuration.
-     */
-    admin?: AdminConfigInput;
-    /**
-     * Auth adapter — **required**. Pass `vexBetterAuth(authConfig)`.
-     * Vex requires auth configuration to generate the schema.
-     */
-    auth: VexAuthAdapter;
-    /**
-     * Schema generation configuration.
-     */
-    schema?: SchemaConfigInput;
-    /**
-     * Media collection configuration.
-     * Requires a storage adapter when collections are provided.
-     */
-    media?: MediaConfigInput;
-    /**
-     * RBAC access permissions configuration.
-     * Created with `defineAccess()` or defined inline.
-     *
-     * If not set, the admin panel allows all actions on all fields (permissive default).
-     */
-    access?: VexAccessConfig;
-    /**
-     * Global rich text editor adapter.
-     * Used as the default editor for all richtext fields.
-     * Pass `plateEditor()` from `@vexcms/richtext/editor`.
-     */
-    editor?: VexEditorAdapter;
-    /**
-     * Responsive breakpoints for block style controls.
-     * Keys are Tailwind prefix names, values are min-width in pixels.
-     * If not set, block styles apply to all viewports (no breakpoint tabs).
-     */
-    breakpoints?: BreakpointConfig;
-    /**
-     * Plugins to apply to the config. Each plugin is a function that receives
-     * the config input and returns a modified config input. Plugins run
-     * sequentially before the config is resolved.
-     *
-     * @example
-     * ```ts
-     * export default defineConfig({
-     *   plugins: [
-     *     seoPlugin({ collections: ["pages"] }),
-     *   ],
-     *   collections: [pages],
-     * })
-     * ```
-     */
-    plugins?: VexPlugin[];
-}
-/**
- * A Vex plugin is a function that transforms the config input.
- * Plugins receive the config (with all previous plugins applied)
- * and return a modified config. Use a curried function for options:
- *
- * @example
- * ```ts
- * export const myPlugin = (opts: MyOpts): VexPlugin =>
- *   (config) => ({
- *     ...config,
- *     collections: [...(config.collections ?? []), myCollection],
- *   })
- * ```
- */
-type VexPlugin = (config: VexConfigInput) => VexConfigInput;
-
-declare function defineConfig(vexConfig: VexConfigInput): VexConfig;
-
-/**
- * Creates a VexCollection with full LSP autocomplete on field names,
- * `admin.useAsTitle`, `admin.defaultColumns`, index fields, etc.
- *
- * When `auth` is provided, auth field keys (e.g. "email", "createdAt") are
- * also included in autocomplete for admin config and indexes.
- *
- * @example
- * ```ts
- * // Without auth — autocomplete for own fields
- * export const posts = defineCollection({
- *   slug: "posts",
- *   fields: {
- *     title: { type: "text", required: true },
- *     status: { type: "select", options: [...] },
- *   },
- *   admin: { useAsTitle: "title" }, // autocomplete: "title" | "status"
- * });
- *
- * // With auth — autocomplete for own fields + auth fields
- * export const users = defineCollection({
- *   slug: "users",
- *   auth,
- *   fields: {
- *     name: { type: "text", required: true },
- *     role: { type: "select", options: [...] },
- *   },
- *   admin: {
- *     useAsTitle: "name",                    // autocomplete: "name" | "role" | "email" | "createdAt" | ...
- *     defaultColumns: ["name", "email"],     // same autocomplete
- *   },
- * });
- * ```
- */
-declare function defineCollection<TFields extends Record<string, VexField>, TAuth extends VexAuthAdapter<any> | undefined = undefined, TSlug extends string = string>(props: {
-    readonly slug: TSlug;
-    fields: TFields;
-    auth?: TAuth;
-    tableName?: string;
-    labels?: {
-        singular?: string;
-        plural?: string;
-    };
-    admin?: CollectionAdminConfig<TFields, VersioningFieldKeys | (TAuth extends VexAuthAdapter<any> ? AuthCollectionFieldKeys<TAuth, TSlug> : never)>;
-    indexes?: IndexConfig<TFields, VersioningFieldKeys | (TAuth extends VexAuthAdapter<any> ? AuthCollectionFieldKeys<TAuth, TSlug> : never)>[];
-    searchIndexes?: SearchIndexConfig<TFields, VersioningFieldKeys | (TAuth extends VexAuthAdapter<any> ? AuthCollectionFieldKeys<TAuth, TSlug> : never)>[];
-    versions?: VersionsConfig;
-    interfaceName?: string;
-}): VexCollection<TFields, VersioningFieldKeys | (TAuth extends VexAuthAdapter<any> ? AuthCollectionFieldKeys<TAuth, TSlug> : never), TSlug>;
-/**
- * Creates a VexMediaCollection with full LSP autocomplete on field names
- * and `admin.useAsTitle`, `admin.defaultColumns`, etc.
- *
- * Default media fields (storageId, filename, mimeType, size, url, alt, width, height)
- * are injected automatically by `defineConfig()` — only define additional or
- * overridden fields here.
- *
- * @example
- * ```ts
- * export const media = defineMediaCollection({
- *   slug: "media",
- *   fields: {
- *     caption: { type: "text" },
- *   },
- *   admin: { useAsTitle: "filename" }, // autocomplete: "caption" | default media field keys
- * });
- * ```
- */
-declare function defineMediaCollection<TFields extends Record<string, VexField> = Record<never, VexField>, TSlug extends string = string>(props: {
-    readonly slug: TSlug;
-    fields?: TFields;
-    tableName?: string;
-    labels?: {
-        singular?: string;
-        plural?: string;
-    };
-    admin?: CollectionAdminConfig<TFields, DefaultMediaFieldKeys>;
-}): VexMediaCollection<TFields, TSlug>;
-
-/**
- * Creates a VexGlobal with full LSP autocomplete on field names
- * and `admin.useAsTitle`, etc.
- *
- * A global is a singleton document — only one document exists per global.
- * The admin panel shows it as a single editable form, not a list.
- *
- * @example
- * ```ts
- * export const siteSettings = defineGlobal({
- *   slug: "site_settings",
- *   label: "Site Settings",
- *   fields: {
- *     siteName: text({ label: "Site Name", required: true }),
- *     description: text({ label: "Description" }),
- *   },
- *   admin: { useAsTitle: "siteName" },
- *   versions: { drafts: true },
- * });
- * ```
- */
-declare function defineGlobal<TFields extends Record<string, VexField>, TSlug extends string = string>(props: {
-    readonly slug: TSlug;
-    fields: TFields;
-    label?: string;
-    tableName?: string;
-    admin?: GlobalAdminConfig<TFields>;
-    versions?: VersionsConfig;
-    interfaceName?: string;
-}): VexGlobal<TFields, TSlug>;
-
-/**
- * Define access permissions for the Vex CMS admin panel.
- *
- * This is a builder function (like `defineCollection`) that provides full
- * TypeScript inference for roles, resource slugs, field keys, user type,
- * and organization type.
- *
- * The function validates configuration in non-production and returns a
- * `VexAccessConfig` for passing to `defineConfig({ access: ... })`.
- *
- * @returns A `VexAccessConfig` for passing to `defineConfig({ access: ... })`.
- */
-declare function defineAccess<const TRoles extends readonly string[], const TResources extends readonly any[], const TUserCollection extends VexCollection<any, any, any>, TUser = undefined, const TOrgCollection extends VexCollection<any, any, any> = never, TOrg = undefined>(props: VexAccessInputWithOrg<TRoles, TResources, TUserCollection, TUser, TOrgCollection, TOrg>): VexAccessConfig;
-declare function defineAccess<const TRoles extends readonly string[], const TResources extends readonly any[], const TUserCollection extends VexCollection<any, any, any>, TUser = undefined>(props: VexAccessInputBase<TRoles, TResources, TUserCollection, TUser> & {
-    orgCollection?: never;
-    orgType?: never;
-    userOrgField?: never;
-}): VexAccessConfig;
-
-/**
- * The result of resolving field permissions for a resource action.
- * Maps each field key to whether the action is allowed on that field.
- */
-type ResolvedFieldPermissions = Record<string, boolean>;
-/**
- * Check permissions for a user on a resource action.
- *
- * Without `fields` param → returns `boolean` (overall action access)
- * With `fields` param → returns `Record<string, boolean>` for those specific fields
- *
- * @param props.access - The VexAccessConfig from defineAccess
- * @param props.user - The user object
- * @param props.userRoles - The user's role(s) as a string array
- * @param props.resource - The resource slug (collection or global slug)
- * @param props.action - The CRUD action to check
- * @param props.data - Document data for dynamic permission checks. Defaults to `{}`.
- * @param props.organization - Optional organization object for org-aware permission checks.
- * @param props.fields - Specific fields to check. When provided, returns Record<string, boolean>.
- * @param props.throwOnDenied - When true, throws VexAccessError instead of returning false. Default: false.
- * @returns `boolean` when fields is omitted, `Record<string, boolean>` when fields is provided
- * @throws {VexAccessError} When `throwOnDenied` is true and access is denied
- */
-declare function hasPermission(props: {
-    access: VexAccessConfig | undefined;
-    user: Record<string, any>;
-    userRoles: string[];
-    resource: string;
-    action: AccessAction;
-    data?: Record<string, any>;
-    organization?: Record<string, any>;
-    fields?: string[];
-    throwOnDenied?: boolean;
-}): ResolvedFieldPermissions | boolean;
-
-/**
- * Check whether a user has access to the admin panel.
- *
- * Evaluates the `admin` permission on each of the user's roles.
- * If any role has `admin: true` (or a callback that returns true),
- * the user is granted access. Returns false if no role grants access
- * or if the access config is not defined.
- *
- * @param props.access - The VexAccessConfig from defineAccess
- * @param props.user - The user object (passed to dynamic permission callbacks)
- * @param props.userRoles - The user's role(s) as a string array
- * @param props.organization - Optional organization object (passed to callbacks if org support is configured)
- * @returns Whether the user can access the admin panel
- */
-declare function checkAdminAccess(props: {
-    access: VexAccessConfig | undefined;
-    user: Record<string, any>;
-    userRoles: string[];
-    organization?: Record<string, any>;
-}): boolean;
-
-/**
- * Framework-agnostic site metadata object.
- * Consumers (Next.js, TanStack Start, etc.) map this to their framework's metadata format.
- */
-interface SiteMetadata {
-    title: string;
-    description: string;
-    ogImage?: string;
-    twitterHandle?: string;
-}
-/**
- * Build site metadata by merging site-wide defaults with per-page overrides.
- *
- * Resolution order (per-page wins over site-wide):
- * - title: page.metaTitle → page.title → site.metaTitle → site.name → "Untitled"
- * - description: page.metaDescription → site.metaDescription → site.description → ""
- * - ogImage: page.ogImage → site.ogImage → undefined
- * - twitterHandle: site.twitterHandle → undefined
- *
- * @param props.site - Site settings fields (from globals)
- * @param props.page - Optional per-page overrides
- * @param props.titleSuffix - Optional suffix appended to title (e.g. " | My Site")
- * @returns Framework-agnostic metadata object
- */
-declare function buildSiteMetadata(props: {
-    site: {
-        name?: string;
-        metaTitle?: string;
-        metaDescription?: string;
-        description?: string;
-        ogImage?: string;
-        twitterHandle?: string;
-    };
-    page?: {
-        title?: string;
-        metaTitle?: string;
-        metaDescription?: string;
-        ogImage?: string;
-    };
-    titleSuffix?: string;
-}): SiteMetadata;
-
-/**
- * Strip non-serializable values from VexConfig for safe passage across
- * RSC / JSON serialization boundaries (e.g., server layout → client component).
- *
- * Currently strips:
- * - `media.storageAdapter` (contains async functions — only needed at CLI / schema-gen time)
- * - `admin.livePreview.url` function values on collections (replaced with `null`)
- *
- * This function is the single place to extend when new non-serializable
- * properties are added to VexConfig in the future.
- */
-declare function sanitizeConfigForClient(config: VexConfig): ClientVexConfig;
-/**
- * Extracts a map of collection slug → original livePreview URL function for collections
- * that have function-based preview URLs. Pass this to admin components so they
- * can resolve preview URLs at runtime on the client.
- *
- * @returns Map of collection slug → { url } (only entries with function URLs)
- */
-declare function extractLivePreviewConfigs(config: VexConfig): Record<string, {
-    url: (doc: {
-        _id: string;
-        [key: string]: any;
-    }) => string;
-}>;
-
-interface HasSlug {
-    readonly slug: string;
-}
-interface ConfigWithMedia {
-    media?: {
-        collections: HasSlug[];
-    };
-}
-/**
- * Check whether a collection is a media collection.
- *
- * Compares the collection's slug against the slugs in `config.media.collections`.
- * Works with both `VexConfig` and `ClientVexConfig` (both have the `media?.collections` shape).
- *
- * @param props.collection - The collection to check
- * @param props.config - The Vex config (or client config) containing media configuration
- * @returns true if the collection's slug matches a media collection slug
- */
-declare function isMediaCollection(props: {
-    collection: HasSlug;
-    config: ConfigWithMedia;
-}): boolean;
-
-interface HasSlugAndFields {
-    readonly slug: string;
-    fields: Record<string, VexField>;
-}
-interface ConfigShape {
-    collections: HasSlugAndFields[];
-    globals: HasSlugAndFields[];
-    media?: {
-        collections: HasSlugAndFields[];
-    };
-}
-type CollectionKind = "collection" | "media" | "global";
-interface ResolvedCollectionMatch {
-    slug: string;
-    fields: Record<string, VexField>;
-    kind: CollectionKind;
-}
-/**
- * Get all collections, media collections, and globals as a flat array.
- *
- * Each entry includes the `kind` discriminator so callers can switch on it.
- *
- * @param props.config - The resolved Vex config
- * @param props.excludeGlobals - Skip globals (default: false)
- */
-declare function getAllCollections(props: {
-    config: ConfigShape;
-    excludeGlobals?: boolean;
-}): ResolvedCollectionMatch[];
-/**
- * Find a collection, media collection, or global by slug across the entire config.
- *
- * Searches in order: collections → media collections → globals.
- * Returns the match with its fields and what kind it is, or null if not found.
- *
- * @param props.slug - The slug to search for
- * @param props.config - The resolved Vex config
- * @param props.excludeGlobals - Skip globals when searching (default: false)
- */
-declare function findCollectionBySlug(props: {
-    slug: string;
-    config: ConfigShape;
-    excludeGlobals?: boolean;
-}): ResolvedCollectionMatch | null;
-
-/**
- * Generates the full TypeScript source content for `convex/vex.schema.ts`.
- *
- * This is the main entry point for schema generation. It:
- * 1. Validates all slugs are unique (via SlugRegistry)
- * 2. For each auth collection, checks if a matching user collection exists (by slug):
- *    a. If yes: merges auth collection fields with user collection fields
- *    b. If no matching collection: generates the auth collection as-is
- * 3. User collections that don't match any auth collection: generates from collection fields only
- * 4. Collects indexes from per-field `index` properties and collection-level `indexes`
- * 5. Generates defineTable() calls for each table with chained .index() calls
- * 6. Generates defineTable() calls for system tables (vex_globals if globals exist)
- *
- * All fields go through fieldToValueType() uniformly — no dual path for auth vs user.
- */
-declare function generateVexSchema(props: {
-    config: VexConfig;
-}): string;
-
-type ExtractFields<T> = T extends TableDefinition<VObject<any, infer F>> ? F : never;
-type ForbidExistingKeys<Existing, New> = {
-    [K in keyof New]: K extends keyof Existing ? never : New[K];
-};
-/**
- * Compute the TableDefinition type that preserves field types.
- * Matches the second overload of defineTable:
- *   defineTable(fields) → TableDefinition<VObject<ObjectType<Fields>, Fields>>
- */
-type ExtendedTableDef<Fields extends Record<string, GenericValidator>> = TableDefinition<VObject<ObjectType<Fields>, Fields>>;
-/**
- * Extends a vex-generated table definition with additional fields,
- * preserving all indexes from the original table.
- *
- * Use this in your `convex/schema.ts` when you need to add custom
- * fields to a vex-managed table (e.g., adding a `body` field to posts).
- *
- * @param props.table - The table definition from vex.schema.ts
- * @param props.additionalFields - Additional Convex validator fields to add.
- *   Keys that already exist on the table will cause a type error.
- * @returns A new TableDefinition with merged fields and original indexes.
- *          You can chain additional `.index()` calls on the result.
- *
- * @example
- * ```ts
- * import { posts } from "./vex.schema";
- * import { extendTable } from "@vexcms/core";
- * import { v } from "convex/values";
- *
- * export default defineSchema({
- *   posts: extendTable({
- *     table: posts,
- *     additionalFields: { body: v.optional(v.string()) },
- *   }).index("by_status", ["status"]),
- * });
- * ```
- */
-declare function extendTable<T extends TableDefinition<VObject<any, any>>, A extends Record<string, GenericValidator> = {}>(props: {
-    table: T;
-    additionalFields?: A & ForbidExistingKeys<ExtractFields<T>, A>;
-}): ExtendedTableDef<ExtractFields<T> & A>;
-
-/**
- * Generates an array of ColumnDef objects from a VexCollection's field configs.
- *
- * @param props.collection - The collection to generate columns for
- * @param props.auth - Optional auth adapter. When provided, auth fields (e.g. createdAt)
- *   get proper columnDef dispatch instead of falling back to plain text columns.
- * @returns Array of ColumnDef objects for use with @tanstack/react-table
- */
-declare function generateColumns(props: {
-    collection: VexCollection;
-    auth?: VexAuthAdapter;
-}): ColumnDef<Record<string, unknown>>[];
-
-/**
- * Result of merging an auth collection with a user collection.
- * Contains merged VexFields and metadata about field sources.
- */
-interface MergedCollectionResult {
-    /**
-     * The final merged field map.
-     * Key is field name, value is the VexField object.
-     * Auth fields win for schema generation; user admin config is preserved.
-     */
-    fields: Record<string, VexField>;
-    /** Indexes from both auth and user collections (deduplicated by name). */
-    indexes: ResolvedIndex[];
-    /** Search indexes from the user collection. */
-    searchIndexes: ResolvedSearchIndex[];
-    /**
-     * Fields that exist in both auth collection and user config.
-     * The auth VexField wins for schema gen; user admin config wins for UI.
-     */
-    overlapping: string[];
-    /** Fields that only exist in the auth collection (not in user's collection). */
-    authOnly: string[];
-    /** Fields that only exist in the user's collection (not from auth). */
-    userOnly: string[];
-}
-/**
- * Merges an auth collection's fields with a user-defined collection's fields.
- *
- * Both sides are VexField records. For overlapping fields, the auth
- * VexField's schema properties are used (it controls the DB shape), but
- * the user's admin config (label, hidden, etc.) is preserved by copying
- * admin-related metadata from the user's field onto the auth field.
- *
- * @param authCollection - The auth collection with fully resolved fields
- * @param userCollection - The user's collection that matches this auth table by slug
- * @returns Merged collection result with combined fields and source tracking
- */
-declare function mergeAuthCollectionWithUserCollection(props: {
-    authCollection: VexCollection;
-    userCollection: VexCollection;
-}): MergedCollectionResult;
-
-declare function toTitleCase(input: string): string;
-
-/**
- * Generate a Zod schema from a collection's field definitions.
- * Used by both the client-side form (for validation on submit)
- * and the server-side mutation (for payload validation).
- *
- * @param props.fields - Record of field name → VexField from the collection
- * @returns A z.object() schema matching the collection's editable fields
- */
-declare function generateFormSchema(props: {
-    fields: Record<string, VexField>;
-}): z.ZodObject<Record<string, ZodTypeAny>>;
-/**
- * Convert a single field to its Zod validator.
- * Does NOT handle optional wrapping — that's done by the caller.
- *
- * @param props.field - The field definition (discriminated on `type`)
- * @returns The base Zod type for this field (always required)
- */
-declare function fieldMetaToZod(props: {
-    field: VexField;
-}): ZodTypeAny;
-
-/**
- * Generate default values for a create form from a collection's field definitions.
- * Skips hidden fields.
- *
- * @param props.fields - Record of field name -> VexField from the collection
- * @returns Record of field name -> default value for the create form
- */
-declare function generateFormDefaultValues(props: {
-    fields: Record<string, VexField>;
-}): Record<string, unknown>;
-
-declare function text(options?: Omit<TextFieldDef, "type">): TextFieldDef;
-
-declare function number(options?: Omit<NumberFieldDef, "type">): NumberFieldDef;
-
-declare function checkbox(options?: Omit<CheckboxFieldDef, "type">): CheckboxFieldDef;
-
-declare function select<T extends string = string>(options: Omit<SelectFieldMany<T>, "type">): SelectFieldDef<T>;
-declare function select<T extends string = string>(options: Omit<SelectFieldSingle<T>, "type">): SelectFieldDef<T>;
-
-declare function date(options?: Omit<DateFieldDef, "type">): DateFieldDef;
-
-declare function imageUrl(options?: Omit<ImageUrlFieldDef, "type">): ImageUrlFieldDef;
-
-declare function relationship(options: Omit<RelationshipFieldMany, "type">): RelationshipFieldDef;
-declare function relationship(options: Omit<RelationshipFieldSingle, "type">): RelationshipFieldDef;
-
-declare function upload(options: Omit<UploadFieldMany, "type">): UploadFieldDef;
-declare function upload(options: Omit<UploadFieldSingle, "type">): UploadFieldDef;
-
-declare function json(options?: Omit<JsonFieldDef, "type">): JsonFieldDef;
-
-declare function object(options: Omit<ObjectFieldDef, "type">): ObjectFieldDef;
-
-declare function array(options: Omit<ArrayFieldDef, "type">): ArrayFieldDef;
-
-/**
- * Creates a rich text field definition.
- * Stores Plate/Slate JSON document as `v.any()` in Convex.
- *
- * @param options.label - Display label in admin form
- * @param options.required - Whether this field is required
- * @param options.editor - Per-field editor adapter override
- * @returns A RichTextFieldDef
- *
- * @example
- * ```ts
- * content: richtext({ label: "Content", required: true })
- * ```
- */
-declare function richtext(options?: Omit<RichTextFieldDef, "type">): RichTextFieldDef;
-
-/**
- * Creates a UI field — a non-persisted field that renders a custom component.
- * UI fields are skipped during schema generation, form validation, and column generation.
- * They are useful for computed displays, action buttons, and embedded widgets.
- *
- * @param props.label - Display label for the field
- * @param props.admin - Admin config. components.Field is required.
- * @param props.description - Helper text displayed below the field
- * @returns A UIFieldDef
- *
- * @example
- * ```ts
- * import { ui } from "@vexcms/core";
- * import WordCount from "~/components/admin/WordCount";
- *
- * const collection = defineCollection({
- *   slug: "posts",
- *   fields: {
- *     wordCount: ui({
- *       label: "Word Count",
- *       admin: {
- *         components: { Field: WordCount },
- *         position: "sidebar",
- *       },
- *     }),
- *   },
- * });
- * ```
- */
-declare function ui(props: {
-    label?: string;
-    admin: FieldAdminConfig & {
-        components: {
-            Field: ComponentType<FieldComponentProps>;
-        };
-    };
-    description?: string;
-}): UIFieldDef;
-
-/**
- * Create a blocks field that stores an ordered array of block instances.
- *
- * @param props.blocks - Array of BlockDef objects allowed in this field
- * @param props.labels - Optional singular/plural display labels
- * @param props.min - Minimum number of blocks
- * @param props.max - Maximum number of blocks
- * @returns A BlocksFieldDef
- *
- * @throws VexBlockValidationError if two blocks share the same slug
- *
- * @example
- * ```ts
- * content: blocks({
- *   blocks: [heroBlock, ctaBlock, featureGridBlock],
- * })
- * ```
- */
-declare function blocks(props: {
-    blocks: BlockDef[];
-    labels?: BlocksFieldDef["labels"];
-    min?: number;
-    max?: number;
-    label?: string;
-    description?: string;
-    required?: boolean;
-    admin?: BlocksFieldDef["admin"];
-}): BlocksFieldDef;
-
-/**
- * Creates a color field definition.
- *
- * @param props - Color field configuration
- * @param props.label - Display label in admin panel
- * @param props.format - Output format: "hex" (default), "hsl", or "oklch"
- * @param props.themeColors - When true, shows theme CSS variable picker tab
- * @returns ColorFieldDef
- */
-declare function color(props?: Omit<ColorFieldDef, "type">): ColorFieldDef;
-
-/**
- * Creates a tabs field definition.
- * Groups fields into tabbed UI sections in the admin panel.
- *
- * Tabs with `slug` create nested objects in the document.
- * Tabs without `slug` flatten their fields onto the parent.
- *
- * @param props - Tabs field configuration
- * @param props.tabs - Array of tab definitions with label, optional slug, and fields
- * @returns TabsFieldDef with preserved tab slug and field type information
- */
-declare function tabs<const TTabs extends TabDef[]>(props: Omit<TabsFieldDef<TTabs>, "type">): TabsFieldDef<TTabs>;
-
-/**
- * Define a block type for use with the `blocks()` field.
- *
- * @param props.slug - Unique identifier for this block type
- * @param props.label - Display label for the admin picker
- * @param props.fields - Field definitions for this block's data shape
- * @param props.admin - Optional admin UI configuration (icon, custom components)
- * @returns A BlockDef object
- *
- * @throws VexBlockValidationError if slug is empty or contains invalid characters
- * @throws VexBlockValidationError if any field name is reserved (blockType, _key)
- *
- * @example
- * ```ts
- * const heroBlock = defineBlock({
- *   slug: "hero",
- *   label: "Hero Section",
- *   fields: {
- *     heading: text({ required: true }),
- *     subheading: text(),
- *   },
- * })
- * ```
- */
-declare function defineBlock<TFields extends Record<string, VexField>>(props: {
-    slug: string;
-    label: string;
-    fields: TFields;
-    admin?: BlockDef["admin"];
-    interfaceName?: string;
-}): BlockDef<TFields>;
-
-interface StylePreset {
-    /** Tailwind scale value (stored in blockStyles JSON). */
-    value: string;
-    /** Display label in the popover. */
-    label: string;
-    /** Size hint shown next to the label (e.g., "16px / 1rem"). */
-    hint: string;
-}
-declare const SPACING_PRESETS: StylePreset[];
-declare const FONT_SIZE_PRESETS: StylePreset[];
-declare const FONT_WEIGHT_PRESETS: StylePreset[];
-declare const BORDER_RADIUS_PRESETS: StylePreset[];
-declare const BOX_SHADOW_PRESETS: StylePreset[];
-declare const OPACITY_PRESETS: StylePreset[];
-declare const WIDTH_PRESETS: StylePreset[];
-declare const MAX_WIDTH_PRESETS: StylePreset[];
-declare const LINE_HEIGHT_PRESETS: StylePreset[];
-declare const LETTER_SPACING_PRESETS: StylePreset[];
-declare const BORDER_WIDTH_PRESETS: StylePreset[];
-declare const ASPECT_RATIO_PRESETS: StylePreset[];
-
-/**
- * Convert a blockStyles JSON string into a Tailwind class string.
- *
- * Handles responsive breakpoint prefixes. The "base" breakpoint has no prefix,
- * all other breakpoints use their key as prefix (e.g., "sm:", "md:", "lg:").
- *
- * @param props.blockStylesJson - The raw JSON string from the block instance's blockStyles field
- * @returns Tailwind class string ready to use in className, or empty string if input is empty/invalid
- *
- * @example
- * ```ts
- * blockStylesToTailwind({
- *   blockStylesJson: '{"base":{"margin":"4","padding":"2"},"sm":{"margin":"6"}}'
- * })
- * // → "m-4 p-2 sm:m-6"
- * ```
- */
-declare function blockStylesToTailwind(props: {
-    blockStylesJson: string | undefined;
-}): string;
-
-/**
- * Generate the complete TypeScript source for `vex.types.ts`.
- *
- * @param props.config - The resolved VexConfig
- * @returns TypeScript source code string
- */
-declare function generateVexTypes(props: {
-    config: VexConfig;
-}): string;
-
-/**
- * Convert a slug string to a PascalCase interface name.
- *
- * @param props.slug - The slug to convert (e.g., "blog-posts", "new_block", "media")
- * @returns PascalCase string (e.g., "BlogPosts", "NewBlock", "Media")
- */
-declare function slugToInterfaceName(props: {
-    slug: string;
-}): string;
-
-/**
- * Extracts user-defined fields from a document, stripping all
- * system fields (_id, _creationTime, _status, _version, _publishedAt).
- *
- * Used to create version snapshots that contain only content fields.
- *
- * @param props.document - The full document including system fields
- * @returns A new object with only user-defined fields
- */
-declare function extractUserFields(props: {
-    document: Record<string, unknown>;
-}): Record<string, unknown>;
-
-/**
- * System field names injected into versioned collection schemas.
- * These are excluded from user-editable fields and version snapshots.
- */
-declare const VERSION_SYSTEM_FIELDS: readonly ["vex_status", "vex_version", "vex_publishedAt"];
-/**
- * All system fields (Convex built-in + versioning) to strip when
- * extracting user content from a document.
- */
-declare const ALL_SYSTEM_FIELDS: Set<string>;
-/**
- * Default max versions to keep per document.
- */
-declare const DEFAULT_MAX_VERSIONS_PER_DOC = 100;
-/**
- * Default autosave interval in milliseconds.
- */
-declare const DEFAULT_AUTOSAVE_INTERVAL = 2000;
-
-/**
- * Resolves the preview URL from a collection's live preview config.
- *
- * @param props.config - The collection's livePreview config
- * @param props.doc - The current document data (must include `_id`)
- * @param props.fallbackURL - URL to return if the function throws
- * @returns The resolved preview URL
- * @throws If the resolved URL is empty and no fallbackURL is provided
- */
-declare function resolvePreviewURL(props: {
-    config: LivePreviewConfig;
-    doc: {
-        _id: string;
-        [key: string]: any;
-    };
-    fallbackURL?: string;
-}): string;
-
-/**
- * Determines if the preview iframe URL should be recomputed.
- *
- * @param props.config - The collection's livePreview config
- * @param props.changedFields - Set of field names that changed in the save
- * @returns true if the URL should be recomputed
- */
-declare function shouldReloadURL(props: {
-    config: LivePreviewConfig;
-    changedFields: string[];
-}): boolean;
-
-declare const DEFAULT_BREAKPOINTS: LivePreviewBreakpoint[];
-/**
- * Debounce interval for writing preview snapshots on form changes.
- */
-declare const PREVIEW_SNAPSHOT_DEBOUNCE_MS = 500;
-
-/**
- * Upserts a preview snapshot for a document.
- * If a snapshot already exists for this collection+document, it is updated in place.
- * If not, a new entry is created.
- *
- * @param props.ctx - Convex mutation context
- * @param props.collection - Collection slug
- * @param props.documentId - Document ID
- * @param props.snapshot - Complete field snapshot from the form
- */
-declare function upsertPreviewSnapshot<DataModel extends GenericDataModel>(props: {
-    ctx: GenericMutationCtx<DataModel>;
-    collection: string;
-    documentId: string;
-    snapshot: Record<string, unknown>;
-}): Promise<void>;
-/**
- * Deletes the preview snapshot for a document.
- * Called after a successful save to clean up transient state.
- *
- * @param props.ctx - Convex mutation context
- * @param props.collection - Collection slug
- * @param props.documentId - Document ID
- */
-declare function deletePreviewSnapshot<DataModel extends GenericDataModel>(props: {
-    ctx: GenericMutationCtx<DataModel>;
-    collection: string;
-    documentId: string;
-}): Promise<void>;
-/**
- * Gets the preview data for a document.
- *
- * Lookup order:
- * 1. Preview snapshot (transient, written by admin form on each change)
- * 2. Latest version from vex_versions (draft or published, excluding autosave/previewSnapshot)
- * 3. null (fall back to main document)
- *
- * @param props.ctx - Convex query context
- * @param props.collection - Collection slug
- * @param props.documentId - Document ID
- * @returns The snapshot data, or null if no preview/version exists
- */
-declare function getPreviewSnapshot<DataModel extends GenericDataModel>(props: {
-    ctx: GenericQueryCtx<DataModel>;
-    collection: string;
-    documentId: string;
-}): Promise<Record<string, unknown> | null>;
-
-/**
- * Drafts mode for vexQuery.
- * - "snapshot": Fetch the transient preview snapshot (written by admin on form changes)
- * - true: Fetch the latest draft version (from versioning system)
- * - false: Fetch published content only
- */
-type VexDraftsMode = "snapshot" | boolean;
-/**
- * Context passed to vexQuery handlers.
- * Extends the standard Convex QueryCtx with draft-awareness.
- */
-interface VexQueryCtx<DataModel extends GenericDataModel = GenericDataModel> extends GenericQueryCtx<DataModel> {
-    /**
-     * The resolved drafts mode.
-     * - "snapshot": caller wants preview snapshot data
-     * - true: caller wants latest draft version
-     * - false: caller wants published content only
-     *
-     * Defaults to "snapshot" when not explicitly passed by the caller.
-     */
-    drafts: VexDraftsMode;
-}
-/**
- * Create a typed vexQuery builder from your project's query builder.
- *
- * Call this once in your project to get a `vexQuery` function that
- * preserves full return type inference from your DataModel.
- *
- * @example
- * ```ts
- * // convex/vex/helpers.ts
- * import { createVexQuery } from "@vexcms/core";
- * import { query } from "../_generated/server";
- *
- * export const vexQuery = createVexQuery(query);
- * ```
- *
- * Then use it in your query files:
- * ```ts
- * // convex/pages.ts
- * import { vexQuery } from "./vex/helpers";
- * import { getPreviewSnapshot } from "@vexcms/core";
- *
- * export const getBySlug = vexQuery({
- *   args: { slug: v.string() },
- *   handler: async (ctx, args) => {
- *     const page = await ctx.db
- *       .query("pages")
- *       .withIndex("by_slug", (q) => q.eq("slug", args.slug))
- *       .first();
- *     if (!page) return null;
- *     if (ctx.drafts === "snapshot") {
- *       const snapshot = await getPreviewSnapshot({ ctx, collection: "pages", documentId: page._id });
- *       if (snapshot) return { ...page, ...snapshot };
- *     }
- *     return page;
- *   },
- * });
- * ```
- */
-declare function createVexQuery<DataModel extends GenericDataModel>(_queryBuilder: QueryBuilder<DataModel, "public">): <Args extends PropertyValidators, Output>(props: {
-    args: Args;
-    handler: (ctx: VexQueryCtx<DataModel>, args: ObjectType<Args>) => Output | Promise<Output>;
-}) => RegisteredQuery<"public", ObjectType<Args & {
-    _vexDrafts: typeof v.optional<any>;
-}>, Awaited<Output>>;
-/**
- * Generic vexQuery for use without project-specific types.
- * Prefer `createVexQuery(query)` for full type inference.
- *
- * @deprecated Use `createVexQuery(query)` instead for proper return type inference.
- */
-declare function vexQuery<Args extends PropertyValidators, Output>(props: {
-    args: Args;
-    handler: (ctx: VexQueryCtx, args: ObjectType<Args>) => Output | Promise<Output>;
-}): RegisteredQuery<"public", ObjectType<Args & {
-    _vexDrafts: typeof v.optional<any>;
-}>, Awaited<Output>>;
-
-declare function listDocuments<DataModel extends GenericDataModel>(props: {
-    args: {
-        collectionSlug: TableNamesInDataModel<DataModel>;
-        paginationOpts: PaginationOptions;
-        order?: "asc" | "desc";
-    };
-    ctx: GenericQueryCtx<DataModel>;
-}): Promise<{
-    page: any[];
-    isDone: boolean;
-    continueCursor: convex_server.Cursor;
-    splitCursor?: convex_server.Cursor | null;
-    pageStatus?: "SplitRecommended" | "SplitRequired" | null;
-}>;
-declare function getDocument<DataModel extends GenericDataModel>(props: {
-    ctx: GenericQueryCtx<DataModel>;
-    args: {
-        collectionSlug: TableNamesInDataModel<DataModel>;
-        documentId: string;
-        /** When true, merges the transient preview snapshot (from admin live preview) */
-        preview?: boolean;
-    };
-}): Promise<any>;
-declare function updateDocument<DataModel extends GenericDataModel>(props: {
-    ctx: GenericMutationCtx<DataModel>;
-    args: {
-        collectionSlug: TableNamesInDataModel<DataModel>;
-        documentId: string;
-        fields: Record<string, unknown>;
-        collectionFields: Record<string, VexField>;
-    };
-}): Promise<string>;
-declare function createDocument<DataModel extends GenericDataModel>(props: {
-    ctx: GenericMutationCtx<DataModel>;
-    args: {
-        collectionSlug: TableNamesInDataModel<DataModel>;
-        fields: Record<string, unknown>;
-        collectionFields: Record<string, VexField>;
-        kind: CollectionKind;
-    };
-}): Promise<string>;
-declare function deleteDocument<DataModel extends GenericDataModel>(props: {
-    ctx: GenericMutationCtx<DataModel>;
-    args: {
-        collectionSlug: TableNamesInDataModel<DataModel>;
-        documentId: string;
-        kind: CollectionKind;
-    };
-}): Promise<void>;
-declare function searchDocuments<DataModel extends GenericDataModel>(props: {
-    args: {
-        collectionSlug: TableNamesInDataModel<DataModel>;
-        searchIndexName: string;
-        searchField: string;
-        query: string;
-    };
-    ctx: GenericQueryCtx<DataModel>;
-}): Promise<any[]>;
-
-/** Sentinel string placed at the top of every generated file. */
-declare const GENERATED_HEADER = "// \u26A0\uFE0F AUTO-GENERATED BY VEX CMS \u2014 DO NOT EDIT \u26A0\uFE0F";
-/**
- * Relative import paths used inside generated files.
- * Computed by the CLI from cwd + convexDir; passed in so this function
- * stays pure and testable.
- */
-interface CollectionQueryImports {
-    /** Import path for vex.config.ts from api/ dir. e.g. `"../../../vex.config"` */
-    vexConfigFromApi: string;
-    /** Import path for _generated/ from api/ dir. e.g. `"../../_generated"` */
-    generatedDirFromApi: string;
-    /** Import path for the user's auth helper from api/ dir. e.g. `"../auth"` */
-    authFromApi: string;
-    /** Import path for _generated/ from model/api/ dir. e.g. `"../../../_generated"` */
-    generatedDirFromModel: string;
-}
-/**
- * Result of generating all collection files.
- * Keys are relative paths from the vex/ directory.
- * e.g. `"api/articles.ts"`, `"model/api/articles.ts"`, `"api/index.ts"`
- */
-type GeneratedFiles = Record<string, string>;
-/**
- * Generate typed Convex query/mutation files for all collections in `config`.
- *
- * Produces two files per collection:
- * - `model/api/{slug}.ts` — typed model functions (DB logic)
- * - `api/{slug}.ts` — Convex query/mutation exports (auth + RBAC + calls model)
- * Plus a barrel `api/index.ts`.
- */
-declare function generateCollectionQueries(props: {
-    config: VexConfig;
-    imports: CollectionQueryImports;
-}): GeneratedFiles;
-/**
- * Generate the barrel `index.ts` that namespace-re-exports all collection files.
- */
-declare function generateIndexFile(props: {
-    slugs: string[];
-}): string;
-
-/**
- * Base error class for all Vex CMS errors.
- * Provides consistent error formatting with a [vex] prefix.
- */
-declare class VexError extends Error {
-    constructor(message: string);
-}
-/**
- * Thrown when a duplicate table slug is detected during schema generation.
- * Includes both registrations so the user can identify the conflict.
- */
-declare class VexSlugConflictError extends VexError {
-    readonly slug: string;
-    readonly existingSource: string;
-    readonly existingLocation: string;
-    readonly newSource: string;
-    readonly newLocation: string;
-    constructor(slug: string, existingSource: string, existingLocation: string, newSource: string, newLocation: string);
-}
-/**
- * Thrown when a field fails validation during schema generation.
- * For example: required field with no defaultValue, or wrong defaultValue type.
- */
-declare class VexFieldValidationError extends VexError {
-    readonly collectionSlug: string;
-    readonly fieldName: string;
-    readonly detail: string;
-    constructor(collectionSlug: string, fieldName: string, detail: string);
-}
-/**
- * Thrown when auth configuration is invalid.
- * For example: userCollection not found in collections.
- */
-declare class VexAuthConfigError extends VexError {
-    constructor(detail: string);
-}
-/**
- * Thrown when media configuration is invalid.
- */
-declare class VexMediaConfigError extends VexError {
-    constructor(detail: string);
-}
-/**
- * Thrown when access configuration is invalid.
- * For example: orgCollection provided without userOrgField.
- */
-declare class VexAccessConfigError extends VexError {
-    constructor(detail: string);
-}
-/**
- * Thrown by `hasPermission` when `throwOnDenied` is true and the user
- * does not have permission for the requested action.
- *
- * Contains structured context about the denied access attempt so callers
- * can log, surface to users, or handle programmatically.
- */
-declare class VexAccessError extends VexError {
-    readonly resource: string;
-    readonly action: string;
-    readonly field?: string | undefined;
-    constructor(resource: string, action: string, field?: string | undefined);
-}
-/**
- * Thrown when a block definition is invalid.
- * For example: reserved field name used, duplicate block slug.
- */
-declare class VexBlockValidationError extends VexError {
-    readonly blockSlug: string;
-    readonly detail: string;
-    constructor(blockSlug: string, detail: string);
-}
-
-interface SchemaFieldInfo {
-    /** Table name (export const name). */
-    table: string;
-    /** Field name within the table. */
-    field: string;
-    /** Full value type string, e.g. "v.string()" or "v.optional(v.string())". */
-    valueType: string;
-    /** Whether the field is wrapped in v.optional(...). */
-    isOptional: boolean;
-}
-interface RemovedFieldInfo {
-    /** Table name (export const name). */
-    table: string;
-    /** Field name that was removed. */
-    field: string;
-    /** The old value type string, e.g. "v.string()". */
-    valueType: string;
-    /** Whether the field was optional in the old schema. */
-    wasOptional: boolean;
-}
-interface SchemaDiff {
-    /** Fields that changed from optional → required (need backfill). */
-    newRequired: SchemaFieldInfo[];
-    /** Fields that are entirely new and required (need backfill). */
-    addedRequired: SchemaFieldInfo[];
-    /** Fields that are entirely new and optional (may need backfill if they have a defaultValue). */
-    addedOptional: SchemaFieldInfo[];
-    /** Fields that existed in old schema but are absent in new schema. */
-    removedFields: RemovedFieldInfo[];
-    /** All fields that need migration. */
-    needsMigration: SchemaFieldInfo[];
-}
-/**
- * Compare two generated schema strings and return fields that need migration.
- *
- * A field needs migration when:
- * 1. It exists in the new schema but not the old, and is NOT optional → `addedRequired`
- * 2. It exists in the new schema but not the old, and IS optional → `addedOptional`
- *    (planMigration decides whether to backfill based on defaultValue)
- * 3. It exists in both, was optional in old but is NOT optional in new → `newRequired`
- */
-declare function diffSchema(oldSchema: string, newSchema: string): SchemaDiff;
-/**
- * Rewrite specific fields in a schema string to be `v.optional(...)`.
- *
- * Used to produce an interim schema where new required fields are temporarily
- * optional, allowing Convex to accept the schema before documents are backfilled.
- */
-declare function makeFieldsOptional(schema: string, fields: SchemaFieldInfo[]): string;
-/**
- * Re-insert removed fields into a schema string as `v.optional(...)`.
- *
- * Used to produce an interim schema that still accepts documents with the
- * removed field, so we can strip the field from documents before deploying
- * the final schema without the field.
- */
-declare function addRemovedFieldsAsOptional(schema: string, fields: RemovedFieldInfo[]): string;
-
-interface MigrationOp {
-    /** The table name (as exported in the schema). */
-    table: string;
-    /** The field name to backfill. */
-    field: string;
-    /** The default value to set on existing documents. */
-    defaultValue: unknown;
-}
-/**
- * Given a schema diff and the full Vex config, produce a list of
- * migration operations — one per field that needs backfilling.
- *
- * Fields are matched by looking up the collection whose table name
- * (or slug) matches the diff's table, then finding the field's
- * `defaultValue`.
- *
- * Auth-only fields (fields that come from the auth adapter, not from
- * user-defined collections) are skipped — auth manages its own data.
- */
-declare function planMigration(props: {
-    diff: SchemaDiff;
-    config: VexConfig;
-}): MigrationOp[];
-
-export { ALL_SYSTEM_FIELDS, ASPECT_RATIO_PRESETS, type AccessAction, type AdminConfig, type AdminConfigInput, type AdminLivePreviewConfig, type AdminMetaInput, type AdminSidebarInput, type AnyVexCollection, type ArrayFieldDef, type AuthCollectionFieldKeys, type AuthTableFieldKeys, BORDER_RADIUS_PRESETS, BORDER_WIDTH_PRESETS, BOX_SHADOW_PRESETS, type BlockAdminConfig, type BlockDef, type BlockStyleValues, type BlockStylesData, type BlocksFieldDef, type BreakpointConfig, type CellComponentProps, type CheckboxFieldDef, type ClientMediaConfig, type ClientVexConfig, type CollectionAdminConfig, type CollectionKind, type CollectionQueryImports, type ColorFieldDef, type ContainerStyleConfig, DEFAULT_AUTOSAVE_INTERVAL, DEFAULT_BREAKPOINTS, DEFAULT_MAX_VERSIONS_PER_DOC, type DateFieldDef, type DefaultMediaFieldKeys, type DistributiveOmit, type ExtractDocType, type ExtractFieldKeys, type ExtractSlug, type ExtractSlugs, FONT_SIZE_PRESETS, FONT_WEIGHT_PRESETS, type FieldAdminConfig, type FieldComponentProps, type FieldPermissionResult, type FileStorageAdapter, GENERATED_HEADER, type GeneratedFiles, type GlobalAdminConfig, type ImageUrlFieldDef, type IndexConfig, type InferBlockUnion, type InferFieldType, type InferFieldsType, type JsonFieldDef, LETTER_SPACING_PRESETS, LINE_HEIGHT_PRESETS, LOCKED_MEDIA_FIELDS, type LayoutStyleConfig, type LivePreviewBreakpoint, type LivePreviewConfig, type LockedMediaField, type LookupBySlug, MAX_WIDTH_PRESETS, type MediaConfig, type MediaConfigInput, type MediaStyleConfig, type MergedCollectionResult, type MigrationOp, type NumberFieldDef, OPACITY_PRESETS, OVERRIDABLE_MEDIA_FIELDS, type ObjectFieldDef, type OverridableMediaField, PREVIEW_SNAPSHOT_DEBOUNCE_MS, type PermissionCallbackProps, type PermissionCheck, type RelationshipFieldDef, type RemovedFieldInfo, type ResolvedCollectionMatch, type ResolvedFieldPermissions, type ResolvedIndex, type ResolvedSearchIndex, type ResourcePermissions, type RichTextDocument, type RichTextElement, type RichTextFieldDef, type RichTextText, type RolesWithPermissions, SPACING_PRESETS, type SchemaDiff, type SchemaFieldInfo, type SearchIndexConfig, type SelectFieldDef, type SelectOption, type SiteMetadata, type StylePreset, type StyleTier, type TabDef, type TabsFieldDef, type TextFieldDef, type TextStyleConfig, type UIFieldDef, type UploadFieldDef, VERSION_SYSTEM_FIELDS, type VersioningFieldKeys, type VersionsConfig, type VexAccessConfig, VexAccessConfigError, VexAccessError, type VexAccessInput, type VexAccessInputBase, type VexAccessInputWithOrg, type VexAuthAdapter, VexAuthConfigError, VexBlockValidationError, type VexCollection, type VexConfig, type VexConfigInput, type VexDraftsMode, type VexEditorAdapter, type VexEditorComponentProps, VexError, type VexField, VexFieldValidationError, type VexGlobal, type VexMediaCollection, VexMediaConfigError, type VexPlugin, type VexQueryCtx, type VexRenderComponentProps, VexSlugConflictError, WIDTH_PRESETS, addRemovedFieldsAsOptional, array, blockStylesToTailwind, blocks, buildSiteMetadata, checkAdminAccess, checkbox, color, createDocument, createVexQuery, date, defineAccess, defineBlock, defineCollection, defineConfig, defineGlobal, defineMediaCollection, deleteDocument, deletePreviewSnapshot, diffSchema, extendTable, extractLivePreviewConfigs, extractUserFields, fieldMetaToZod, findCollectionBySlug, generateCollectionQueries, generateColumns, generateFormDefaultValues, generateFormSchema, generateIndexFile, generateVexSchema, generateVexTypes, getAllCollections, getDocument, getPreviewSnapshot, hasPermission, imageUrl, isMediaCollection, json, listDocuments, makeFieldsOptional, mergeAuthCollectionWithUserCollection, number, object, planMigration, relationship, resolvePreviewURL, richtext, sanitizeConfigForClient, searchDocuments, select, shouldReloadURL, slugToInterfaceName, tabs, text, toTitleCase, ui, updateDocument, upload, upsertPreviewSnapshot, vexQuery };
+export * from "./collections";
+export * from "./globals";
+export * from "./fields";
+export * from "./utils";
+export * from "./framework";
+export * from "./api/convex";
+export * from "./api/types";
+export * from "./config";
+export * from "./access";
+export * from "./schema";
+export * from "./types";
+export { type VexAuthAdapter, type AuthCollectionConfig, type AuthFieldMeta, VexAuthConfigError, } from "./auth/types";
+export { mergeAuthCollections } from "./auth/mergeCollections";
+export { type VexStorageAdapter, type StorageAdapterPresignedUrlInterface, type StorageAdapterBaseInterface, type StorageAdapterProtocol, type MediaCollectionConfig, type MediaCollectionMeta, type MediaCollectionConfigInput, type GetUrlReturn, type GenerateUploadUrlReturn, type UploadFileReturn, STORAGE_ADAPTER_PROTOCOLS, StorageAdapterPresignedUrl, VexStorageConfigError, validateAndMergeStorageConfig, mediaApi, formatBytes, formatMimeType, createMediaDocumentArgs, createMediaDocumentReturn, deleteMediaArgs, deleteMediaReturn, getUrlArgs, getUrlReturn, } from "./media";
+//# sourceMappingURL=index.d.ts.map