better-convex 0.6.3 → 0.7.0

package/dist/orm/index.d.ts

@@ -1,3012 +1,4 @@
-import { a as ReturnTypeOrValue, i as KnownKeysOnly, o as Simplify, t as Assume } from "../types-jftzhhuc.js";
-import { DefineSchemaOptions, DefineSchemaOptions as DefineSchemaOptions$1, FilterExpression as FilterExpression$1, GenericDatabaseReader, GenericDatabaseWriter, GenericIndexFields, GenericSchema, GenericSchema as GenericSchema$1, GenericTableIndexes, GenericTableSearchIndexes, GenericTableVectorIndexes, IndexRange, IndexRangeBuilder, SchedulableFunctionReference, Scheduler, SchemaDefinition, SchemaDefinition as SchemaDefinition$1, TableDefinition, VectorFilterBuilder, internalMutationGeneric } from "convex/server";
-import * as convex_values69 from "convex/values";
-import { GenericId, Validator, Value } from "convex/values";
-
-//#region src/orm/builders/column-builder.d.ts
-/**
- * Core data types supported by column builders
- * Maps to Convex types: string, number (float64), boolean, bigint (int64), vector
- */
-type ColumnDataType = 'string' | 'number' | 'boolean' | 'bigint' | 'bytes' | 'any' | 'vector';
-type ForeignKeyAction = 'cascade' | 'restrict' | 'no action' | 'set null' | 'set default';
-interface ColumnReferenceConfig {
-  name?: string;
-  onUpdate?: ForeignKeyAction;
-  onDelete?: ForeignKeyAction;
-}
-/**
- * Base configuration for all column builders
- * Stores type-level metadata extracted by TypeScript
- * Matches Drizzle's ColumnBuilderBaseConfig structure
- */
-interface ColumnBuilderBaseConfig<TDataType extends ColumnDataType, TColumnType extends string> {
-  name: string;
-  dataType: TDataType;
-  columnType: TColumnType;
-  data: unknown;
-  driverParam: unknown;
-  enumValues: string[] | undefined;
-}
-/**
- * Runtime configuration stored in builder instance
- * Updated by chaining methods (.notNull(), .default(), etc.)
- */
-interface ColumnBuilderRuntimeConfig<TData> {
-  name: string;
-  tableName?: string;
-  table?: unknown;
-  referenceTable?: string;
-  notNull: boolean;
-  default: TData | undefined;
-  defaultFn?: (() => unknown) | undefined;
-  onUpdateFn?: (() => unknown) | undefined;
-  hasDefault: boolean;
-  primaryKey: boolean;
-  isUnique: boolean;
-  uniqueName?: string;
-  uniqueNulls?: 'distinct' | 'not distinct';
-  foreignKeyConfigs: {
-    ref: () => ColumnBuilderBase;
-    config: ColumnReferenceConfig;
-  }[];
-  dataType: string;
-  columnType: string;
-}
-/**
- * Phantom type configuration - never instantiated, just for TypeScript
- * Tracks type-level state through method chaining
- * Matches Drizzle's exact structure
- */
-type ColumnBuilderTypeConfig<T extends ColumnBuilderBaseConfig<ColumnDataType, string>, TTypeConfig extends object> = Simplify<{
-  brand: 'ColumnBuilder';
-  name: T['name'];
-  dataType: T['dataType'];
-  columnType: T['columnType'];
-  data: T['data'];
-  driverParam: T['driverParam'];
-  notNull: T extends {
-    notNull: infer U;
-  } ? U : boolean;
-  hasDefault: T extends {
-    hasDefault: infer U;
-  } ? U : boolean;
-  isPrimaryKey: T extends {
-    isPrimaryKey: infer U;
-  } ? U : boolean;
-  isUnique: T extends {
-    isUnique: infer U;
-  } ? U : boolean;
-  enumValues: T['enumValues'];
-} & TTypeConfig>;
-/**
- * entityKind symbol for runtime type checking
- * Following Drizzle's pattern for type guards
- */
-declare const entityKind: unique symbol;
-interface DrizzleEntity {
-  [entityKind]: string;
-}
-/**
- * ColumnBuilderBase interface - defines the phantom _ property
- * This interface is crucial for proper type intersection with NotNull/HasDefault/etc.
- */
-interface ColumnBuilderBase<T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>, TTypeConfig extends object = object> {
-  _: ColumnBuilderTypeConfig<T, TTypeConfig>;
-}
-/**
- * Use as the return type for self-referencing `.references()` callbacks.
- *
- * @example
- * ```ts
- * parentId: text().references((): AnyColumn => commentsTable.id, { onDelete: 'cascade' })
- * ```
- */
-type AnyColumn = ColumnBuilderBase;
-/**
- * Base ColumnBuilder abstract class
- *
- * All column builders inherit from this class.
- * Implements chaining methods and stores runtime config.
- */
-declare abstract class ColumnBuilder<T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = object, TTypeConfig extends object = object> implements ColumnBuilderBase<T, TTypeConfig>, DrizzleEntity {
-  static readonly [entityKind]: string;
-  readonly [entityKind]: string;
-  /**
-   * Phantom property - never instantiated, just for types
-   * Accumulates type info through method chaining
-   */
-  _: ColumnBuilderTypeConfig<T, TTypeConfig>;
-  /**
-   * Runtime configuration - actual mutable state
-   */
-  protected config: ColumnBuilderRuntimeConfig<T['data']> & TRuntimeConfig;
-  constructor(name: T['name'], dataType: T['dataType'], columnType: T['columnType']);
-  /**
-   * Mark column as NOT NULL
-   * Returns type-branded instance with notNull: true
-   */
-  notNull(): NotNull<this>;
-  /**
-   * Override the TypeScript type for this column.
-   * Mirrors Drizzle's $type() (type-only, no runtime validation changes).
-   */
-  $type<TType>(): $Type<this, TType>;
-  /**
-   * Set default value for column
-   * Makes field optional on insert
-   */
-  default(value: ColumnData<this>): HasDefault<this>;
-  /**
-   * Set default function for column (runtime evaluated on insert).
-   * Mirrors Drizzle's $defaultFn() / $default().
-   */
-  $defaultFn(fn: () => ColumnData<this>): HasDefault<this>;
-  /**
-   * Alias of $defaultFn for Drizzle parity.
-   */
-  $default(fn: () => ColumnData<this>): HasDefault<this>;
-  /**
-   * Set on-update function for column (runtime evaluated on update).
-   * Mirrors Drizzle's $onUpdateFn() / $onUpdate().
-   */
-  $onUpdateFn(fn: () => ColumnData<this>): HasDefault<this>;
-  /**
-   * Alias of $onUpdateFn for Drizzle parity.
-   */
-  $onUpdate(fn: () => ColumnData<this>): HasDefault<this>;
-  /**
-   * Mark column as primary key
-   * Implies NOT NULL
-   */
-  primaryKey(): IsPrimaryKey<NotNull<this>>;
-  /**
-   * Mark column as UNIQUE
-   * Mirrors Drizzle column unique API
-   */
-  unique(name?: string, config?: {
-    nulls: 'distinct' | 'not distinct';
-  }): IsUnique<this>;
-  /**
-   * Define a foreign key reference
-   * Mirrors Drizzle column references() API
-   */
-  references(ref: () => ColumnBuilderBase, config?: ColumnReferenceConfig): this;
-  /**
-   * Build method - must be implemented by subclasses
-   * Compiles builder to Convex validator
-   *
-   * @returns Convex validator for this column
-   */
-  abstract build(): Validator<any, any, any>;
-}
-/**
- * Type utilities for phantom type branding
- * Drizzle's EXACT pattern - verified working
- */
-/**
- * Brand a builder as NOT NULL
- * Removes | null from extracted type
- */
-type NotNull<T extends ColumnBuilderBase> = T & {
-  _: {
-    notNull: true;
-  };
-};
-/**
- * Brand a builder with a table name
- * Used for relation typing (fields/references must match table)
- */
-type ColumnBuilderWithTableName<T extends ColumnBuilderBase, TTableName extends string> = T & {
-  _: {
-    tableName: TTableName;
-  };
-};
-/**
- * Brand a builder as UNIQUE
- */
-type IsUnique<T extends ColumnBuilderBase> = T & {
-  _: {
-    isUnique: true;
-  };
-};
-/**
- * Brand a builder with a default value
- * Makes field optional on insert
- */
-type HasDefault<T extends ColumnBuilderBase> = T & {
-  _: {
-    hasDefault: true;
-  };
-};
-type ColumnData<TBuilder extends ColumnBuilderBase> = TBuilder['_'] extends {
-  $type: infer TType;
-} ? TType : TBuilder['_']['data'];
-type $Type<TBuilder extends ColumnBuilderBase, TType> = TBuilder & {
-  _: {
-    $type: TType;
-  };
-};
-/**
- * Brand a builder as a primary key
- * Implies NOT NULL
- */
-type IsPrimaryKey<T extends ColumnBuilderBase> = T & {
-  _: {
-    isPrimaryKey: true;
-    notNull: true;
-  };
-};
-//#endregion
-//#region src/orm/builders/convex-column-builder.d.ts
-/**
- * Convex-specific column builder base class
- *
- * All Convex column builders (ConvexTextBuilder, ConvexIntegerBuilder, etc.)
- * inherit from this class.
- */
-declare abstract class ConvexColumnBuilder<T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = object> extends ColumnBuilder<T, TRuntimeConfig, {
-  dialect: 'convex';
-}> {
-  static readonly [entityKind]: string;
-  /**
-   * Build method - compiles builder to Convex validator
-   *
-   * Subclasses implement this to produce the correct validator:
-   * - text() → v.string() or v.optional(v.string())
-   * - integer() → v.number() or v.optional(v.number())
-   * - etc.
-   *
-   * @returns Convex validator for this column
-   */
-  abstract build(): Validator<any, any, any>;
-}
-//#endregion
-//#region src/orm/builders/bigint.d.ts
-/**
- * Initial type for ConvexBigIntBuilder
- */
-type ConvexBigIntBuilderInitial<TName extends string> = ConvexBigIntBuilder<{
-  name: TName;
-  dataType: 'bigint';
-  columnType: 'ConvexBigInt';
-  data: bigint;
-  driverParam: bigint;
-  enumValues: undefined;
-}>;
-/**
- * BigInt column builder class
- * Compiles to v.int64() or v.optional(v.int64())
- */
-declare class ConvexBigIntBuilder<T extends ColumnBuilderBaseConfig<'bigint', 'ConvexBigInt'>> extends ConvexColumnBuilder<T> {
-  static readonly [entityKind]: string;
-  constructor(name: T['name']);
-  /**
-   * Expose Convex validator for schema integration
-   */
-  get convexValidator(): Validator<any, any, any>;
-  /**
-   * Compile to Convex validator
-   * .notNull() → v.int64()
-   * nullable → v.optional(v.int64())
-   */
-  build(): Validator<any, any, any>;
-}
-/**
- * bigint() factory function
- *
- * Creates a bigint column builder (int64 in Convex).
- * For JavaScript bigint values.
- *
- * @example
- * bigint() → unnamed column
- * bigint('col_name') → named column
- */
-declare function bigint(): ConvexBigIntBuilderInitial<''>;
-declare function bigint<TName extends string>(name: TName): ConvexBigIntBuilderInitial<TName>;
-//#endregion
-//#region src/orm/builders/boolean.d.ts
-/**
- * Initial type for ConvexBooleanBuilder
- */
-type ConvexBooleanBuilderInitial<TName extends string> = ConvexBooleanBuilder<{
-  name: TName;
-  dataType: 'boolean';
-  columnType: 'ConvexBoolean';
-  data: boolean;
-  driverParam: boolean;
-  enumValues: undefined;
-}>;
-/**
- * Boolean column builder class
- * Compiles to v.boolean() or v.optional(v.boolean())
- */
-declare class ConvexBooleanBuilder<T extends ColumnBuilderBaseConfig<'boolean', 'ConvexBoolean'>> extends ConvexColumnBuilder<T> {
-  static readonly [entityKind]: string;
-  constructor(name: T['name']);
-  /**
-   * Expose Convex validator for schema integration
-   */
-  get convexValidator(): Validator<any, any, any>;
-  /**
-   * Compile to Convex validator
-   * .notNull() → v.boolean()
-   * nullable → v.optional(v.boolean())
-   */
-  build(): Validator<any, any, any>;
-}
-/**
- * boolean() factory function
- *
- * Creates a boolean column builder.
- *
- * @example
- * boolean() → unnamed column
- * boolean('col_name') → named column
- */
-declare function boolean(): ConvexBooleanBuilderInitial<''>;
-declare function boolean<TName extends string>(name: TName): ConvexBooleanBuilderInitial<TName>;
-//#endregion
-//#region src/orm/builders/bytes.d.ts
-type ConvexBytesBuilderInitial<TName extends string> = ConvexBytesBuilder<{
-  name: TName;
-  dataType: 'bytes';
-  columnType: 'ConvexBytes';
-  data: ArrayBuffer;
-  driverParam: ArrayBuffer;
-  enumValues: undefined;
-}>;
-declare class ConvexBytesBuilder<T extends ColumnBuilderBaseConfig<'bytes', 'ConvexBytes'>> extends ConvexColumnBuilder<T> {
-  static readonly [entityKind]: string;
-  constructor(name: T['name']);
-  get convexValidator(): Validator<any, any, any>;
-  build(): Validator<any, any, any>;
-}
-declare function bytes(): ConvexBytesBuilderInitial<''>;
-declare function bytes<TName extends string>(name: TName): ConvexBytesBuilderInitial<TName>;
-//#endregion
-//#region src/orm/builders/custom.d.ts
-type AnyValidator = Validator<any, any, any>;
-type ConvexCustomBuilderInitial<TName extends string, TValidator extends AnyValidator> = ConvexCustomBuilder<{
-  name: TName;
-  dataType: 'any';
-  columnType: 'ConvexCustom';
-  data: TValidator['type'];
-  driverParam: TValidator['type'];
-  enumValues: undefined;
-}, TValidator>;
-declare class ConvexCustomBuilder<T extends ColumnBuilderBaseConfig<'any', 'ConvexCustom'>, TValidator extends AnyValidator> extends ConvexColumnBuilder<T, {
-  validator: TValidator;
-}> {
-  static readonly [entityKind]: string;
-  constructor(name: T['name'], validator: TValidator);
-  get convexValidator(): Validator<any, any, any>;
-  build(): Validator<any, any, any>;
-}
-declare function custom<TValidator extends AnyValidator>(validator: TValidator): ConvexCustomBuilderInitial<'', TValidator>;
-declare function custom<TName extends string, TValidator extends AnyValidator>(name: TName, validator: TValidator): ConvexCustomBuilderInitial<TName, TValidator>;
-/**
- * Convenience wrapper for Convex "JSON" values.
- *
- * Note: This is Convex JSON (runtime `v.any()`), not SQL JSON/JSONB.
- */
-declare function json<T = Value>(): $Type<ConvexCustomBuilderInitial<"", convex_values69.VAny<any, "required", string>>, T>;
-//#endregion
-//#region src/orm/builders/date.d.ts
-type ConvexDateMode = 'string' | 'date';
-type ConvexDateBuilderConfig<TName extends string, TMode extends ConvexDateMode> = {
-  name: TName;
-  dataType: 'string';
-  columnType: 'ConvexDate';
-  data: TMode extends 'date' ? Date : string;
-  driverParam: string;
-  enumValues: undefined;
-};
-type ConvexDateBuilderInitial<TName extends string, TMode extends ConvexDateMode = 'string'> = ConvexDateBuilder<ConvexDateBuilderConfig<TName, TMode>, TMode>;
-type ConvexDateRuntimeConfig<TMode extends ConvexDateMode> = {
-  mode: TMode;
-};
-type ConvexDateBuilderArg<TMode extends ConvexDateMode> = {
-  mode?: TMode;
-};
-declare class ConvexDateBuilder<T extends ColumnBuilderBaseConfig<'string', 'ConvexDate'>, TMode extends ConvexDateMode = ConvexDateMode> extends ConvexColumnBuilder<T, ConvexDateRuntimeConfig<TMode>> {
-  static readonly [entityKind]: string;
-  constructor(name: T['name'], mode: TMode);
-  get convexValidator(): Validator<any, any, any>;
-  defaultNow(): HasDefault<this>;
-  build(): Validator<any, any, any>;
-}
-declare function date(): ConvexDateBuilderInitial<'', 'string'>;
-declare function date<TName extends string>(name: TName): ConvexDateBuilderInitial<TName, 'string'>;
-declare function date<TMode extends ConvexDateMode>(config: ConvexDateBuilderArg<TMode>): ConvexDateBuilderInitial<'', TMode>;
-declare function date<TName extends string, TMode extends ConvexDateMode>(name: TName, config: ConvexDateBuilderArg<TMode>): ConvexDateBuilderInitial<TName, TMode>;
-//#endregion
-//#region src/orm/builders/id.d.ts
-/**
- * Initial type for ConvexIdBuilder
- * Includes table name in type for branded Id
- */
-type ConvexIdBuilderInitial<TName extends string, TTableName extends string> = ConvexIdBuilder<{
-  name: TName;
-  dataType: 'string';
-  columnType: 'ConvexId';
-  data: GenericId<TTableName>;
-  driverParam: GenericId<TTableName>;
-  enumValues: undefined;
-}>;
-/**
- * ID column builder class
- * Compiles to v.id(tableName) or v.optional(v.id(tableName))
- */
-declare class ConvexIdBuilder<T extends ColumnBuilderBaseConfig<'string', 'ConvexId'>> extends ConvexColumnBuilder<T> {
-  private tableName;
-  static readonly [entityKind]: string;
-  constructor(name: T['name'], tableName: string);
-  /**
-   * Expose Convex validator for schema integration
-   */
-  get convexValidator(): Validator<any, any, any>;
-  /**
-   * Compile to Convex validator
-   * .notNull() → v.id(tableName)
-   * nullable → v.optional(v.id(tableName))
-   */
-  build(): Validator<any, any, any>;
-}
-/**
- * id() factory function
- *
- * Creates an ID reference column builder (foreign key).
- * Requires table name to generate branded Id type.
- *
- * @example
- * id('users') → unnamed column referencing users table
- */
-declare function id<TTableName extends string>(tableName: TTableName): ConvexIdBuilderInitial<'', TTableName>;
-//#endregion
-//#region src/orm/builders/number.d.ts
-/**
- * Initial type for ConvexNumberBuilder
- */
-type ConvexNumberBuilderInitial<TName extends string> = ConvexNumberBuilder<{
-  name: TName;
-  dataType: 'number';
-  columnType: 'ConvexNumber';
-  data: number;
-  driverParam: number;
-  enumValues: undefined;
-}>;
-/**
- * Number column builder class
- * Compiles to v.number() or v.optional(v.number())
- */
-declare class ConvexNumberBuilder<T extends ColumnBuilderBaseConfig<'number', 'ConvexNumber'>> extends ConvexColumnBuilder<T> {
-  static readonly [entityKind]: string;
-  constructor(name: T['name']);
-  /**
-   * Expose Convex validator for schema integration
-   */
-  get convexValidator(): Validator<any, any, any>;
-  /**
-   * Compile to Convex validator
-   * .notNull() → v.number()
-   * nullable → v.optional(v.number())
-   */
-  build(): Validator<any, any, any>;
-}
-/**
- * integer() factory function
- *
- * Drizzle-parity numeric builder.
- * In Convex this maps to v.number() (Float64).
- *
- * @example
- * integer() → unnamed column
- * integer('col_name') → named column
- */
-declare function integer(): ConvexNumberBuilderInitial<''>;
-declare function integer<TName extends string>(name: TName): ConvexNumberBuilderInitial<TName>;
-//#endregion
-//#region src/orm/builders/system-fields.d.ts
-/**
- * System ID field builder (public id, internal _id)
- * Always present, always non-null
- */
-type ConvexSystemIdConfig = ColumnBuilderBaseConfig<'string', 'ConvexSystemId'> & {
-  data: string;
-  driverParam: string;
-  enumValues: undefined;
-};
-declare class ConvexSystemIdBuilder<_TTableName extends string> extends ColumnBuilder<ConvexSystemIdConfig, {}, {
-  notNull: true;
-}> {
-  static readonly [entityKind]: string;
-  readonly [entityKind]: string;
-  constructor();
-  build(): convex_values69.VString<string, "required">;
-  /**
-   * Convex validator - runtime access
-   * System fields use v.string() for _id
-   */
-  get convexValidator(): convex_values69.VString<string, "required">;
-}
-/**
- * System creation time field builder (_creationTime)
- * Always present, always non-null, always a number (milliseconds)
- */
-type ConvexSystemCreationTimeConfig = ColumnBuilderBaseConfig<'number', 'ConvexSystemCreationTime'> & {
-  data: number;
-  driverParam: number;
-  enumValues: undefined;
-};
-declare class ConvexSystemCreationTimeBuilder extends ColumnBuilder<ConvexSystemCreationTimeConfig, {}, {
-  notNull: true;
-}> {
-  static readonly [entityKind]: string;
-  readonly [entityKind]: string;
-  constructor();
-  build(): convex_values69.VFloat64<number, "required">;
-  /**
-   * Convex validator - runtime access
-   * System fields use v.number() for _creationTime
-   */
-  get convexValidator(): convex_values69.VFloat64<number, "required">;
-}
-type ConvexSystemCreatedAtConfig = ColumnBuilderBaseConfig<'number', 'ConvexSystemCreatedAt'> & {
-  data: number;
-  driverParam: number;
-  enumValues: undefined;
-};
-declare class ConvexSystemCreatedAtBuilder extends ColumnBuilder<ConvexSystemCreatedAtConfig, {}, {
-  notNull: true;
-}> {
-  static readonly [entityKind]: string;
-  readonly [entityKind]: string;
-  constructor();
-  build(): convex_values69.VFloat64<number, "required">;
-  get convexValidator(): convex_values69.VFloat64<number, "required">;
-}
-/**
- * Create system field builders for a table
- * These are automatically added to every ConvexTable
- */
-type SystemFields<TName extends string> = {
-  id: ColumnBuilderWithTableName<ConvexSystemIdBuilder<TName>, TName>;
-};
-type InternalSystemFields<TName extends string> = {
-  _creationTime: ColumnBuilderWithTableName<ConvexSystemCreationTimeBuilder, TName>;
-};
-type SystemFieldAliases<TName extends string, TColumns extends Record<string, unknown> = {}> = 'createdAt' extends keyof TColumns ? {} : {
-  createdAt: ColumnBuilderWithTableName<ConvexSystemCreatedAtBuilder, TName>;
-};
-type SystemFieldsWithAliases<TName extends string, TColumns extends Record<string, unknown> = {}> = SystemFields<TName> & InternalSystemFields<TName> & SystemFieldAliases<TName, TColumns>;
-//#endregion
-//#region src/orm/builders/text.d.ts
-/**
- * Initial type for ConvexTextBuilder
- * Used in factory function return types
- * Matches Drizzle's pattern with all required properties
- */
-type ConvexTextBuilderInitial<TName extends string> = ConvexTextBuilder<{
-  name: TName;
-  dataType: 'string';
-  columnType: 'ConvexText';
-  data: string;
-  driverParam: string;
-  enumValues: undefined;
-}>;
-/**
- * Text column builder class
- * Compiles to v.string() or v.optional(v.string())
- */
-declare class ConvexTextBuilder<T extends ColumnBuilderBaseConfig<'string', 'ConvexText'>> extends ConvexColumnBuilder<T> {
-  static readonly [entityKind]: string;
-  constructor(name: T['name']);
-  /**
-   * Expose Convex validator for schema integration
-   */
-  get convexValidator(): Validator<any, any, any>;
-  /**
-   * Compile to Convex validator
-   * .notNull() → v.string()
-   * nullable → v.optional(v.string())
-   */
-  build(): Validator<any, any, any>;
-}
-/**
- * text() factory function
- *
- * Creates a text column builder.
- * Supports both named and unnamed columns (for later binding).
- *
- * @example
- * text() → unnamed column
- * text('col_name') → named column
- */
-declare function text(): ConvexTextBuilderInitial<''>;
-declare function text<TName extends string>(name: TName): ConvexTextBuilderInitial<TName>;
-//#endregion
-//#region src/orm/builders/text-enum.d.ts
-type EnumValues = readonly [string, ...string[]];
-type ConvexTextEnumBuilderInitial<TName extends string, TValues extends EnumValues> = ConvexTextEnumBuilder<{
-  name: TName;
-  dataType: 'string';
-  columnType: 'ConvexText';
-  data: TValues[number];
-  driverParam: TValues[number];
-  enumValues: TValues[number][];
-}>;
-declare class ConvexTextEnumBuilder<T extends ColumnBuilderBaseConfig<'string', 'ConvexText'>> extends ConvexColumnBuilder<T, {
-  values: string[];
-}> {
-  static readonly [entityKind]: string;
-  constructor(name: T['name'], values: readonly string[]);
-  private _enumValidator;
-  get convexValidator(): Validator<any, any, any>;
-  build(): Validator<any, any, any>;
-}
-declare function textEnum<const TValues extends EnumValues>(values: TValues): ConvexTextEnumBuilderInitial<'', TValues>;
-//#endregion
-//#region src/orm/builders/timestamp.d.ts
-type ConvexTimestampMode = 'date' | 'string';
-type ConvexTimestampBuilderConfig<TName extends string, TMode extends ConvexTimestampMode> = {
-  name: TName;
-  dataType: 'number';
-  columnType: 'ConvexTimestamp';
-  data: TMode extends 'string' ? string : Date;
-  driverParam: number;
-  enumValues: undefined;
-};
-type ConvexTimestampBuilderInitial<TName extends string, TMode extends ConvexTimestampMode = 'date'> = ConvexTimestampBuilder<ConvexTimestampBuilderConfig<TName, TMode>, TMode>;
-type ConvexTimestampRuntimeConfig<TMode extends ConvexTimestampMode> = {
-  mode: TMode;
-};
-type ConvexTimestampBuilderArg<TMode extends ConvexTimestampMode> = {
-  mode?: TMode;
-};
-declare class ConvexTimestampBuilder<T extends ColumnBuilderBaseConfig<'number', 'ConvexTimestamp'>, TMode extends ConvexTimestampMode = ConvexTimestampMode> extends ConvexColumnBuilder<T, ConvexTimestampRuntimeConfig<TMode>> {
-  static readonly [entityKind]: string;
-  constructor(name: T['name'], mode: TMode);
-  get convexValidator(): Validator<any, any, any>;
-  defaultNow(): HasDefault<this>;
-  build(): Validator<any, any, any>;
-}
-declare function timestamp(): ConvexTimestampBuilderInitial<'', 'date'>;
-declare function timestamp<TName extends string>(name: TName): ConvexTimestampBuilderInitial<TName, 'date'>;
-declare function timestamp<TMode extends ConvexTimestampMode>(config: ConvexTimestampBuilderArg<TMode>): ConvexTimestampBuilderInitial<'', TMode>;
-declare function timestamp<TName extends string, TMode extends ConvexTimestampMode>(name: TName, config: ConvexTimestampBuilderArg<TMode>): ConvexTimestampBuilderInitial<TName, TMode>;
-//#endregion
-//#region src/orm/builders/vector.d.ts
-/**
- * Initial type for ConvexVectorBuilder
- */
-type ConvexVectorBuilderInitial<TName extends string> = ConvexVectorBuilder<{
-  name: TName;
-  dataType: 'vector';
-  columnType: 'ConvexVector';
-  data: number[];
-  driverParam: number[];
-  enumValues: undefined;
-}>;
-/**
- * Vector column builder class
- * Compiles to v.array(v.float64()) or v.optional(v.array(v.float64()))
- */
-declare class ConvexVectorBuilder<T extends ColumnBuilderBaseConfig<'vector', 'ConvexVector'>> extends ConvexColumnBuilder<T, {
-  dimensions: number;
-}> {
-  static readonly [entityKind]: string;
-  constructor(name: T['name'], dimensions: number);
-  get dimensions(): number;
-  /**
-   * Expose Convex validator for schema integration
-   */
-  get convexValidator(): Validator<any, any, any>;
-  /**
-   * Compile to Convex validator
-   * .notNull() → v.array(v.float64())
-   * nullable → v.optional(v.array(v.float64()))
-   */
-  build(): Validator<any, any, any>;
-}
-/**
- * vector() factory function
- *
- * Creates a vector column builder with fixed dimensions.
- *
- * @example
- * vector(1536) → unnamed column
- * vector('embedding', 1536) → named column
- */
-declare function vector(dimensions: number): ConvexVectorBuilderInitial<''>;
-declare function vector<TName extends string>(name: TName, dimensions: number): ConvexVectorBuilderInitial<TName>;
-//#endregion
-//#region src/orm/filter-expression.d.ts
-/**
- * Extract TypeScript type from a column builder
- * Uses phantom `_` property to get type info
- */
-type ColumnToType<TBuilder extends ColumnBuilder<any, any, any>> = TBuilder['_']['notNull'] extends true ? TBuilder['_']['data'] : TBuilder['_']['data'] | null;
-/**
- * Unique symbol for FilterExpression brand
- * Prevents structural typing - only expressions created by factory functions are valid
- */
-declare const FilterExpressionBrand: unique symbol;
-/**
- * Base filter expression interface
- * All filter expressions (binary, logical, unary) implement this interface
- *
- * @template TValue - The TypeScript type this expression evaluates to
- */
-interface FilterExpression<_TValue = boolean> {
-  /** Brand symbol for nominal typing */
-  readonly [FilterExpressionBrand]: true;
-  /** Expression type discriminator */
-  readonly type: 'binary' | 'logical' | 'unary';
-  /** Operator string (eq, and, not, etc.) */
-  readonly operator: string;
-  /** Expression operands (FieldReference, values, or nested expressions) */
-  readonly operands: readonly any[];
-  /** Accept visitor for traversal */
-  accept<R>(visitor: ExpressionVisitor<R>): R;
-}
-/**
- * Binary operator expression (eq, ne, gt, gte, lt, lte, inArray, notInArray)
- * Compares field to value: field eq value
- *
- * @template TField - Field type being compared
- */
-interface BinaryExpression<TField = any> extends FilterExpression<boolean> {
-  readonly type: 'binary';
-  readonly operator: 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'inArray' | 'notInArray' | 'arrayContains' | 'arrayContained' | 'arrayOverlaps' | 'like' | 'ilike' | 'notLike' | 'notIlike' | 'startsWith' | 'endsWith' | 'contains';
-  /** [field, value] or [field, array] for inArray/notInArray */
-  readonly operands: readonly [FieldReference<TField>, TField | TField[]];
-}
-/**
- * Logical operator expression (and, or)
- * Combines multiple filter expressions
- */
-interface LogicalExpression extends FilterExpression<boolean> {
-  readonly type: 'logical';
-  readonly operator: 'and' | 'or';
-  /** Array of nested filter expressions */
-  readonly operands: readonly FilterExpression<boolean>[];
-}
-/**
- * Unary operator expression (not, isNull, isNotNull)
- * Negates or checks null state of an expression
- */
-interface UnaryExpression extends FilterExpression<boolean> {
-  readonly type: 'unary';
-  readonly operator: 'not' | 'isNull' | 'isNotNull';
-  /** Single nested filter expression or field reference for null checks */
-  readonly operands: readonly [FilterExpression<boolean> | FieldReference<any>];
-}
-/**
- * CRITICAL: FieldReference abstraction
- *
- * Decouples filter expressions from M2 table configuration
- * Allows filter expressions to reference fields without knowing about validators
- *
- * @template TValue - TypeScript type of the field
- */
-interface FieldReference<TValue = unknown> {
-  readonly __brand: 'FieldReference';
-  readonly fieldName: string;
-  /** Phantom type for type inference - not present at runtime */
-  readonly __type?: TValue;
-}
-/**
- * Create a field reference
- * Used internally by operator functions
- */
-declare function fieldRef<T>(fieldName: string): FieldReference<T>;
-/**
- * Type guard for FieldReference
- */
-declare function isFieldReference(value: any): value is FieldReference<any>;
-/**
- * Column wrapper - combines builder with column name
- * Used in where clause to pass column objects to operators
- * Following Drizzle's pattern: operators receive columns, not extracted types
- *
- * @template TBuilder - The column builder type
- * @template TName - The column name (string literal)
- */
-interface Column<TBuilder extends ColumnBuilder<any, any, any> = any, TName extends string = string> {
-  readonly builder: TBuilder;
-  readonly columnName: TName;
-}
-type ColumnArgument<TBuilder extends ColumnBuilder<any, any, any>> = Column<TBuilder, string> | TBuilder;
-/**
- * Create a column wrapper
- * Used internally by query builder's _createColumnProxies
- */
-/**
- * Expression visitor interface for tree traversal
- * Extensible pattern - add new visit methods without modifying expression classes
- *
- * @template R - Return type of visit operations
- */
-interface ExpressionVisitor<R = void> {
-  visitBinary(expr: BinaryExpression): R;
-  visitLogical(expr: LogicalExpression): R;
-  visitUnary(expr: UnaryExpression): R;
-}
-/**
- * Equality operator: field == value
- *
- * @example
- * const filter = eq(cols.name, 'Alice');
- */
-declare function eq<TBuilder extends ColumnBuilder<any, any, any>>(col: ColumnArgument<TBuilder>, value: ColumnToType<TBuilder>): BinaryExpression<ColumnToType<TBuilder>>;
-/**
- * Not equal operator: field != value
- */
-declare function ne<TBuilder extends ColumnBuilder<any, any, any>>(col: ColumnArgument<TBuilder>, value: ColumnToType<TBuilder>): BinaryExpression<ColumnToType<TBuilder>>;
-/**
- * Greater than operator: field > value
- */
-declare function gt<TBuilder extends ColumnBuilder<any, any, any>>(col: ColumnArgument<TBuilder>, value: ColumnToType<TBuilder>): BinaryExpression<ColumnToType<TBuilder>>;
-/**
- * Greater than or equal operator: field >= value
- */
-declare function gte<TBuilder extends ColumnBuilder<any, any, any>>(col: ColumnArgument<TBuilder>, value: ColumnToType<TBuilder>): BinaryExpression<ColumnToType<TBuilder>>;
-/**
- * Less than operator: field < value
- */
-declare function lt<TBuilder extends ColumnBuilder<any, any, any>>(col: ColumnArgument<TBuilder>, value: ColumnToType<TBuilder>): BinaryExpression<ColumnToType<TBuilder>>;
-/**
- * Less than or equal operator: field <= value
- */
-declare function lte<TBuilder extends ColumnBuilder<any, any, any>>(col: ColumnArgument<TBuilder>, value: ColumnToType<TBuilder>): BinaryExpression<ColumnToType<TBuilder>>;
-/**
- * Between operator: field BETWEEN min AND max (inclusive)
- *
- * Sugar for and(gte(field, min), lte(field, max)).
- */
-declare function between<TBuilder extends ColumnBuilder<any, any, any>>(col: ColumnArgument<TBuilder>, min: ColumnToType<TBuilder>, max: ColumnToType<TBuilder>): FilterExpression<boolean>;
-/**
- * Not between operator: field < min OR field > max
- *
- * Sugar for or(lt(field, min), gt(field, max)).
- */
-declare function notBetween<TBuilder extends ColumnBuilder<any, any, any>>(col: ColumnArgument<TBuilder>, min: ColumnToType<TBuilder>, max: ColumnToType<TBuilder>): FilterExpression<boolean>;
-/**
- * LIKE operator: SQL-style pattern matching with % wildcards
- * Note: Implemented as post-filter (Convex has no native LIKE)
- *
- * @example
- * const users = await db.query.users.findMany({
- *   where: like(users.name, '%alice%'),
- * });
- */
-declare function like<TBuilder extends ColumnBuilder<any, any, any>>(col: ColumnArgument<TBuilder>, pattern: string): BinaryExpression<string>;
-/**
- * ILIKE operator: Case-insensitive LIKE
- * Note: Implemented as post-filter (Convex has no native LIKE)
- *
- * @example
- * const users = await db.query.users.findMany({
- *   where: ilike(users.name, '%ALICE%'),
- * });
- */
-declare function ilike<TBuilder extends ColumnBuilder<any, any, any>>(col: ColumnArgument<TBuilder>, pattern: string): BinaryExpression<string>;
-/**
- * startsWith operator: Check if string starts with prefix
- * Optimized for prefix matching
- *
- * @example
- * const users = await db.query.users.findMany({
- *   where: startsWith(users.email, 'admin@'),
- * });
- */
-declare function startsWith<TBuilder extends ColumnBuilder<any, any, any>>(col: ColumnArgument<TBuilder>, prefix: string): BinaryExpression<string>;
-/**
- * endsWith operator: Check if string ends with suffix
- *
- * @example
- * const users = await db.query.users.findMany({
- *   where: endsWith(users.email, '@example.com'),
- * });
- */
-declare function endsWith<TBuilder extends ColumnBuilder<any, any, any>>(col: ColumnArgument<TBuilder>, suffix: string): BinaryExpression<string>;
-/**
- * contains operator: Check if string contains substring
- * Can use search index for optimization when available
- *
- * @example
- * const posts = await db.query.posts.findMany({
- *   where: contains(posts.title, 'javascript'),
- * });
- */
-declare function contains<TBuilder extends ColumnBuilder<any, any, any>>(col: ColumnArgument<TBuilder>, substring: string): BinaryExpression<string>;
-/**
- * Logical AND: all expressions must be true
- * Filters out undefined expressions (following Drizzle pattern)
- *
- * @example
- * const filter = and(
- *   eq(fieldRef('age'), 25),
- *   eq(fieldRef('name'), 'Alice')
- * );
- */
-declare function and(...expressions: (FilterExpression<boolean> | undefined)[]): LogicalExpression | undefined;
-/**
- * Logical OR: at least one expression must be true
- * Filters out undefined expressions (following Drizzle pattern)
- *
- * @example
- * const filter = or(
- *   eq(fieldRef('status'), 'active'),
- *   eq(fieldRef('status'), 'pending')
- * );
- */
-declare function or(...expressions: (FilterExpression<boolean> | undefined)[]): LogicalExpression | undefined;
-/**
- * Logical NOT: negates expression
- *
- * @example
- * const filter = not(eq(fieldRef('isDeleted'), true));
- */
-declare function not(expression: FilterExpression<boolean>): UnaryExpression;
-/**
- * Array membership operator: field IN array
- *
- * @example
- * const filter = inArray(cols.status, ['active', 'pending']);
- */
-declare function inArray<TBuilder extends ColumnBuilder<any, any, any>>(col: ColumnArgument<TBuilder>, values: readonly ColumnToType<TBuilder>[]): BinaryExpression<ColumnToType<TBuilder>>;
-/**
- * Array exclusion operator: field NOT IN array
- * Validates array is non-empty at construction time
- *
- * @example
- * const filter = notInArray(cols.role, ['admin', 'moderator']);
- */
-declare function notInArray<TBuilder extends ColumnBuilder<any, any, any>>(col: ColumnArgument<TBuilder>, values: readonly ColumnToType<TBuilder>[]): BinaryExpression<ColumnToType<TBuilder>>;
-/**
- * Null check operator: field IS NULL
- * Type validation: Only works with nullable fields
- *
- * @example
- * const filter = isNull(cols.deletedAt);
- */
-declare function isNull<TBuilder extends ColumnBuilder<any, any, any>>(col: ColumnArgument<TBuilder>): UnaryExpression;
-/**
- * Not null check operator: field IS NOT NULL
- * Type validation: Only works with nullable fields
- *
- * @example
- * const filter = isNotNull(cols.deletedAt);
- */
-declare function isNotNull<TBuilder extends ColumnBuilder<any, any, any>>(col: ColumnArgument<TBuilder>): UnaryExpression;
-//#endregion
-//#region src/orm/constraints.d.ts
-type ConvexConstraintColumn = ColumnBuilderBase;
-type ConvexForeignKeyColumns = [ConvexConstraintColumn, ...ConvexConstraintColumn[]];
-interface ConvexUniqueConstraintConfig {
-  name?: string;
-  columns: ConvexConstraintColumn[];
-  nullsNotDistinct: boolean;
-}
-interface ConvexForeignKeyConfig<TColumns extends ConvexForeignKeyColumns = ConvexForeignKeyColumns> {
-  name?: string;
-  columns: TColumns;
-  foreignColumns: { [K in keyof TColumns]: ConvexConstraintColumn };
-  onUpdate?: ForeignKeyAction;
-  onDelete?: ForeignKeyAction;
-}
-declare class ConvexUniqueConstraintBuilderOn {
-  private name?;
-  static readonly [entityKind] = "ConvexUniqueConstraintBuilderOn";
-  readonly [entityKind] = "ConvexUniqueConstraintBuilderOn";
-  constructor(name?: string | undefined);
-  on(...columns: [ConvexConstraintColumn, ...ConvexConstraintColumn[]]): ConvexUniqueConstraintBuilder;
-}
-declare class ConvexUniqueConstraintBuilder {
-  static readonly [entityKind] = "ConvexUniqueConstraintBuilder";
-  readonly [entityKind] = "ConvexUniqueConstraintBuilder";
-  _: {
-    brand: 'ConvexUniqueConstraintBuilder';
-  };
-  config: ConvexUniqueConstraintConfig;
-  constructor(name: string | undefined, columns: ConvexConstraintColumn[]);
-  nullsNotDistinct(): this;
-}
-declare class ConvexForeignKeyBuilder {
-  static readonly [entityKind] = "ConvexForeignKeyBuilder";
-  readonly [entityKind] = "ConvexForeignKeyBuilder";
-  _: {
-    brand: 'ConvexForeignKeyBuilder';
-  };
-  config: ConvexForeignKeyConfig;
-  constructor(config: ConvexForeignKeyConfig);
-  onUpdate(action: ForeignKeyAction): this;
-  onDelete(action: ForeignKeyAction): this;
-}
-declare function unique(name?: string): ConvexUniqueConstraintBuilderOn;
-declare function foreignKey<TColumns extends ConvexForeignKeyColumns>(config: ConvexForeignKeyConfig<TColumns>): ConvexForeignKeyBuilder;
-interface ConvexCheckConfig {
-  name: string;
-  expression: FilterExpression<boolean>;
-}
-declare class ConvexCheckBuilder {
-  static readonly [entityKind] = "ConvexCheckBuilder";
-  readonly [entityKind] = "ConvexCheckBuilder";
-  _: {
-    brand: 'ConvexCheckBuilder';
-  };
-  config: ConvexCheckConfig;
-  constructor(name: string, expression: FilterExpression<boolean>);
-}
-declare function check(name: string, expression: FilterExpression<boolean>): ConvexCheckBuilder;
-//#endregion
-//#region src/orm/symbols.d.ts
-/**
- * Symbol-based metadata storage for ORM tables
- * Following Drizzle's pattern for type-safe runtime introspection
- */
-type OrmRuntimeDefaults = {
-  defaultLimit?: number;
-  relationFanOutMaxKeys?: number;
-  mutationBatchSize?: number;
-  mutationLeafBatchSize?: number;
-  mutationMaxRows?: number;
-  mutationMaxBytesPerBatch?: number;
-  mutationScheduleCallCap?: number;
-  mutationExecutionMode?: 'sync' | 'async';
-  mutationAsyncDelayMs?: number;
-};
-type OrmDeleteMode = 'hard' | 'soft' | 'scheduled';
-type OrmTableDeleteConfig = {
-  mode: OrmDeleteMode;
-  delayMs?: number;
-};
-declare const TableName: unique symbol;
-declare const Columns: unique symbol;
-declare const Brand: unique symbol;
-declare const RlsPolicies: unique symbol;
-declare const EnableRLS: unique symbol;
-declare const TableDeleteConfig: unique symbol;
-declare const TableLifecycleHooks: unique symbol;
-declare const OrmSchemaDefinition: unique symbol;
-//#endregion
-//#region src/orm/unset-token.d.ts
-declare const unsetToken: unique symbol;
-type UnsetToken = typeof unsetToken;
-//#endregion
-//#region src/orm/types.d.ts
-/**
- * Value or array helper (Drizzle pattern).
- */
-type ValueOrArray<T> = T | T[];
-/**
- * Type equality check - returns true if X and Y are exactly the same type
- * Pattern from Drizzle: drizzle-orm/src/utils.ts:172
- */
-type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
-/**
- * Merge two object types without using intersection
- * Intersection can cause TypeScript to lose phantom type brands
- * This manually combines keys from both types
- */
-type Merge<A, B> = { [K in keyof A | keyof B]: K extends keyof B ? B[K] : K extends keyof A ? A[K] : never };
-type IndexKey = (Value | undefined)[];
-type FindManyUnionSource<TTableConfig extends TableRelationalConfig = TableRelationalConfig> = {
-  where?: RelationsFilter<TTableConfig, any> | WhereCallback<TTableConfig>;
-};
-type PipelineRelationName<TTableConfig extends TableRelationalConfig> = Extract<keyof TTableConfig['relations'], string>;
-type FindManyPipelineFlatMapConfig<TTableConfig extends TableRelationalConfig = TableRelationalConfig, TRelationName extends PipelineRelationName<TTableConfig> = PipelineRelationName<TTableConfig>> = {
-  relation: TRelationName;
-  where?: unknown;
-  orderBy?: unknown;
-  limit?: number;
-  includeParent?: boolean;
-};
-type FindManyPipelineFlatMapStage<TTableConfig extends TableRelationalConfig = TableRelationalConfig> = {
-  flatMap: FindManyPipelineFlatMapConfig<TTableConfig>;
-};
-type FindManyPipelineFilterWithStage<TRow = unknown> = {
-  filterWith: (row: TRow) => boolean | Promise<boolean>;
-};
-type FindManyPipelineMapStage<TRow = unknown, TOutput = unknown> = {
-  map: (row: TRow) => TOutput | null | Promise<TOutput | null>;
-};
-type FindManyPipelineDistinctStage = {
-  distinct: {
-    fields: string[];
-  };
-};
-type FindManyPipelineStageForInput<TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTableConfig extends TableRelationalConfig = TableRelationalConfig, TRow = BuildQueryResult<TSchema, TTableConfig, true>> = FindManyPipelineFilterWithStage<TRow> | FindManyPipelineMapStage<TRow> | FindManyPipelineDistinctStage | FindManyPipelineFlatMapStage<TTableConfig>;
-type FindManyPipelineConfig<TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTableConfig extends TableRelationalConfig = TableRelationalConfig, TStages extends readonly unknown[] = readonly FindManyPipelineStageForInput<TSchema, TTableConfig, BuildQueryResult<TSchema, TTableConfig, true>>[]> = {
-  union?: FindManyUnionSource<TTableConfig>[];
-  interleaveBy?: string[];
-  stages?: TStages;
-};
-type FindManyPageByKeyConfig = {
-  index?: string;
-  order?: 'asc' | 'desc';
-  startKey?: IndexKey;
-  startInclusive?: boolean;
-  endKey?: IndexKey;
-  endInclusive?: boolean;
-  targetMaxRows?: number;
-  absoluteMaxRows?: number;
-};
-type KeyPageResult<T> = {
-  page: T[];
-  indexKeys: IndexKey[];
-  hasMore: boolean;
-};
-/**
- * Extract full document type from a ConvexTable (includes system fields)
- * Uses GetColumnData in 'query' mode to respect notNull brands
- *
- * @example
- * const users = convexTable('users', { name: text().notNull() });
- * type User = InferSelectModel<typeof users>;
- * // → { id: string, createdAt: number, name: string }
- *
- * const posts = convexTable('posts', { title: text() }); // nullable
- * type Post = InferSelectModel<typeof posts>;
- * // → { id: string, createdAt: number, title: string | null }
- */
-type InferSelectModel<TTable extends ConvexTable<any>> = Simplify<Merge<{
-  id: string;
-  createdAt: number;
-}, { [K in keyof TTable['_']['columns']]: GetColumnData<TTable['_']['columns'][K], 'query'> }>>;
-type RequiredKeyOnly<TKey extends string, TColumn extends ColumnBuilder<any, any, any>> = TColumn['_']['notNull'] extends true ? TColumn['_']['hasDefault'] extends true ? never : TKey : never;
-type OptionalKeyOnly<TKey extends string, TColumn extends ColumnBuilder<any, any, any>> = TColumn['_']['notNull'] extends true ? TColumn['_']['hasDefault'] extends true ? TKey : never : TKey;
-/**
- * Extract insert type from a ConvexTable (excludes system fields).
- * Mirrors Drizzle behavior: required if notNull && no default, otherwise optional.
- *
- * @example
- * const users = convexTable('users', { name: text().notNull() });
- * type NewUser = InferInsertModel<typeof users>;
- * // → { name: string }
- */
-type InferInsertModel<TTable extends ConvexTable<any>> = Simplify<{ [K in keyof TTable['_']['columns'] & string as RequiredKeyOnly<K, TTable['_']['columns'][K]>]: GetColumnData<TTable['_']['columns'][K], 'query'> } & { [K in keyof TTable['_']['columns'] & string as OptionalKeyOnly<K, TTable['_']['columns'][K]>]?: GetColumnData<TTable['_']['columns'][K], 'query'> | undefined }>;
-/**
- * Extract column data type with mode-based handling (Drizzle pattern)
- *
- * Following Drizzle's GetColumnData pattern for consistent type extraction:
- * - 'raw' mode: Returns base data type without null (for inserts, operator comparisons)
- * - 'query' mode: Respects notNull brand, adds | null for nullable fields (for selects)
- *
- * @template TColumn - Column builder type
- * @template TInferMode - 'query' (default, adds | null) or 'raw' (base type only)
- *
- * @example
- * const name = text().notNull();
- * type NameQuery = GetColumnData<typeof name, 'query'>; // string
- * type NameRaw = GetColumnData<typeof name, 'raw'>; // string
- *
- * const age = integer(); // nullable
- * type AgeQuery = GetColumnData<typeof age, 'query'>; // number | null
- * type AgeRaw = GetColumnData<typeof age, 'raw'>; // number
- */
-type GetColumnData<TColumn extends ColumnBuilder<any, any, any>, TInferMode extends 'query' | 'raw' = 'query'> = TInferMode extends 'raw' ? TColumn['_'] extends {
-  $type: infer TType;
-} ? TType : TColumn['_']['data'] : TColumn['_']['notNull'] extends true ? TColumn['_'] extends {
-  $type: infer TType;
-} ? TType : TColumn['_']['data'] : (TColumn['_'] extends {
-  $type: infer TType;
-} ? TType : TColumn['_']['data']) | null;
-/**
- * Query configuration for findMany/findFirst
- *
- * @template TRelationType - 'one' or 'many' determines available options
- * @template TSchema - Full schema configuration
- * @template TTableConfig - Configuration for the queried table
- */
-type DBQueryConfig<TRelationType extends 'one' | 'many' = 'one' | 'many', _TIsRoot extends boolean = boolean, TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTableConfig extends TableRelationalConfig = TableRelationalConfig> = {
-  /**
-   * Column selection - pick specific columns to return
-   * If omitted, all columns are selected
-   */
-  columns?: { [K in keyof TableColumns<TTableConfig>]?: boolean } | undefined;
-  /**
-   * Relation loading - specify which relations to include
-   * Can be `true` for default config or nested config object
-   */
-  with?: KnownKeysOnly<{ [K in keyof TTableConfig['relations']]?: true | DBQueryConfig<TTableConfig['relations'][K] extends One<any, any> ? 'one' : 'many', false, TSchema, FindTableByDBName<TSchema, TTableConfig['relations'][K]['targetTableName']>> | undefined }, TTableConfig['relations']> | undefined;
-  /**
-   * Extra computed fields (post-fetch, computed in JS at runtime)
-   */
-  extras?: Record<string, Value | ((row: InferModelFromColumns<TableColumns<TTableConfig>>) => Value)> | ((fields: Simplify<[TableColumns<TTableConfig>] extends [never] ? {} : TableColumns<TTableConfig>>) => Record<string, Value | ((row: InferModelFromColumns<TableColumns<TTableConfig>>) => Value)>) | undefined;
-  /**
-   * Order results - callback or object syntax
-   */
-  orderBy?: DBQueryConfigOrderBy<TTableConfig> | undefined; /** Skip first N results */
-  offset?: number | undefined;
-  /**
-   * Cursor pagination (Convex native). When `cursor` is provided, `limit` is
-   * required and the result type changes to a paginated shape.
-   *
-   * - First page: cursor: null
-   * - Next page: cursor: previous.continueCursor
-   */
-  cursor?: _TIsRoot extends true ? string | null : never;
-  /**
-   * Pin the end boundary to a previously returned cursor.
-   * Only valid with cursor pagination.
-   */
-  endCursor?: _TIsRoot extends true ? string | null : never;
-  /**
-   * Maximum documents to scan during predicate `where(fn)` pagination.
-   * Only valid when `cursor` is provided.
-   */
-  maxScan?: _TIsRoot extends true ? number : never;
-  /**
-   * Full-text search query configuration.
-   * Only available on tables that declare search indexes.
-   */
-  search?: SearchQueryConfig<TTableConfig> | undefined;
-  /**
-   * Vector search query configuration.
-   * Only available on tables that declare vector indexes.
-   */
-  vectorSearch?: VectorQueryConfig<TTableConfig> | undefined;
-  /**
-   * Stream-backed advanced query pipeline.
-   */
-  pipeline?: _TIsRoot extends true ? FindManyPipelineConfig<TSchema, TTableConfig> : never;
-  /**
-   * Key-based page boundaries.
-   */
-  pageByKey?: _TIsRoot extends true ? FindManyPageByKeyConfig : never;
-} & (TRelationType extends 'many' ? {
-  /** Limit number of results */limit?: number | undefined;
-} : {}) & {
-  /**
-   * Relation-aware filter object (v1) or callback expression.
-   */
-  where?: RelationsFilter<TTableConfig, TSchema> | WhereCallback<TTableConfig> | undefined;
-  /**
-   * Allow full scans when no index can be used.
-   */
-  allowFullScan?: boolean | undefined;
-};
-type PredicateWhereClause<TTableConfig extends TableRelationalConfig> = {
-  readonly __kind: 'predicate';
-  readonly predicate: (row: InferModelFromColumns<TableColumns<TTableConfig>>) => boolean | Promise<boolean>;
-};
-type WhereCallback<TTableConfig extends TableRelationalConfig> = (table: TTableConfig['table'], operators: FilterOperators<TTableConfig>) => FilterExpression<boolean> | PredicateWhereClause<TTableConfig> | undefined;
-type PredicateWhereIndexMap<TTableConfig extends TableRelationalConfig> = TTableConfig['table'] extends ConvexTable<any, infer TIndexes, any, any> ? TIndexes : Record<string, GenericIndexFields>;
-type PredicateWhereIndexName<TTableConfig extends TableRelationalConfig> = Extract<keyof PredicateWhereIndexMap<TTableConfig>, string>;
-type PredicateWhereNamedIndex<TTableConfig extends TableRelationalConfig, TIndexName extends string> = TIndexName extends PredicateWhereIndexName<TTableConfig> ? PredicateWhereIndexMap<TTableConfig>[TIndexName] extends GenericIndexFields ? PredicateWhereIndexMap<TTableConfig>[TIndexName] : GenericIndexFields : GenericIndexFields;
-type PredicateWhereIndexConfig<TTableConfig extends TableRelationalConfig = TableRelationalConfig> = [PredicateWhereIndexName<TTableConfig>] extends [never] ? {
-  name: string;
-  range?: (q: IndexRangeBuilder<InferModelFromColumns<TableColumns<TTableConfig>>, GenericIndexFields>) => IndexRange;
-} : { [TIndexName in PredicateWhereIndexName<TTableConfig>]: {
-  name: TIndexName;
-  range?: (q: IndexRangeBuilder<InferModelFromColumns<TableColumns<TTableConfig>>, PredicateWhereNamedIndex<TTableConfig, TIndexName>>) => IndexRange;
-} }[PredicateWhereIndexName<TTableConfig>];
-type SearchIndexMap<TTableConfig extends TableRelationalConfig> = TTableConfig['table'] extends ConvexTable<any, any, infer TSearchIndexes, any> ? TSearchIndexes : Record<string, {
-  searchField: string;
-  filterFields: string;
-}>;
-type SearchIndexName<TTableConfig extends TableRelationalConfig> = Extract<keyof SearchIndexMap<TTableConfig>, string>;
-type SearchIndexConfigByName<TTableConfig extends TableRelationalConfig, TIndexName extends SearchIndexName<TTableConfig>> = SearchIndexMap<TTableConfig>[TIndexName];
-type SearchFilterFieldNames<TTableConfig extends TableRelationalConfig, TIndexName extends SearchIndexName<TTableConfig>> = SearchIndexConfigByName<TTableConfig, TIndexName> extends {
-  filterFields: infer TFilterFields extends string;
-} ? TFilterFields : never;
-type SearchFilterValueForField<TTableConfig extends TableRelationalConfig, TFieldName extends string> = TFieldName extends keyof TableColumns<TTableConfig> ? TableColumns<TTableConfig>[TFieldName] extends ColumnBuilder<any, any, any> ? GetColumnData<TableColumns<TTableConfig>[TFieldName], 'raw'> : never : never;
-type SearchFiltersForIndex<TTableConfig extends TableRelationalConfig, TIndexName extends SearchIndexName<TTableConfig>> = Partial<{ [K in SearchFilterFieldNames<TTableConfig, TIndexName>]: SearchFilterValueForField<TTableConfig, K> }>;
-type SearchQueryConfig<TTableConfig extends TableRelationalConfig = TableRelationalConfig> = [SearchIndexName<TTableConfig>] extends [never] ? never : { [TIndexName in SearchIndexName<TTableConfig>]: {
-  index: TIndexName;
-  query: string;
-  filters?: SearchFiltersForIndex<TTableConfig, TIndexName> | undefined;
-} }[SearchIndexName<TTableConfig>];
-type SearchWhereFilter<TTableConfig extends TableRelationalConfig> = TableFilter<TTableConfig['table']>;
-type VectorIndexMap<TTableConfig extends TableRelationalConfig> = TTableConfig['table'] extends ConvexTable<any, any, any, infer TVectorIndexes> ? TVectorIndexes : Record<string, {
-  vectorField: string;
-  dimensions: number;
-  filterFields: string;
-}>;
-type VectorIndexName<TTableConfig extends TableRelationalConfig> = Extract<keyof VectorIndexMap<TTableConfig>, string>;
-type VectorIndexConfigByName<TTableConfig extends TableRelationalConfig, TIndexName extends VectorIndexName<TTableConfig>> = VectorIndexMap<TTableConfig>[TIndexName];
-type VectorFilterFieldNames<TTableConfig extends TableRelationalConfig, TIndexName extends VectorIndexName<TTableConfig>> = VectorIndexConfigByName<TTableConfig, TIndexName> extends {
-  filterFields: infer TFilterFields extends string;
-} ? TFilterFields : never;
-type VectorFilterForIndex<TTableConfig extends TableRelationalConfig, TIndexName extends VectorIndexName<TTableConfig>> = (q: VectorFilterBuilder<InferModelFromColumns<TableColumns<TTableConfig>>, VectorIndexConfigByName<TTableConfig, TIndexName>>) => FilterExpression$1<boolean>;
-type VectorQueryConfig<TTableConfig extends TableRelationalConfig = TableRelationalConfig> = [VectorIndexName<TTableConfig>] extends [never] ? never : { [TIndexName in VectorIndexName<TTableConfig>]: {
-  index: TIndexName;
-  vector: number[];
-  limit: number;
-  includeScore?: boolean | undefined;
-  filter?: (VectorFilterFieldNames<TTableConfig, TIndexName> extends never ? never : VectorFilterForIndex<TTableConfig, TIndexName>) | undefined;
-} }[VectorIndexName<TTableConfig>];
-type VectorSearchProvider = (tableName: string, indexName: string, query: {
-  vector: number[];
-  limit: number;
-  filter?: ((q: any) => unknown) | undefined;
-}) => Promise<Array<{
-  _id: GenericId<string> | string;
-  _score: number;
-}>>;
-type FullScanOperatorKey = 'arrayContains' | 'arrayContained' | 'arrayOverlaps' | 'ilike' | 'notLike' | 'notIlike' | 'endsWith' | 'contains' | 'RAW';
-type HasFullScanOperatorKey<T> = Extract<keyof T, FullScanOperatorKey> extends never ? false : true;
-type DepthPrev = [0, 0, 1, 2, 3, 4, 5, 6, 7, 8];
-type HasStaticFullScanWhere<TWhere, TDepth extends number = 6> = [TDepth] extends [0] ? false : TWhere extends ((...args: any[]) => any) ? false : TWhere extends string | number | boolean | bigint | null | undefined ? false : TWhere extends readonly (infer TItem)[] ? HasStaticFullScanWhere<TItem, DepthPrev[TDepth]> : TWhere extends object ? HasFullScanOperatorKey<TWhere> extends true ? true : 'NOT' extends keyof TWhere ? true : true extends { [K in keyof TWhere]-?: HasStaticFullScanWhere<TWhere[K], DepthPrev[TDepth]> }[keyof TWhere] ? true : false : false;
-type ReturnsPredicateClause<TWhere> = TWhere extends ((...args: any[]) => infer TResult) ? Extract<NonNullable<TResult>, PredicateWhereClause<any>> extends never ? false : true : false;
-type EnforceWithIndexForWhere<TConfig, _TTableConfig extends TableRelationalConfig, THasIndex extends boolean> = THasIndex extends true ? TConfig : TConfig extends {
-  where: infer TWhere;
-} ? ReturnsPredicateClause<TWhere> extends true ? never : HasStaticFullScanWhere<TWhere> extends true ? never : TConfig : TConfig;
-type EnforceNoAllowFullScanWhenIndexed<TConfig, THasIndex extends boolean> = THasIndex extends true ? Omit<TConfig, 'allowFullScan'> & {
-  allowFullScan?: never;
-} : TConfig;
-type EnforceCursorMaxScan<TConfig> = TConfig extends {
-  cursor: string | null;
-} ? TConfig extends {
-  where: infer TWhere;
-} ? HasStaticFullScanWhere<TWhere> extends true ? Omit<TConfig, 'allowFullScan'> & {
-  maxScan: number;
-  allowFullScan?: never;
-} : TConfig : TConfig : TConfig;
-type EnforceSearchConstraints<TConfig, TTableConfig extends TableRelationalConfig> = 'search' extends keyof TConfig ? TConfig extends {
-  search: infer TSearch;
-} ? [TSearch] extends [undefined] ? TConfig : Omit<TConfig, 'where' | 'orderBy' | 'vectorSearch'> & {
-  search: TSearch;
-  where?: SearchWhereFilter<TTableConfig> | undefined;
-  orderBy?: never;
-  vectorSearch?: never;
-} : TConfig : TConfig;
-type EnforceVectorSearchConstraints<TConfig, _TTableConfig extends TableRelationalConfig> = 'vectorSearch' extends keyof TConfig ? TConfig extends {
-  vectorSearch: infer TVectorSearch;
-} ? [TVectorSearch] extends [undefined] ? TConfig : Omit<TConfig, 'search' | 'where' | 'orderBy' | 'cursor' | 'maxScan' | 'offset' | 'limit' | 'allowFullScan'> & {
-  vectorSearch: TVectorSearch;
-  search?: never;
-  where?: never;
-  orderBy?: never;
-  cursor?: never;
-  maxScan?: never;
-  offset?: never;
-  limit?: never;
-  allowFullScan?: never;
-} : TConfig : TConfig;
-/**
- * Filter operators available in where clause
- * Following Drizzle pattern: accept column builders directly, extract types with GetColumnData
- *
- * Operators use 'raw' mode for comparisons (no null union in comparison values)
- * Runtime wraps builders with column() helper for FilterExpression construction
- */
-interface FilterOperators<TTableConfig extends TableRelationalConfig = TableRelationalConfig> {
-  and(...expressions: (FilterExpression<boolean> | undefined)[]): FilterExpression<boolean> | undefined;
-  or(...expressions: (FilterExpression<boolean> | undefined)[]): FilterExpression<boolean> | undefined;
-  not(expression: FilterExpression<boolean>): FilterExpression<boolean>;
-  eq<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, value: GetColumnData<TBuilder, 'raw'>): FilterExpression<boolean>;
-  ne<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, value: GetColumnData<TBuilder, 'raw'>): FilterExpression<boolean>;
-  gt<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, value: GetColumnData<TBuilder, 'raw'>): FilterExpression<boolean>;
-  gte<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, value: GetColumnData<TBuilder, 'raw'>): FilterExpression<boolean>;
-  lt<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, value: GetColumnData<TBuilder, 'raw'>): FilterExpression<boolean>;
-  lte<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, value: GetColumnData<TBuilder, 'raw'>): FilterExpression<boolean>;
-  between<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, min: GetColumnData<TBuilder, 'raw'>, max: GetColumnData<TBuilder, 'raw'>): FilterExpression<boolean>;
-  notBetween<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, min: GetColumnData<TBuilder, 'raw'>, max: GetColumnData<TBuilder, 'raw'>): FilterExpression<boolean>;
-  inArray<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, values: readonly GetColumnData<TBuilder, 'raw'>[]): FilterExpression<boolean>;
-  notInArray<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, values: readonly GetColumnData<TBuilder, 'raw'>[]): FilterExpression<boolean>;
-  arrayContains<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, values: readonly GetColumnData<TBuilder, 'raw'>[]): FilterExpression<boolean>;
-  arrayContained<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, values: readonly GetColumnData<TBuilder, 'raw'>[]): FilterExpression<boolean>;
-  arrayOverlaps<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, values: readonly GetColumnData<TBuilder, 'raw'>[]): FilterExpression<boolean>;
-  isNull<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder extends {
-    _: {
-      notNull: true;
-    };
-  } ? never : TBuilder): FilterExpression<boolean>;
-  isNotNull<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder): FilterExpression<boolean>;
-  like<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, pattern: string): FilterExpression<boolean>;
-  ilike<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, pattern: string): FilterExpression<boolean>;
-  notLike<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, pattern: string): FilterExpression<boolean>;
-  notIlike<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, pattern: string): FilterExpression<boolean>;
-  startsWith<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, prefix: string): FilterExpression<boolean>;
-  endsWith<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, suffix: string): FilterExpression<boolean>;
-  contains<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, substring: string): FilterExpression<boolean>;
-  predicate(predicate: (row: InferModelFromColumns<TableColumns<TTableConfig>>) => boolean | Promise<boolean>): PredicateWhereClause<TTableConfig>;
-}
-/**
- * Order by clause - represents a single field ordering
- * Following Drizzle pattern for type-safe ordering
- *
- * @template TColumn - Column builder type
- */
-interface OrderByClause<TColumn extends ColumnBuilder<any, any, any>> {
-  readonly column: Column<TColumn, string>;
-  readonly direction: 'asc' | 'desc';
-}
-/**
- * Order by input - either a column builder (default ASC)
- * or an explicit order by clause from asc()/desc().
- */
-type OrderByValue<TColumn extends ColumnBuilder<any, any, any> = ColumnBuilder<any, any, any>> = OrderByClause<TColumn> | TColumn;
-/**
- * Order direction helpers
- */
-interface OrderDirection {
-  asc: <TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder) => OrderByClause<TBuilder>;
-  desc: <TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder) => OrderByClause<TBuilder>;
-}
-type DBQueryConfigOrderByCallback<TTable extends ConvexTable<any>> = (table: TTable, operators: OrderDirection) => ValueOrArray<OrderByValue> | undefined;
-type DBQueryConfigOrderByObject<TColumns extends Record<string, unknown>> = { [K in keyof TColumns]?: 'asc' | 'desc' | undefined };
-type DBQueryConfigOrderBy<TTableConfig extends TableRelationalConfig> = DBQueryConfigOrderByCallback<TTableConfig['table']> | DBQueryConfigOrderByObject<TableColumns<TTableConfig>>;
-/**
- * Build query result type from configuration
- * Handles column selection and relation loading
- *
- * @template TSchema - Full schema configuration
- * @template TTableConfig - Configuration for queried table
- * @template TConfig - Query configuration (true | config object)
- */
-/**
- * Infer selected columns from a raw selection using Drizzle v1 semantics.
- * - Any `true` => include-only
- * - All `false` => exclude-only
- * - Empty / all undefined => no columns
- */
-type InferRelationalQueryTableResult<TRawSelection extends Record<string, unknown>, TSelectedFields extends Record<string, unknown> | 'Full' = 'Full'> = TSelectedFields extends 'Full' ? TRawSelection : { [K in Equal<Exclude<TSelectedFields[keyof TSelectedFields & keyof TRawSelection], undefined>, false> extends true ? Exclude<keyof TRawSelection, NonUndefinedKeysOnly$1<TSelectedFields>> : { [K in keyof TSelectedFields]: Equal<TSelectedFields[K], true> extends true ? K : never }[keyof TSelectedFields] & keyof TRawSelection]: TRawSelection[K] };
-type TableColumns<TTableConfig extends TableRelationalConfig> = TTableConfig['table']['_']['columns'] & SystemFields<TTableConfig['table']['_']['name']> & SystemFieldAliases<TTableConfig['table']['_']['name'], TTableConfig['table']['_']['columns']>;
-type PaginatedResult<T> = {
-  page: T[];
-  continueCursor: string | null;
-  isDone: boolean;
-  pageStatus?: 'SplitRecommended' | 'SplitRequired';
-  splitCursor?: string;
-};
-type BuildQueryResult<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig, TFullSelection> = Equal<TFullSelection, true> extends true ? InferModelFromColumns<TableColumns<TTableConfig>> : TFullSelection extends Record<string, unknown> ? Simplify<InferRelationalQueryTableResult<InferModelFromColumns<TableColumns<TTableConfig>>, TFullSelection['columns'] extends Record<string, unknown> ? TFullSelection['columns'] : 'Full'> & (Exclude<TFullSelection['extras'], undefined> extends Record<string, unknown> | ((...args: any[]) => Record<string, unknown>) ? ReturnTypeOrValue<Exclude<TFullSelection['extras'], undefined>> extends infer TExtras extends Record<string, unknown> ? { [K in NonUndefinedKeysOnly$1<TExtras>]: ReturnTypeOrValue<TExtras[K]> } : {} : {}) & (Exclude<TFullSelection['with'], undefined> extends Record<string, unknown> ? BuildRelationResult<TSchema, Exclude<TFullSelection['with'], undefined>, TTableConfig['relations']> : {}) & (TFullSelection extends {
-  vectorSearch: infer TVectorSearch;
-} ? [TVectorSearch] extends [undefined] ? {} : {
-  _score?: number;
-} : {})> : never;
-/**
- * Build relation result types from `with` configuration
- * Maps each included relation to its result type (T | null for one, T[] for many)
- *
- * Following Drizzle's exact pattern for type inference
- *
- * @template TSchema - Full schema configuration
- * @template TInclude - Relations to include from `with` config
- * @template TRelations - Available relations on the table
- */
-type BuildRelationResult<TSchema extends TablesRelationalConfig, TInclude extends Record<string, unknown>, TRelations extends RelationsRecord> = { [K in NonUndefinedKeysOnly$1<TInclude> & keyof TRelations]: TRelations[K] extends infer TRel extends Relation<any> ? BuildQueryResult<TSchema, FindTableByDBName<TSchema, TRel['targetTableName']>, Assume<TInclude[K], true | Record<string, unknown>>> extends infer TResult ? TRel extends One<any, any> ? TResult | (Equal<TRel['optional'], true> extends true ? null : TInclude[K] extends Record<string, unknown> ? TInclude[K]['where'] extends Record<string, any> ? null : never : never) : TResult[] : never : never };
-/**
- * Extract TypeScript types from column validators
- * Includes system fields for query results
- * Following Drizzle pattern: query results always include system fields
- * Uses GetColumnData in 'query' mode to respect notNull brands
- *
- * CRITICAL: No extends constraint to avoid type widening (convex-ents pattern)
- * CRITICAL: Uses Merge instead of & to preserve NotNull phantom type brands
- */
-type InferModelFromColumns<TColumns> = TColumns extends Record<string, ColumnBuilder<any, any, any>> ? Simplify<{ [K in keyof TColumns]: GetColumnData<TColumns[K], 'query'> }> : never;
-/**
- * Extract union of all values from an object type
- * Pattern from Drizzle: drizzle-orm/src/relations.ts:145
- */
-type ExtractObjectValues<T> = T[keyof T];
-/**
- * Find table configuration by database name
- * Pattern from Drizzle: drizzle-orm/src/relations.ts:198-208
- *
- * Uses mapped type with key remapping to avoid `infer` widening.
- * The `as` clause filters to only matching keys, then ExtractObjectValues
- * extracts the single table value without creating unions.
- */
-type FindTableByDBName<TSchema extends TablesRelationalConfig, TDBName extends string> = ExtractObjectValues<{ [K in keyof TSchema as TSchema[K]['name'] extends TDBName ? K : never]: TSchema[K] }>;
-type PipelineFlatMapTargetRow<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig, TRelationName extends PipelineRelationName<TTableConfig>> = TTableConfig['relations'][TRelationName] extends infer TRelation extends Relation<any> ? BuildQueryResult<TSchema, FindTableByDBName<TSchema, TRelation['targetTableName']>, true> : never;
-type PipelineFlatMapOutput<TCurrentRow, TFlatMapConfig, TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig> = TFlatMapConfig extends {
-  relation: infer TRelationName extends PipelineRelationName<TTableConfig>;
-} ? TFlatMapConfig extends {
-  includeParent: false;
-} ? PipelineFlatMapTargetRow<TSchema, TTableConfig, TRelationName> : {
-  parent: TCurrentRow;
-  child: PipelineFlatMapTargetRow<TSchema, TTableConfig, TRelationName>;
-} : never;
-type ApplyPipelineStage<TCurrentRow, TStage, TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig> = TStage extends FindManyPipelineFilterWithStage<any> ? TCurrentRow : TStage extends {
-  map: (...args: any[]) => infer TMapOutput;
-} ? NonNullable<Awaited<TMapOutput>> : TStage extends FindManyPipelineDistinctStage ? TCurrentRow : TStage extends {
-  flatMap: infer TFlatMapConfig;
-} ? PipelineFlatMapOutput<TCurrentRow, TFlatMapConfig, TSchema, TTableConfig> : TCurrentRow;
-/**
- * Filter object keys to only non-undefined values
- * Used to filter `with` config to only included relations
- */
-type NonUndefinedKeysOnly$1<T> = ExtractObjectValues<{ [K in keyof T as T[K] extends undefined ? never : K]: K }> & keyof T;
-type TableColumnsForTable<TTable extends ConvexTable<any>> = TTable['_']['columns'] & SystemFields<TTable['_']['name']> & SystemFieldAliases<TTable['_']['name'], TTable['_']['columns']>;
-type ReturningSelection<TTable extends ConvexTable<any>> = Record<string, TableColumnsForTable<TTable>[keyof TableColumnsForTable<TTable>]>;
-type ReturningResult<TSelection extends Record<string, ColumnBuilder<any, any, any>>> = Simplify<{ [K in keyof TSelection]: TSelection[K] extends ColumnBuilder<any, any, any> ? GetColumnData<TSelection[K], 'query'> : never }>;
-type ReturningAll<TTable extends ConvexTable<any>> = InferSelectModel<TTable>;
-type MutationReturning = true | Record<string, ColumnBuilder<any, any, any>> | undefined;
-type MutationResult<TTable extends ConvexTable<any>, TReturning extends MutationReturning> = TReturning extends true ? ReturningAll<TTable>[] : TReturning extends Record<string, ColumnBuilder<any, any, any>> ? ReturningResult<TReturning>[] : undefined;
-type MutationPaginateConfig = {
-  cursor: string | null;
-  limit: number;
-};
-type MutationRunMode = 'sync' | 'async';
-type MutationExecuteConfig = {
-  mode?: MutationRunMode;
-  batchSize?: number;
-  delayMs?: number;
-};
-type MutationAsyncConfig = Omit<MutationExecuteConfig, 'mode'>;
-type MutationExecutionMode = 'single' | 'paged';
-type MutationPaginatedResult<TTable extends ConvexTable<any>, TReturning extends MutationReturning> = Simplify<{
-  continueCursor: string | null;
-  isDone: boolean;
-  numAffected: number;
-} & (MutationResult<TTable, TReturning> extends undefined ? {} : {
-  page: MutationResult<TTable, TReturning>;
-})>;
-type MutationExecuteResult<TTable extends ConvexTable<any>, TReturning extends MutationReturning, TMode extends MutationExecutionMode> = TMode extends 'paged' ? MutationPaginatedResult<TTable, TReturning> : MutationResult<TTable, TReturning>;
-type InsertValue<TTable extends ConvexTable<any>> = InferInsertModel<TTable>;
-type UpdateSetValue<TColumn extends ColumnBuilder<any, any, any>> = GetColumnData<TColumn, 'query'> | (TColumn['_']['notNull'] extends true ? never : UnsetToken) | undefined;
-type UpdateSet<TTable extends ConvexTable<any>> = Simplify<{ [K in keyof TTable['_']['columns'] & string]?: UpdateSetValue<TTable['_']['columns'][K]> }>;
-//#endregion
-//#region src/orm/indexes.d.ts
-type ConvexIndexColumn = ColumnBuilderBase;
-interface ConvexIndexConfig<TName extends string = string, TColumns extends readonly ConvexIndexColumn[] = ConvexIndexColumn[], TUnique extends boolean = boolean> {
-  name: TName;
-  columns: TColumns;
-  unique: TUnique;
-  where?: unknown;
-}
-interface ConvexSearchIndexConfig<TName extends string = string, TSearchField extends ConvexIndexColumn = ConvexIndexColumn, TFilterFields extends readonly ConvexIndexColumn[] = ConvexIndexColumn[]> {
-  name: TName;
-  searchField: TSearchField;
-  filterFields: TFilterFields;
-  staged: boolean;
-}
-interface ConvexVectorIndexConfig<TName extends string = string, TVectorField extends ConvexIndexColumn = ConvexIndexColumn, TFilterFields extends readonly ConvexIndexColumn[] = ConvexIndexColumn[]> {
-  name: TName;
-  vectorField: TVectorField;
-  dimensions: number;
-  filterFields: TFilterFields;
-  staged: boolean;
-}
-declare class ConvexIndexBuilderOn<TName extends string = string, TUnique extends boolean = boolean> {
-  private name;
-  private unique;
-  static readonly [entityKind] = "ConvexIndexBuilderOn";
-  readonly [entityKind] = "ConvexIndexBuilderOn";
-  constructor(name: TName, unique: TUnique);
-  on<TColumns extends [ConvexIndexColumn, ...ConvexIndexColumn[]]>(...columns: TColumns): ConvexIndexBuilder<TName, TColumns, TUnique>;
-}
-declare class ConvexIndexBuilder<TName extends string = string, TColumns extends readonly [ConvexIndexColumn, ...ConvexIndexColumn[]] = [ConvexIndexColumn, ...ConvexIndexColumn[]], TUnique extends boolean = boolean> {
-  static readonly [entityKind] = "ConvexIndexBuilder";
-  readonly [entityKind] = "ConvexIndexBuilder";
-  _: {
-    brand: 'ConvexIndexBuilder';
-    name: TName;
-    columns: TColumns;
-    unique: TUnique;
-  };
-  config: ConvexIndexConfig<TName, TColumns, TUnique>;
-  constructor(name: TName, columns: TColumns, unique: TUnique);
-  /**
-   * Partial index conditions are not supported in Convex.
-   * This method is kept for Drizzle API parity.
-   */
-  where(condition: unknown): this;
-}
-declare class ConvexSearchIndexBuilderOn<TName extends string = string> {
-  private name;
-  static readonly [entityKind] = "ConvexSearchIndexBuilderOn";
-  readonly [entityKind] = "ConvexSearchIndexBuilderOn";
-  constructor(name: TName);
-  on<TSearchField extends ConvexIndexColumn>(searchField: TSearchField): ConvexSearchIndexBuilder<TName, TSearchField>;
-}
-declare class ConvexSearchIndexBuilder<TName extends string = string, TSearchField extends ConvexIndexColumn = ConvexIndexColumn, TFilterFields extends readonly ConvexIndexColumn[] = ConvexIndexColumn[]> {
-  static readonly [entityKind] = "ConvexSearchIndexBuilder";
-  readonly [entityKind] = "ConvexSearchIndexBuilder";
-  _: {
-    brand: 'ConvexSearchIndexBuilder';
-    name: TName;
-    searchField: TSearchField;
-    filterFields: TFilterFields;
-  };
-  config: ConvexSearchIndexConfig<TName, TSearchField, TFilterFields>;
-  constructor(name: TName, searchField: TSearchField);
-  filter<TNextFilterFields extends readonly ConvexIndexColumn[]>(...fields: TNextFilterFields): ConvexSearchIndexBuilder<TName, TSearchField, TNextFilterFields>;
-  staged(): this;
-}
-type ConvexVectorIndexConfigInternal = Omit<ConvexVectorIndexConfig<string, ConvexIndexColumn, readonly ConvexIndexColumn[]>, 'dimensions'> & {
-  dimensions?: number;
-};
-declare class ConvexVectorIndexBuilderOn<TName extends string = string> {
-  private name;
-  static readonly [entityKind] = "ConvexVectorIndexBuilderOn";
-  readonly [entityKind] = "ConvexVectorIndexBuilderOn";
-  constructor(name: TName);
-  on<TVectorField extends ConvexIndexColumn>(vectorField: TVectorField): ConvexVectorIndexBuilder<TName, TVectorField>;
-}
-declare class ConvexVectorIndexBuilder<TName extends string = string, TVectorField extends ConvexIndexColumn = ConvexIndexColumn, TFilterFields extends readonly ConvexIndexColumn[] = ConvexIndexColumn[]> {
-  static readonly [entityKind] = "ConvexVectorIndexBuilder";
-  readonly [entityKind] = "ConvexVectorIndexBuilder";
-  _: {
-    brand: 'ConvexVectorIndexBuilder';
-    name: TName;
-    vectorField: TVectorField;
-    filterFields: TFilterFields;
-  };
-  config: ConvexVectorIndexConfigInternal & {
-    name: TName;
-    vectorField: TVectorField;
-    filterFields: TFilterFields;
-  };
-  constructor(name: TName, vectorField: TVectorField);
-  dimensions(dimensions: number): this;
-  filter<TNextFilterFields extends readonly ConvexIndexColumn[]>(...fields: TNextFilterFields): ConvexVectorIndexBuilder<TName, TVectorField, TNextFilterFields>;
-  staged(): this;
-}
-declare function index<TName extends string>(name: TName): ConvexIndexBuilderOn<TName, false>;
-declare function uniqueIndex<TName extends string>(name: TName): ConvexIndexBuilderOn<TName, true>;
-declare function searchIndex<TName extends string>(name: TName): ConvexSearchIndexBuilderOn<TName>;
-declare function vectorIndex<TName extends string>(name: TName): ConvexVectorIndexBuilderOn<TName>;
-//#endregion
-//#region src/orm/rls/roles.d.ts
-interface RlsRoleConfig {
-  createDb?: boolean;
-  createRole?: boolean;
-  inherit?: boolean;
-}
-declare class RlsRole implements RlsRoleConfig {
-  readonly name: string;
-  static readonly [entityKind]: string;
-  readonly [entityKind]: string;
-  /** @internal */
-  _existing?: boolean;
-  /** @internal */
-  readonly createDb: RlsRoleConfig['createDb'];
-  /** @internal */
-  readonly createRole: RlsRoleConfig['createRole'];
-  /** @internal */
-  readonly inherit: RlsRoleConfig['inherit'];
-  constructor(name: string, config?: RlsRoleConfig);
-  existing(): this;
-}
-declare function rlsRole(name: string, config?: RlsRoleConfig): RlsRole;
-//#endregion
-//#region src/orm/rls/policies.d.ts
-type RlsPolicyToOption = 'public' | 'current_role' | 'current_user' | 'session_user' | (string & {}) | RlsRole | RlsPolicyToOption[];
-type PolicyExpression<TCtx, TTable> = FilterExpression<boolean> | ((ctx: TCtx, table: TTable) => FilterExpression<boolean> | Promise<FilterExpression<boolean>>);
-interface RlsPolicyConfig<TCtx = any, TTable = ConvexTableWithColumns<any>> {
-  as?: 'permissive' | 'restrictive';
-  for?: 'all' | 'select' | 'insert' | 'update' | 'delete';
-  to?: RlsPolicyToOption;
-  using?: PolicyExpression<TCtx, TTable>;
-  withCheck?: PolicyExpression<TCtx, TTable>;
-}
-declare class RlsPolicy<TCtx = any, TTable = ConvexTableWithColumns<any>> implements RlsPolicyConfig<TCtx, TTable> {
-  readonly name: string;
-  static readonly [entityKind]: string;
-  readonly [entityKind]: string;
-  readonly as: RlsPolicyConfig<TCtx, TTable>['as'];
-  readonly for: RlsPolicyConfig<TCtx, TTable>['for'];
-  readonly to: RlsPolicyConfig<TCtx, TTable>['to'];
-  readonly using: RlsPolicyConfig<TCtx, TTable>['using'];
-  readonly withCheck: RlsPolicyConfig<TCtx, TTable>['withCheck'];
-  /** @internal */
-  _linkedTable?: ConvexTable<any>;
-  constructor(name: string, config?: RlsPolicyConfig<TCtx, TTable>);
-  link(table: ConvexTable<any>): this;
-}
-declare function rlsPolicy<TCtx = any, TTable = ConvexTableWithColumns<any>>(name: string, config?: RlsPolicyConfig<TCtx, TTable>): RlsPolicy<TCtx, TTable>;
-//#endregion
-//#region src/orm/table.d.ts
-/**
- * Configuration for a Convex table
- * Only supports column builders (text(), integer(), etc.)
- *
- * CRITICAL: No extends constraint on TColumns to avoid type widening (convex-ents pattern)
- */
-interface TableConfig<TName extends string = string, TColumns = any> {
-  name: TName;
-  columns: TColumns;
-}
-type ColumnsWithTableName<TColumns, TName extends string> = { [K in keyof TColumns]: TColumns[K] extends ColumnBuilderBase ? ColumnBuilderWithTableName<TColumns[K], TName> & {
-  _: {
-    fieldName: K extends string ? K : never;
-  };
-} : TColumns[K] };
-type ColumnsWithSystemFields<TColumns, TName extends string> = ColumnsWithTableName<TColumns, TName> & (TColumns extends Record<string, unknown> ? SystemFieldsWithAliases<TName, TColumns> : SystemFieldsWithAliases<TName>);
-type ConvexTableExtraConfigValue = ConvexIndexBuilder | ConvexSearchIndexBuilder | ConvexVectorIndexBuilder | ConvexForeignKeyBuilder | ConvexCheckBuilder | ConvexUniqueConstraintBuilder | ConvexDeletionBuilder | ConvexLifecycleBuilder | OrmTriggerLike | RlsPolicy;
-type ConvexTableExtraConfig = Record<string, ConvexTableExtraConfigValue>;
-type UnionToIntersection<T> = (T extends unknown ? (arg: T) => void : never) extends ((arg: infer U) => void) ? U : never;
-type SimplifyObject<T> = { [K in keyof T]: T[K] };
-type ExtraConfigValues<TExtraConfig> = TExtraConfig extends readonly (infer TValue)[] ? TValue : TExtraConfig extends Record<string, infer TValue> ? TValue : never;
-type ColumnNameFromBuilder<TColumn extends ColumnBuilderBase> = TColumn extends {
-  _: {
-    fieldName: infer TFieldName extends string;
-  };
-} ? TFieldName : never;
-type IndexFieldTupleFromColumns<TColumns extends readonly [ConvexIndexColumn, ...ConvexIndexColumn[]]> = [...{ [K in keyof TColumns]: TColumns[K] extends ConvexIndexColumn ? ColumnNameFromBuilder<TColumns[K]> : never }, '_creationTime'];
-type InferDbIndexRecordFromExtraValue<TValue> = TValue extends ConvexIndexBuilder<infer TName extends string, infer TColumns extends readonly [ConvexIndexColumn, ...ConvexIndexColumn[]], boolean> ? Record<TName, IndexFieldTupleFromColumns<TColumns>> : {};
-type SearchFilterFieldsUnionFromColumns<TColumns extends readonly ConvexIndexColumn[]> = TColumns[number] extends infer TColumn extends ConvexIndexColumn ? ColumnNameFromBuilder<TColumn> : never;
-type InferSearchIndexRecordFromExtraValue<TValue> = TValue extends ConvexSearchIndexBuilder<infer TName extends string, infer TSearchField extends ConvexIndexColumn, infer TFilterFields extends readonly ConvexIndexColumn[]> ? Record<TName, {
-  searchField: ColumnNameFromBuilder<TSearchField>;
-  filterFields: SearchFilterFieldsUnionFromColumns<TFilterFields>;
-}> : {};
-type InferVectorIndexRecordFromExtraValue<TValue> = TValue extends ConvexVectorIndexBuilder<infer TName extends string, infer TVectorField extends ConvexIndexColumn, infer TFilterFields extends readonly ConvexIndexColumn[]> ? Record<TName, {
-  vectorField: ColumnNameFromBuilder<TVectorField>;
-  dimensions: number;
-  filterFields: SearchFilterFieldsUnionFromColumns<TFilterFields>;
-}> : {};
-type InferredDbIndexesFromExtraConfig<TExtraConfig> = UnionToIntersection<InferDbIndexRecordFromExtraValue<ExtraConfigValues<Exclude<TExtraConfig, undefined>>>>;
-type InferredSearchIndexesFromExtraConfig<TExtraConfig> = UnionToIntersection<InferSearchIndexRecordFromExtraValue<ExtraConfigValues<Exclude<TExtraConfig, undefined>>>>;
-type InferredVectorIndexesFromExtraConfig<TExtraConfig> = UnionToIntersection<InferVectorIndexRecordFromExtraValue<ExtraConfigValues<Exclude<TExtraConfig, undefined>>>>;
-type NormalizeDbIndexMap<TIndexMap> = { [K in keyof TIndexMap as K extends string ? K : never]: TIndexMap[K] extends string[] ? TIndexMap[K] : never };
-type NormalizeSearchIndexMap<TIndexMap> = { [K in keyof TIndexMap as K extends string ? K : never]: TIndexMap[K] extends {
-  searchField: infer TSearchField extends string;
-  filterFields: infer TFilterFields extends string;
-} ? {
-  searchField: TSearchField;
-  filterFields: TFilterFields;
-} : never };
-type NormalizeVectorIndexMap<TIndexMap> = { [K in keyof TIndexMap as K extends string ? K : never]: TIndexMap[K] extends {
-  vectorField: infer TVectorField extends string;
-  dimensions: infer TDimensions extends number;
-  filterFields: infer TFilterFields extends string;
-} ? {
-  vectorField: TVectorField;
-  dimensions: TDimensions;
-  filterFields: TFilterFields;
-} : never };
-type InferDbIndexesFromExtraConfig<TExtraConfig> = SimplifyObject<{
-  by_creation_time: ['_creationTime'];
-} & NormalizeDbIndexMap<InferredDbIndexesFromExtraConfig<TExtraConfig>>>;
-type InferSearchIndexesFromExtraConfig<TExtraConfig> = SimplifyObject<NormalizeSearchIndexMap<InferredSearchIndexesFromExtraConfig<TExtraConfig>>>;
-type InferVectorIndexesFromExtraConfig<TExtraConfig> = SimplifyObject<NormalizeVectorIndexMap<InferredVectorIndexesFromExtraConfig<TExtraConfig>>>;
-type ConvexDeletionConfig = {
-  mode: OrmDeleteMode;
-  delayMs?: number;
-};
-type OrmLifecycleOperation = 'insert' | 'update' | 'delete';
-type OrmLifecycleChange<TDoc = Record<string, unknown>> = {
-  id: unknown;
-} & ({
-  operation: 'insert';
-  oldDoc: null;
-  newDoc: TDoc;
-} | {
-  operation: 'update';
-  oldDoc: TDoc;
-  newDoc: TDoc;
-} | {
-  operation: 'delete';
-  oldDoc: TDoc;
-  newDoc: null;
-});
-type OrmLifecycleChangeFor<TOperation extends OrmLifecycleOperation | 'change', TDoc = Record<string, unknown>> = TOperation extends 'insert' ? Extract<OrmLifecycleChange<TDoc>, {
-  operation: 'insert';
-}> : TOperation extends 'update' ? Extract<OrmLifecycleChange<TDoc>, {
-  operation: 'update';
-}> : TOperation extends 'delete' ? Extract<OrmLifecycleChange<TDoc>, {
-  operation: 'delete';
-}> : OrmLifecycleChange<TDoc>;
-type OrmLifecycleHandler<TOperation extends OrmLifecycleOperation | 'change' = 'change', TDoc = Record<string, unknown>> = (ctx: {
-  db: unknown;
-  innerDb: unknown;
-} & Record<string, unknown>, change: OrmLifecycleChangeFor<TOperation, TDoc>) => Promise<void> | void;
-type OrmLifecycleConfig = {
-  operation: 'insert';
-  handler: OrmLifecycleHandler<'insert'>;
-} | {
-  operation: 'update';
-  handler: OrmLifecycleHandler<'update'>;
-} | {
-  operation: 'delete';
-  handler: OrmLifecycleHandler<'delete'>;
-} | {
-  operation: 'change';
-  handler: OrmLifecycleHandler<'change'>;
-};
-type OrmTriggerLike<TDoc = Record<string, unknown>, TCtx = Record<string, unknown>> = {
-  bivarianceHack: (ctx: TCtx, change: OrmLifecycleChange<TDoc>) => Promise<void> | void;
-}['bivarianceHack'];
-declare class ConvexDeletionBuilder {
-  readonly config: ConvexDeletionConfig;
-  static readonly [entityKind] = "ConvexDeletionBuilder";
-  readonly [entityKind] = "ConvexDeletionBuilder";
-  constructor(config: ConvexDeletionConfig);
-}
-declare function deletion(mode: OrmDeleteMode, options?: {
-  delayMs?: number;
-}): ConvexDeletionBuilder;
-declare class ConvexLifecycleBuilder {
-  readonly config: OrmLifecycleConfig;
-  static readonly [entityKind] = "ConvexLifecycleBuilder";
-  readonly [entityKind] = "ConvexLifecycleBuilder";
-  constructor(config: OrmLifecycleConfig);
-}
-declare function onInsert<TDoc = Record<string, unknown>>(handler: OrmLifecycleHandler<'insert', TDoc>): ConvexLifecycleBuilder;
-declare function onUpdate<TDoc = Record<string, unknown>>(handler: OrmLifecycleHandler<'update', TDoc>): ConvexLifecycleBuilder;
-declare function onDelete<TDoc = Record<string, unknown>>(handler: OrmLifecycleHandler<'delete', TDoc>): ConvexLifecycleBuilder;
-declare function onChange<TDoc = Record<string, unknown>>(handler: OrmLifecycleHandler<'change', TDoc>): ConvexLifecycleBuilder;
-/**
- * ConvexTable interface with type branding
- * Extends TableDefinition for schema compatibility
- * Adds phantom types for type inference
- *
- * Following Drizzle pattern: columns are exposed as table properties
- * via mapped type for type safety + Object.assign for runtime access
- */
-interface ConvexTable<T extends TableConfig, Indexes extends GenericTableIndexes = {}, SearchIndexes extends GenericTableSearchIndexes = {}, VectorIndexes extends GenericTableVectorIndexes = {}> extends TableDefinition<Validator<any, any, any>, Indexes, SearchIndexes, VectorIndexes> {
-  /**
-   * Type brand for generic type extraction
-   * Uses `declare readonly` to avoid runtime overhead
-   */
-  readonly _: {
-    readonly brand: 'ConvexTable';
-    readonly name: T['name'];
-    readonly columns: T['columns'];
-    readonly inferSelect: InferSelectModel<ConvexTable<T>>;
-    readonly inferInsert: InferInsertModel<ConvexTable<T>>;
-  };
-  /**
-   * Inferred types for select and insert operations
-   * Following Drizzle's pattern: $inferSelect and $inferInsert properties
-   */
-  readonly $inferSelect: InferSelectModel<ConvexTable<T>>;
-  readonly $inferInsert: InferInsertModel<ConvexTable<T>>;
-  /**
-   * Symbol-based metadata storage
-   */
-  [TableName]: T['name'];
-  [Columns]: T['columns'];
-  [Brand]: 'ConvexTable';
-  [RlsPolicies]: RlsPolicy[];
-  [EnableRLS]: boolean;
-  [TableDeleteConfig]?: OrmTableDeleteConfig;
-  [TableLifecycleHooks]: OrmLifecycleConfig[];
-  /**
-   * Convex schema validator
-   */
-  validator: Validator<any, any, any>;
-  tableName: T['name'];
-}
-/**
- * ConvexTable with columns as properties
- * Following Drizzle's PgTableWithColumns pattern
- * Mapped type makes columns accessible: table.columnName
- * Includes public system fields (id, createdAt) available on all Convex documents
- */
-type ConvexTableWithColumns<T extends TableConfig, Indexes extends GenericTableIndexes = {}, SearchIndexes extends GenericTableSearchIndexes = {}, VectorIndexes extends GenericTableVectorIndexes = {}> = ConvexTable<T, Indexes, SearchIndexes, VectorIndexes> & { [Key in keyof T['columns']]: T['columns'][Key] } & SystemFields<T['name']> & SystemFieldAliases<T['name'], T['columns']>;
-/**
- * Create a type-safe Convex table definition
- *
- * Uses Drizzle-style column builders:
- * - text().notNull(), integer(), boolean(), etc.
- *
- * @param name - Table name (must be valid Convex table name)
- * @param columns - Column builders
- * @returns ConvexTable instance compatible with defineSchema()
- *
- * @example
- * import { convexTable, text, integer } from 'better-convex/orm';
- *
- * const users = convexTable('users', {
- *   name: text().notNull(),
- *   email: text().notNull(),
- *   age: integer(),
- * });
- *
- * // Use in schema - works with defineSchema()
- * export default defineSchema({ users });
- *
- * // Extract types
- * type User = InferSelectModel<typeof users>;
- * type NewUser = InferInsertModel<typeof users>;
- *
- * // Indexes
- * const usersWithIndex = convexTable('users', { email: text() }, (t) => [
- *   index('by_email').on(t.email),
- * ]);
- */
-type ConvexTableFnInternal = <TName extends string, TColumns, TExtraConfig extends ConvexTableExtraConfigValue[] | ConvexTableExtraConfig | undefined = undefined>(name: TName, columns: TColumns, extraConfig?: (self: ColumnsWithSystemFields<TColumns, TName>) => TExtraConfig) => ConvexTableWithColumns<{
-  name: TName;
-  columns: ColumnsWithTableName<TColumns, TName>;
-}, InferDbIndexesFromExtraConfig<TExtraConfig>, InferSearchIndexesFromExtraConfig<TExtraConfig>, InferVectorIndexesFromExtraConfig<TExtraConfig>>;
-interface ConvexTableFn extends ConvexTableFnInternal {
-  withRLS: ConvexTableFnInternal;
-}
-declare const convexTable: ConvexTableFn;
-//#endregion
-//#region src/orm/relations.d.ts
-type SchemaEntry = ConvexTable<any>;
-type Schema = Record<string, SchemaEntry>;
-type ExtractTablesFromSchema<TSchema extends Record<string, unknown>> = { [K in keyof TSchema as TSchema[K] extends SchemaEntry ? K extends string ? K : never : never]: Extract<TSchema[K], SchemaEntry> };
-type IncludeEveryTable<TTables extends Schema> = { [K in keyof TTables]: {} };
-declare class RelationsBuilderTable<TTableName extends string = string> {
-  static readonly [entityKind]: string;
-  protected readonly _: {
-    readonly name: TTableName;
-    readonly table: SchemaEntry;
-  };
-  constructor(table: SchemaEntry, name: TTableName);
-}
-interface RelationsBuilderColumnConfig<TTableName extends string = string> {
-  readonly tableName: TTableName;
-  readonly column: ColumnBuilder<any, any, any>;
-  readonly through?: RelationsBuilderColumnBase;
-  readonly key: string;
-}
-interface RelationsBuilderColumnBase<TTableName extends string = string> {
-  _: RelationsBuilderColumnConfig<TTableName>;
-}
-declare class RelationsBuilderColumn<TTableName extends string = string> implements RelationsBuilderColumnBase<TTableName> {
-  static readonly [entityKind]: string;
-  readonly _: {
-    readonly tableName: TTableName;
-    readonly column: ColumnBuilder<any, any, any>;
-    readonly key: string;
-  };
-  constructor(column: ColumnBuilder<any, any, any>, tableName: TTableName, key: string);
-  through(column: RelationsBuilderColumn): RelationsBuilderJunctionColumn<TTableName>;
-}
-declare class RelationsBuilderJunctionColumn<TTableName extends string = string> implements RelationsBuilderColumnBase<TTableName> {
-  static readonly [entityKind]: string;
-  readonly _: {
-    readonly tableName: TTableName;
-    readonly column: ColumnBuilder<any, any, any>;
-    readonly through: RelationsBuilderColumnBase;
-    readonly key: string;
-  };
-  constructor(column: ColumnBuilder<any, any, any>, tableName: TTableName, key: string, through: RelationsBuilderColumnBase);
-}
-interface OneConfig<TTargetTable extends SchemaEntry, TOptional extends boolean> {
-  from?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
-  to?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
-  where?: TableFilter<TTargetTable>;
-  optional?: TOptional;
-  alias?: string;
-}
-type AnyOneConfig = OneConfig<SchemaEntry, boolean>;
-interface ManyConfig<TTargetTable extends SchemaEntry> {
-  from?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
-  to?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
-  where?: TableFilter<TTargetTable>;
-  alias?: string;
-}
-type AnyManyConfig = ManyConfig<SchemaEntry>;
-type OneFn<TTargetTable extends SchemaEntry, TTargetTableName extends string> = <TOptional extends boolean = true>(config?: OneConfig<TTargetTable, TOptional>) => One<TTargetTableName, TOptional>;
-type ManyFn<TTargetTable extends SchemaEntry, TTargetTableName extends string> = (config?: ManyConfig<TTargetTable>) => Many<TTargetTableName>;
-declare class RelationsHelperStatic<TTables extends Schema> {
-  static readonly [entityKind]: string;
-  constructor(tables: TTables);
-  one: { [K in keyof TTables]: OneFn<TTables[K], K & string> };
-  many: { [K in keyof TTables]: ManyFn<TTables[K], K & string> };
-}
-type RelationsBuilderColumns<TTable extends SchemaEntry, TTableName extends string> = { [K in keyof GetTableColumns<TTable>]: RelationsBuilderColumn<TTableName> };
-type GetTableColumns<TTable extends SchemaEntry> = TTable extends ConvexTable<any> ? TTable['_']['columns'] & SystemFields<TTable['_']['name']> & SystemFieldAliases<TTable['_']['name'], TTable['_']['columns']> : never;
-type RelationsBuilderTables<TSchema extends Schema> = { [TTableName in keyof TSchema]: RelationsBuilderColumns<TSchema[TTableName], TTableName & string> & RelationsBuilderTable<TTableName & string> };
-type RelationsBuilder<TSchema extends Schema> = RelationsBuilderTables<TSchema> & RelationsHelperStatic<TSchema>;
-type RelationsBuilderConfigValue = RelationsRecord | undefined;
-type RelationsBuilderConfig<TTables extends Schema> = { [TTableName in keyof TTables]?: RelationsBuilderConfigValue };
-type AnyRelationsBuilderConfig = Record<string, RelationsBuilderConfigValue>;
-type RelationsRecord = Record<string, AnyRelation>;
-declare abstract class Relation<TTargetTableName extends string = string> {
-  readonly targetTableName: TTargetTableName;
-  static readonly [entityKind]: string;
-  readonly $brand: 'RelationV2';
-  readonly relationType: 'many' | 'one';
-  fieldName: string;
-  sourceColumns: ColumnBuilder<any, any, any>[];
-  targetColumns: ColumnBuilder<any, any, any>[];
-  alias: string | undefined;
-  where: Record<string, unknown> | undefined;
-  sourceTable: SchemaEntry;
-  targetTable: SchemaEntry;
-  through?: {
-    source: RelationsBuilderColumnBase[];
-    target: RelationsBuilderColumnBase[];
-  };
-  throughTable?: SchemaEntry;
-  isReversed?: boolean;
-  /** @internal */
-  sourceColumnTableNames: string[];
-  /** @internal */
-  targetColumnTableNames: string[];
-  constructor(targetTable: SchemaEntry, targetTableName: TTargetTableName);
-}
-type AnyRelation = Relation<string>;
-declare class One<TTargetTableName extends string, TOptional extends boolean = boolean> extends Relation<TTargetTableName> {
-  static readonly [entityKind]: string;
-  protected $relationBrand: 'OneV2';
-  readonly relationType: "one";
-  readonly optional: TOptional;
-  constructor(tables: Schema, targetTable: SchemaEntry, targetTableName: TTargetTableName, config: AnyOneConfig | undefined);
-}
-declare class Many<TTargetTableName extends string> extends Relation<TTargetTableName> {
-  readonly config: AnyManyConfig | undefined;
-  static readonly [entityKind]: string;
-  protected $relationBrand: 'ManyV2';
-  readonly relationType: "many";
-  constructor(tables: Schema, targetTable: SchemaEntry, targetTableName: TTargetTableName, config: AnyManyConfig | undefined);
-}
-interface TableRelationalConfig {
-  table: SchemaEntry;
-  name: string;
-  relations: RelationsRecord;
-  strict?: boolean;
-  defaults?: OrmRuntimeDefaults;
-}
-type TablesRelationalConfig<SchemaDef extends SchemaDefinition$1<any, boolean> = SchemaDefinition$1<any, true>, Tables extends Record<string, TableRelationalConfig> = Record<string, TableRelationalConfig>> = Tables & {
-  [OrmSchemaDefinition]?: SchemaDef;
-};
-type RelationsConfigWithSchema<TConfig extends AnyRelationsBuilderConfig, TTables extends Schema> = TablesRelationalConfig<SchemaDefinition$1<TTables, true>, ExtractTablesWithRelations<TConfig, TTables>>;
-type RelationsPartsConfigWithSchema<TConfig extends AnyRelationsBuilderConfig, TTables extends Schema> = TablesRelationalConfig<SchemaDefinition$1<TTables, true>, ExtractTablesWithRelationsParts<TConfig, TTables>>;
-type Placeholder = {
-  readonly __placeholder?: true;
-};
-type SQLWrapper = {
-  readonly __sqlWrapper?: true;
-};
-interface SQLOperator {
-  sql: (...args: any[]) => unknown;
-}
-interface RelationFieldsFilterInternals<T> {
-  eq?: T | Placeholder | undefined;
-  ne?: T | Placeholder | undefined;
-  gt?: T | Placeholder | undefined;
-  gte?: T | Placeholder | undefined;
-  lt?: T | Placeholder | undefined;
-  lte?: T | Placeholder | undefined;
-  between?: [T | Placeholder, T | Placeholder] | Placeholder | undefined;
-  notBetween?: [T | Placeholder, T | Placeholder] | Placeholder | undefined;
-  in?: (T | Placeholder)[] | Placeholder | undefined;
-  notIn?: (T | Placeholder)[] | Placeholder | undefined;
-  arrayContains?: (T extends Array<infer E> ? (E | Placeholder)[] : (T | Placeholder)[]) | Placeholder | undefined;
-  arrayContained?: (T extends Array<infer E> ? (E | Placeholder)[] : (T | Placeholder)[]) | Placeholder | undefined;
-  arrayOverlaps?: (T extends Array<infer E> ? (E | Placeholder)[] : (T | Placeholder)[]) | Placeholder | undefined;
-  like?: string | Placeholder | undefined;
-  ilike?: string | Placeholder | undefined;
-  notLike?: string | Placeholder | undefined;
-  notIlike?: string | Placeholder | undefined;
-  startsWith?: string | Placeholder | undefined;
-  endsWith?: string | Placeholder | undefined;
-  contains?: string | Placeholder | undefined;
-  isNull?: true | undefined;
-  isNotNull?: true | undefined;
-  NOT?: RelationsFieldFilter<T> | undefined;
-  OR?: RelationsFieldFilter<T>[] | undefined;
-  AND?: RelationsFieldFilter<T>[] | undefined;
-}
-type RelationsFieldFilter<T = unknown> = RelationFieldsFilterInternals<T> | (unknown extends T ? never : T extends string | number | boolean | bigint | null | undefined ? T : T extends object ? never : T) | Placeholder;
-interface RelationsFilterCommons<TTable extends TableRelationalConfig = TableRelationalConfig, TSchema extends TablesRelationalConfig = TablesRelationalConfig> {
-  OR?: RelationsFilter<TTable, TSchema>[] | undefined;
-  NOT?: RelationsFilter<TTable, TSchema> | undefined;
-  AND?: RelationsFilter<TTable, TSchema>[] | undefined;
-  RAW?: SQLWrapper | ((table: TTable['table'], operators: SQLOperator) => unknown) | undefined;
-}
-type RelationsFilterColumns<TColumns extends Record<string, unknown>> = { [K in keyof TColumns]?: (TColumns[K] extends {
-  _: {
-    data: infer Data;
-  };
-} ? RelationsFieldFilter<Data> : RelationsFieldFilter<unknown>) | undefined };
-type FindTargetTableInRelationalConfig<TConfig extends TablesRelationalConfig, TRelation extends AnyRelation> = TConfig[TRelation['targetTableName']];
-type RelationsFilterRelations<TTable extends TableRelationalConfig, TSchema extends TablesRelationalConfig, TRelations extends RelationsRecord = TTable['relations']> = { [K in keyof TRelations]?: boolean | RelationsFilter<FindTargetTableInRelationalConfig<TSchema, TRelations[K]>, TSchema> | undefined };
-type RelationsFilter<TTable extends TableRelationalConfig, TSchema extends TablesRelationalConfig, TColumns extends Record<string, unknown> = GetTableColumns<TTable['table']>> = TTable['relations'] extends Record<string, never> ? TableFilter<TTable['table']> : Simplify<RelationsFilterColumns<TColumns> & RelationsFilterRelations<TTable, TSchema> & RelationsFilterCommons<TTable, TSchema>>;
-interface TableFilterCommons<TTable extends SchemaEntry = SchemaEntry, TColumns extends Record<string, unknown> = GetTableColumns<TTable>> {
-  OR?: TableFilter<TTable, TColumns>[] | undefined;
-  NOT?: TableFilter<TTable, TColumns> | undefined;
-  AND?: TableFilter<TTable, TColumns>[] | undefined;
-  RAW?: SQLWrapper | ((table: TTable, operators: SQLOperator) => unknown) | undefined;
-}
-type TableFilterColumns<TColumns extends Record<string, unknown>> = { [K in keyof TColumns]?: (TColumns[K] extends {
-  _: {
-    data: infer Data;
-  };
-} ? RelationsFieldFilter<Data> : RelationsFieldFilter<unknown>) | undefined };
-type TableFilter<TTable extends SchemaEntry = SchemaEntry, TColumns extends Record<string, unknown> = GetTableColumns<TTable>> = Simplify<TableFilterColumns<TColumns> & TableFilterCommons<TTable, TColumns>>;
-type ExtractTablesWithRelations<TConfig extends AnyRelationsBuilderConfig, TTables extends Schema> = { [K in keyof TTables]: {
-  table: TTables[K];
-  name: K & string;
-  relations: TConfig extends { [CK in K]: Record<string, any> } ? TConfig[K] : {};
-} };
-type ExtractTablesWithRelationsParts<TConfig extends AnyRelationsBuilderConfig, TTables extends Schema> = { [K in NonUndefinedKeysOnly<TConfig> & keyof TTables]: {
-  table: TTables[K & string];
-  name: K & string;
-  relations: TConfig[K] extends Record<string, any> ? TConfig[K] : {};
-} };
-type NonUndefinedKeysOnly<T> = { [K in keyof T]: T[K] extends undefined ? never : K }[keyof T];
-/** Builds relational config for every table in schema */
-declare function defineRelations<TSchema extends Record<string, unknown>, TTables extends Schema = ExtractTablesFromSchema<TSchema>>(schema: TSchema): RelationsConfigWithSchema<{}, TTables>;
-/** Builds relational config for every table in schema */
-declare function defineRelations<TSchema extends Record<string, unknown>, TConfig extends RelationsBuilderConfig<TTables>, TTables extends Schema = ExtractTablesFromSchema<TSchema>>(schema: TSchema, relations: (helpers: RelationsBuilder<TTables>) => TConfig): RelationsConfigWithSchema<TConfig, TTables>;
-/** Builds relational config only for tables present in relational config */
-declare function defineRelationsPart<TSchema extends Record<string, unknown>, TTables extends Schema = ExtractTablesFromSchema<TSchema>>(schema: TSchema): RelationsPartsConfigWithSchema<IncludeEveryTable<TTables>, TTables>;
-/** Builds relational config only for tables present in relational config */
-declare function defineRelationsPart<TSchema extends Record<string, unknown>, TConfig extends RelationsBuilderConfig<TTables>, TTables extends Schema = ExtractTablesFromSchema<TSchema>>(schema: TSchema, relations: (helpers: RelationsBuilder<TTables>) => TConfig): RelationsPartsConfigWithSchema<TConfig, TTables>;
-//#endregion
-//#region src/orm/rls/types.d.ts
-type RlsMode = 'enforce' | 'skip';
-type RlsContext = {
-  /**
-   * Optional mode override. Defaults to "enforce".
-   */
-  mode?: RlsMode;
-  /**
-   * Request context passed to policy builders.
-   */
-  ctx?: unknown;
-  /**
-   * Optional role resolver for enforcing policy "to" clauses.
-   */
-  roleResolver?: (ctx: unknown) => string[];
-};
-//#endregion
-//#region src/orm/mutation-utils.d.ts
-type UniqueIndexDefinition = {
-  name: string;
-  fields: string[];
-  nullsNotDistinct: boolean;
-};
-type CheckDefinition = {
-  name: string;
-  expression: FilterExpression<boolean>;
-};
-type SerializedFieldReference = {
-  fieldName: string;
-};
-type SerializedBinaryExpression = {
-  type: 'binary';
-  operator: BinaryExpression['operator'];
-  field: SerializedFieldReference;
-  value: unknown;
-};
-type SerializedLogicalExpression = {
-  type: 'logical';
-  operator: LogicalExpression['operator'];
-  operands: SerializedFilterExpression[];
-};
-type SerializedUnaryExpression = {
-  type: 'unary';
-  operator: UnaryExpression['operator'];
-  operand: SerializedFilterExpression | SerializedFieldReference;
-};
-type SerializedFilterExpression = SerializedBinaryExpression | SerializedLogicalExpression | SerializedUnaryExpression;
-type ForeignKeyDefinition = {
-  name?: string;
-  columns: string[];
-  foreignColumns: string[];
-  foreignTableName: string;
-  foreignTable?: ConvexTable<any>;
-  onDelete?: ForeignKeyAction;
-  onUpdate?: ForeignKeyAction;
-};
-declare function getUniqueIndexes(table: ConvexTable<any>): UniqueIndexDefinition[];
-declare function getChecks(table: ConvexTable<any>): CheckDefinition[];
-declare function getForeignKeys(table: ConvexTable<any>): ForeignKeyDefinition[];
-type DeleteMode = OrmDeleteMode;
-type CascadeMode = 'hard' | 'soft';
-//#endregion
-//#region src/orm/query-promise.d.ts
-/**
- * Query Promise - Lazy query execution via Promise interface
- *
- * Implements Drizzle's QueryPromise pattern:
- * - Queries don't execute until awaited or .then() is called
- * - Implements full Promise interface (then/catch/finally)
- * - Subclasses provide execute() implementation
- *
- * @example
- * const query = ctx.db.query.users.findMany();
- * // Query not executed yet
- * const users = await query; // Now executed
- */
-/**
- * Abstract base class for promise-based query execution
- *
- * @template T - The result type returned by the query
- *
- * Pattern from Drizzle ORM: query-promise.ts:27-31
- */
-declare abstract class QueryPromise<T> implements Promise<T> {
-  /**
-   * Promise tag for debugging and type identification
-   */
-  [Symbol.toStringTag]: string;
-  /**
-   * Promise.then() implementation - delegates to execute()
-   * This enables lazy evaluation: queries only run when awaited
-   */
-  then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
-  /**
-   * Promise.catch() implementation - delegates to execute()
-   */
-  catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
-  /**
-   * Promise.finally() implementation - delegates to execute()
-   */
-  finally(onFinally?: (() => void) | undefined | null): Promise<T>;
-  /**
-   * Execute the query and return results
-   * Subclasses must implement this method
-   *
-   * @returns Promise resolving to query results
-   */
-  abstract execute(): Promise<T>;
-}
-//#endregion
-//#region src/orm/delete.d.ts
-type ConvexDeleteWithout<T extends ConvexDeleteBuilder<any, any, any>, K extends string> = Omit<T, K>;
-declare class ConvexDeleteBuilder<TTable extends ConvexTable<any>, TReturning extends MutationReturning = undefined, TMode extends MutationExecutionMode = 'single'> extends QueryPromise<MutationExecuteResult<TTable, TReturning, TMode>> {
-  private db;
-  private table;
-  readonly _: {
-    readonly table: TTable;
-    readonly returning: TReturning;
-    readonly mode: TMode;
-    readonly result: MutationExecuteResult<TTable, TReturning, TMode>;
-  };
-  private whereExpression?;
-  private returningFields?;
-  private allowFullScanFlag;
-  private deleteModeOverride?;
-  private cascadeMode?;
-  private scheduledDelayMs?;
-  private executionModeOverride?;
-  private paginateConfig?;
-  constructor(db: GenericDatabaseWriter<any>, table: TTable);
-  where(expression: FilterExpression<boolean>): this;
-  returning(): ConvexDeleteWithout<ConvexDeleteBuilder<TTable, true, TMode>, 'returning'>;
-  returning<TSelection extends ReturningSelection<TTable>>(fields: TSelection): ConvexDeleteWithout<ConvexDeleteBuilder<TTable, TSelection, TMode>, 'returning'>;
-  paginate(config: MutationPaginateConfig): ConvexDeleteWithout<ConvexDeleteBuilder<TTable, TReturning, 'paged'>, 'paginate'>;
-  allowFullScan(): this;
-  private getIdEquality;
-  soft(): this;
-  hard(): this;
-  scheduled(config: {
-    delayMs: number;
-  }): this;
-  private resolveDeleteModeAndDelay;
-  cascade(config: {
-    mode: CascadeMode;
-  }): this;
-  executeAsync(...args: TMode extends 'single' ? [config?: MutationAsyncConfig] : [config: never]): Promise<TMode extends 'single' ? MutationExecuteResult<TTable, TReturning, 'single'> : never>;
-  execute(...args: TMode extends 'single' ? [config?: MutationExecuteConfig] : [config?: never]): Promise<MutationExecuteResult<TTable, TReturning, TMode>>;
-}
-//#endregion
-//#region src/orm/extractRelationsConfig.d.ts
-/**
- * M2-M3 CONTRACT: EdgeMetadata interface
- * Consumed by query builder for relation traversal
- */
-interface EdgeMetadata {
-  /** Source table name (ts name) */
-  sourceTable: string;
-  /** Relation field name on source */
-  edgeName: string;
-  /** Target table name (ts name) */
-  targetTable: string;
-  /** Cardinality: one-to-one/many-to-one or one-to-many */
-  cardinality: 'one' | 'many';
-  /** Primary source field name (best-effort) */
-  fieldName: string;
-  /** Source field names (from) */
-  sourceFields: string[];
-  /** Target field names (to) */
-  targetFields: string[];
-  /**
-   * True when the FK columns on the source side are nullable (i.e. the relation
-   * can be absent). Used to avoid rejecting optional/self-referencing relations
-   * as "circular dependencies".
-   */
-  sourceNullable: boolean;
-  /** Inverse edge if bidirectional relation */
-  inverseEdge?: EdgeMetadata;
-  /** Index name for efficient lookups */
-  indexName: string;
-  /** Index fields for compound indexes */
-  indexFields: string[];
-  /** Relation optional (one only) */
-  optional: boolean;
-  /** Alias for disambiguation (v1 rename of relationName) */
-  alias?: string;
-  /** Many-to-many through info */
-  through?: {
-    table: string;
-    sourceFields: string[];
-    targetFields: string[];
-  };
-}
-/**
- * Extract relations configuration from defineRelations output
- */
-declare function extractRelationsConfig(schema: TablesRelationalConfig): EdgeMetadata[];
-//#endregion
-//#region src/orm/insert.d.ts
-type InsertOnConflictDoNothingConfig<_TTable extends ConvexTable<any>> = {
-  target?: ColumnBuilder<any, any, any> | ColumnBuilder<any, any, any>[];
-  where?: FilterExpression<boolean>;
-};
-type InsertOnConflictDoUpdateConfig<TTable extends ConvexTable<any>> = {
-  target: ColumnBuilder<any, any, any> | ColumnBuilder<any, any, any>[];
-  set: UpdateSet<TTable>;
-  where?: FilterExpression<boolean>;
-  targetWhere?: FilterExpression<boolean>;
-  setWhere?: FilterExpression<boolean>;
-};
-type ConvexInsertWithout<T extends ConvexInsertBuilder<any, any>, K extends string> = Omit<T, K>;
-declare class ConvexInsertBuilder<TTable extends ConvexTable<any>, TReturning extends MutationReturning = undefined> extends QueryPromise<MutationResult<TTable, TReturning>> {
-  private db;
-  private table;
-  readonly _: {
-    readonly table: TTable;
-    readonly returning: TReturning;
-    readonly result: MutationResult<TTable, TReturning>;
-  };
-  private valuesList;
-  private returningFields?;
-  private conflictConfig?;
-  private allowFullScanFlag;
-  constructor(db: GenericDatabaseWriter<any>, table: TTable);
-  values(values: InsertValue<TTable> | InsertValue<TTable>[]): this;
-  returning(): ConvexInsertWithout<ConvexInsertBuilder<TTable, true>, 'returning'>;
-  returning<TSelection extends ReturningSelection<TTable>>(fields: TSelection): ConvexInsertWithout<ConvexInsertBuilder<TTable, TSelection>, 'returning'>;
-  allowFullScan(): this;
-  onConflictDoNothing(config?: InsertOnConflictDoNothingConfig<TTable>): ConvexInsertWithout<this, 'onConflictDoNothing' | 'onConflictDoUpdate'>;
-  onConflictDoUpdate(config: InsertOnConflictDoUpdateConfig<TTable>): ConvexInsertWithout<this, 'onConflictDoNothing' | 'onConflictDoUpdate'>;
-  execute(): Promise<MutationResult<TTable, TReturning>>;
-  private resolveReturningRow;
-  private handleConflict;
-  private findConflictRow;
-  private findAnyUniqueConflictRow;
-}
-//#endregion
-//#region src/orm/query.d.ts
-/**
- * Relational query builder with promise-based execution
- *
- * @template TResult - The final result type after execution
- *
- * Pattern from Drizzle: gel-core/query-builders/query.ts:32-62
- */
-declare class GelRelationalQuery<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig, TResult> extends QueryPromise<TResult> {
-  private schema;
-  private tableConfig;
-  private edgeMetadata;
-  private db;
-  private config;
-  private mode;
-  private _allEdges?;
-  private rls?;
-  private relationLoading?;
-  private vectorSearchProvider?;
-  private configuredIndex?;
-  /**
-   * Type brand for result type extraction
-   * Critical for Expect<Equal<>> type tests to work correctly
-   * Following Drizzle pattern: allows TypeScript to infer result type before await
-   */
-  readonly _: {
-    readonly result: TResult;
-  };
-  private allowFullScan;
-  constructor(schema: TSchema, tableConfig: TTableConfig, edgeMetadata: EdgeMetadata[], db: GenericDatabaseReader<any>, config: DBQueryConfig<'one' | 'many', boolean, TSchema, TTableConfig>, mode: 'many' | 'first' | 'firstOrThrow', _allEdges?: EdgeMetadata[] | undefined, // M6.5 Phase 2: All edges for nested loading
-  rls?: RlsContext | undefined, relationLoading?: {
-    concurrency?: number;
-  } | undefined, vectorSearchProvider?: VectorSearchProvider | undefined, configuredIndex?: PredicateWhereIndexConfig<TTableConfig> | undefined);
-  private _usesSystemCreatedAtAlias;
-  private _assertNoLegacyPublicFieldName;
-  private _normalizePublicFieldName;
-  private _normalizeComparableValue;
-  private _toPublicRow;
-  private _extractIdOnlyWhere;
-  private _returnSelectedRows;
-  private _applyRlsSelectFilter;
-  private _isColumnBuilder;
-  private _isOrderByClause;
-  private _normalizeOrderByValue;
-  private _normalizeOrderBy;
-  private _orderBySpecs;
-  private _resolveNonPaginatedLimit;
-  private _compareByOrderSpecs;
-  private _getTableConfigByDbName;
-  private _matchLike;
-  /**
-   * Evaluate a filter expression against a fetched row
-   * Used for post-fetch filtering (string operators, etc.)
-   */
-  private _evaluatePostFetchFilter;
-  private _isRecord;
-  private _isPlaceholder;
-  private _isSQLWrapper;
-  private _evaluateFieldFilter;
-  private _evaluateTableFilter;
-  private _evaluateRelationsFilter;
-  private _buildFieldFilterExpression;
-  private _buildFilterExpression;
-  private _mergeWithConfig;
-  private _buildFilterWithConfig;
-  private _stripFilterRelations;
-  private _hasSearchDisallowedRelationFilter;
-  private _searchFilterValuesEqual;
-  private _extractSearchEqFromWhereField;
-  private _mergeSearchFiltersWithWhereEq;
-  private _applyRelationsFilterToRows;
-  private _finalizeRows;
-  private _getSchemaDefinitionOrThrow;
-  private _applyEqBounds;
-  private _buildTableFilterPredicate;
-  private _assertWhereIndexRequirement;
-  private _isFilterExpressionNode;
-  private _isPredicateWhereClause;
-  private _createFilterOperators;
-  private _resolveWhereCallbackExpression;
-  private _buildBasePipelineStream;
-  private _buildUnionSourceStream;
-  private _applyFlatMapStage;
-  private _applyPipelineStages;
-  /**
-   * Execute the query and return results
-   * Phase 4 implementation with WhereClauseCompiler integration
-   */
-  execute(): Promise<TResult>;
-  /**
-   * Convert query config to Convex query parameters
-   * Phase 4 implementation with WhereClauseCompiler
-   */
-  private _toConvexQuery;
-  private _buildRelationKey;
-  private _buildIndexPredicate;
-  private _buildFilterPredicate;
-  private _queryByFields;
-  private _getColumns;
-  /**
-   * Apply a single filter expression to a Convex query builder
-   * Used for index filters (eq operations)
-   */
-  private _applyFilterToQuery;
-  /**
-   * Convert FilterExpression to Convex filter function
-   * Uses visitor pattern to traverse expression tree
-   */
-  private _toConvexExpression;
-  /**
-   * Get edge metadata for a target table
-   * Helper for recursive relation loading
-   */
-  private _getTargetTableEdges;
-  private _getRelationConcurrency;
-  private _getRelationFanOutKeyCap;
-  private _enforceRelationFanOutKeyCap;
-  private _mapWithConcurrency;
-  /**
-   * Load relations for query results
-   * M6.5 Phase 2 implementation: Recursive relation loading with depth limiting
-   *
-   * @param rows - Array of parent records to load relations for
-   * @param withConfig - Relation configuration object
-   * @param depth - Current recursion depth (default 0)
-   * @param maxDepth - Maximum recursion depth (default 3)
-   * @param targetTableEdges - Edge metadata for nested relations (optional, defaults to this.edgeMetadata)
-   */
-  private _loadRelations;
-  /**
-   * Load a single relation for all rows
-   * Handles both one() and many() cardinality
-   * M6.5 Phase 2: Added support for nested relations
-   */
-  private _loadSingleRelation;
-  /**
-   * Load one() relation (many-to-one or one-to-one)
-   * Example: posts.author where posts.authorId → users.id
-   * M6.5 Phase 2: Added support for nested relations
-   */
-  private _loadOneRelation;
-  /**
-   * Load many() relation (one-to-many)
-   * Example: users.posts where posts.authorId → users.id
-   *
-   * For many() relations, use the configured from/to fields to match rows.
-   * Supports .through() for many-to-many relations via a junction table.
-   * M6.5 Phase 2: Added support for nested relations
-   * M6.5 Phase 3: Added support for where filters, orderBy, and per-parent limit
-   */
-  private _loadManyRelation;
-  private _applyExtras;
-  /**
-   * Select specific columns from rows
-   * Phase 5 implementation
-   */
-  private _selectColumns;
-}
-//#endregion
-//#region src/orm/query-builder.d.ts
-type EnforcedConfig<TConfig, TTableConfig extends TableRelationalConfig, THasIndex extends boolean = false> = EnforceVectorSearchConstraints<EnforceSearchConstraints<EnforceCursorMaxScan<EnforceNoAllowFullScanWhenIndexed<EnforceWithIndexForWhere<TConfig, TTableConfig, THasIndex>, THasIndex>>, TTableConfig>, TTableConfig>;
-type DisallowWithIndexSearchOrVector<THasIndex extends boolean> = THasIndex extends true ? {
-  search?: never;
-  vectorSearch?: never;
-} : unknown;
-type PredicateIndexName<TTableConfig extends TableRelationalConfig> = PredicateWhereIndexConfig<TTableConfig> extends {
-  name: infer TIndexName extends string;
-} ? TIndexName : string;
-type PredicateIndexConfigByName<TTableConfig extends TableRelationalConfig, TIndexName extends PredicateIndexName<TTableConfig>> = Extract<PredicateWhereIndexConfig<TTableConfig>, {
-  name: TIndexName;
-}>;
-type SearchPaginatedConfig<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig> = Omit<CursorPaginatedConfig<TSchema, TTableConfig>, 'search' | 'vectorSearch' | 'where' | 'orderBy'> & {
-  search: SearchQueryConfig<TTableConfig>;
-  vectorSearch?: never;
-  where?: SearchWhereFilter<TTableConfig> | undefined;
-  orderBy?: never;
-  pipeline?: never;
-  pageByKey?: never;
-  endCursor?: never;
-};
-type SearchNonPaginatedConfig<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig> = Omit<NonCursorConfig<TSchema, TTableConfig>, 'search' | 'vectorSearch' | 'where' | 'orderBy'> & {
-  search: SearchQueryConfig<TTableConfig>;
-  vectorSearch?: never;
-  where?: SearchWhereFilter<TTableConfig> | undefined;
-  orderBy?: never;
-  pipeline?: never;
-  pageByKey?: never;
-  endCursor?: never;
-};
-type SearchFindFirstConfig<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig> = Omit<DBQueryConfig<'many', true, TSchema, TTableConfig>, 'limit' | 'search' | 'vectorSearch' | 'where' | 'orderBy' | 'cursor' | 'maxScan' | 'pipeline'> & {
-  search: SearchQueryConfig<TTableConfig>;
-  vectorSearch?: never;
-  where?: SearchWhereFilter<TTableConfig> | undefined;
-  orderBy?: never;
-  pipeline?: never;
-};
-type VectorNonPaginatedConfig<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig> = Omit<DBQueryConfig<'many', true, TSchema, TTableConfig>, 'vectorSearch' | 'search' | 'where' | 'orderBy' | 'offset' | 'limit' | 'cursor' | 'maxScan' | 'allowFullScan' | 'pipeline'> & {
-  vectorSearch: VectorQueryConfig<TTableConfig>;
-  search?: never;
-  where?: never;
-  orderBy?: never;
-  offset?: never;
-  limit?: never;
-  cursor?: never;
-  maxScan?: never;
-  allowFullScan?: never;
-  pipeline?: never;
-  pageByKey?: never;
-  endCursor?: never;
-};
-type FindManyResult<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig, TConfig> = TConfig extends {
-  pageByKey: FindManyPageByKeyConfig;
-} ? KeyPageResult<BuildQueryResult<TSchema, TTableConfig, TConfig>> : TConfig extends {
-  cursor: string | null;
-} ? PaginatedResult<BuildQueryResult<TSchema, TTableConfig, TConfig>> : BuildQueryResult<TSchema, TTableConfig, TConfig>[];
-type CursorPaginatedConfig<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig> = Omit<DBQueryConfig<'many', true, TSchema, TTableConfig>, 'cursor' | 'limit' | 'pageByKey' | 'allowFullScan' | 'pipeline'> & {
-  cursor: string | null;
-  limit: number;
-  offset?: never;
-  pageByKey?: never;
-  allowFullScan?: never;
-  pipeline?: never;
-};
-type NonCursorConfig<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig> = Omit<DBQueryConfig<'many', true, TSchema, TTableConfig>, 'maxScan' | 'endCursor' | 'pipeline'> & {
-  cursor?: never;
-  maxScan?: never;
-  endCursor?: never;
-  pipeline?: never;
-};
-type KeyPageConfig<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig> = Omit<NonCursorConfigNoSearch<TSchema, TTableConfig>, 'pageByKey' | 'cursor' | 'maxScan' | 'endCursor' | 'offset' | 'pipeline'> & {
-  pageByKey: FindManyPageByKeyConfig;
-  cursor?: never;
-  maxScan?: never;
-  endCursor?: never;
-  offset?: never;
-  pipeline?: never;
-};
-type CursorPaginatedConfigNoSearch<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig> = Omit<CursorPaginatedConfig<TSchema, TTableConfig>, 'search'> & {
-  search?: undefined;
-  vectorSearch?: undefined;
-};
-type NonCursorConfigNoSearch<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig> = Omit<NonCursorConfig<TSchema, TTableConfig>, 'search'> & {
-  search?: undefined;
-  vectorSearch?: undefined;
-};
-type FindFirstConfigNoSearch<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig> = Omit<DBQueryConfig<'many', true, TSchema, TTableConfig>, 'limit' | 'search' | 'vectorSearch' | 'cursor' | 'maxScan' | 'endCursor' | 'pipeline' | 'pageByKey'> & {
-  search?: undefined;
-  vectorSearch?: undefined;
-  endCursor?: never;
-  pipeline?: never;
-  pageByKey?: never;
-};
-type SelectPipelineBaseConfig<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig> = Omit<DBQueryConfig<'many', true, TSchema, TTableConfig>, 'cursor' | 'maxScan' | 'endCursor' | 'pageByKey' | 'pipeline' | 'with' | 'extras' | 'columns' | 'search' | 'vectorSearch' | 'offset'> & {
-  cursor?: never;
-  maxScan?: never;
-  endCursor?: never;
-  pageByKey?: never;
-  pipeline?: never;
-  with?: never;
-  extras?: never;
-  columns?: never;
-  search?: never;
-  vectorSearch?: never;
-  offset?: never;
-};
-type ComposeFlatMapOutput<TCurrentRow, TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig, TRelationName extends Extract<keyof TTableConfig['relations'], string>, TIncludeParent extends boolean | undefined> = ApplyPipelineStage<TCurrentRow, {
-  flatMap: {
-    relation: TRelationName;
-    includeParent: TIncludeParent;
-  };
-}, TSchema, TTableConfig>;
-type PaginateConfig = {
-  cursor: string | null;
-  limit: number;
-  endCursor?: string | null;
-  maxScan?: number;
-};
-type QueryFactory<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig> = <TResult>(config: DBQueryConfig<'many', true, TSchema, TTableConfig>, mode: 'many' | 'first' | 'firstOrThrow', configuredIndex?: PredicateWhereIndexConfig<TTableConfig>) => GelRelationalQuery<TSchema, TTableConfig, TResult>;
-declare class RelationalSelectChain<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig, TRow, THasIndex extends boolean = false> extends QueryPromise<TRow[]> {
-  private readonly createQuery;
-  private readonly configuredIndex?;
-  private readonly config;
-  private readonly pipeline;
-  constructor(createQuery: QueryFactory<TSchema, TTableConfig>, config: SelectPipelineBaseConfig<TSchema, TTableConfig>, pipeline?: FindManyPipelineConfig<TSchema, TTableConfig>, configuredIndex?: PredicateWhereIndexConfig<TTableConfig> | undefined);
-  private withConfig;
-  private withPipeline;
-  private appendStage;
-  private asManyConfig;
-  execute(): Promise<TRow[]>;
-  where(where: SelectPipelineBaseConfig<TSchema, TTableConfig>['where']): RelationalSelectChain<TSchema, TTableConfig, TRow>;
-  withIndex<TIndexName extends PredicateIndexName<TTableConfig>>(indexName: TIndexName, range?: PredicateIndexConfigByName<TTableConfig, TIndexName>['range']): RelationalSelectChain<TSchema, TTableConfig, TRow, true>;
-  orderBy(orderBy: SelectPipelineBaseConfig<TSchema, TTableConfig>['orderBy']): RelationalSelectChain<TSchema, TTableConfig, TRow>;
-  limit(limit: number): RelationalSelectChain<TSchema, TTableConfig, TRow>;
-  allowFullScan(this: RelationalSelectChain<TSchema, TTableConfig, TRow, false>, allowFullScan: boolean): RelationalSelectChain<TSchema, TTableConfig, TRow>;
-  map<TOutput>(map: (row: TRow) => TOutput | null | Promise<TOutput | null>): RelationalSelectChain<TSchema, TTableConfig, NonNullable<Awaited<TOutput>>>;
-  filter(filter: (row: TRow) => boolean | Promise<boolean>): RelationalSelectChain<TSchema, TTableConfig, TRow>;
-  distinct(distinct: {
-    fields: string[];
-  }): RelationalSelectChain<TSchema, TTableConfig, TRow>;
-  flatMap<TRelationName extends Extract<keyof TTableConfig['relations'], string>, TIncludeParent extends boolean | undefined = undefined>(relation: TRelationName, options?: Omit<FindManyPipelineFlatMapConfig<TTableConfig, TRelationName>, 'relation'> & {
-    includeParent?: TIncludeParent;
-  }): RelationalSelectChain<TSchema, TTableConfig, ComposeFlatMapOutput<TRow, TSchema, TTableConfig, TRelationName, TIncludeParent>>;
-  union(union: FindManyUnionSource<TTableConfig>[]): RelationalSelectChain<TSchema, TTableConfig, TRow>;
-  interleaveBy(interleaveBy: string[]): RelationalSelectChain<TSchema, TTableConfig, TRow>;
-  paginate(config: PaginateConfig): GelRelationalQuery<TSchema, TTableConfig, PaginatedResult<TRow>>;
-  pageByKey(pageByKey: FindManyPageByKeyConfig): GelRelationalQuery<TSchema, TTableConfig, KeyPageResult<TRow>>;
-  first(): GelRelationalQuery<TSchema, TTableConfig, TRow | undefined>;
-  firstOrThrow(): GelRelationalQuery<TSchema, TTableConfig, TRow>;
-}
-/**
- * Query builder for a specific table
- *
- * Uses HKT (Higher-Kinded Type) pattern to prevent type widening.
- * The readonly `_` interface anchors the result type, preventing TypeScript
- * from re-evaluating TSchema[K] as a union of all tables.
- *
- * Pattern from Drizzle ORM:
- * drizzle-orm/src/pg-core/query-builders/select.ts:167-179
- *
- * @template TSchema - Full schema configuration
- * @template TTableConfig - Configuration for this specific table
- */
-declare class RelationalQueryBuilder<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig, THasIndex extends boolean = false> {
-  private schema;
-  private tableConfig;
-  private edgeMetadata;
-  private db;
-  private allEdges?;
-  private rls?;
-  private relationLoading?;
-  private vectorSearch?;
-  private queryIndex?;
-  /**
-   * Type anchor for HKT pattern
-   * Stores base result type in immutable property to prevent TypeScript from
-   * widening types during mapped type evaluation. Methods construct their
-   * return types (array, single, paginated) from this base type.
-   */
-  readonly _: {
-    readonly schema: TSchema;
-    readonly tableConfig: TTableConfig;
-    readonly baseResult: BuildQueryResult<TSchema, TTableConfig, true>;
-  };
-  constructor(schema: TSchema, tableConfig: TTableConfig, edgeMetadata: EdgeMetadata[], db: GenericDatabaseReader<any>, allEdges?: EdgeMetadata[] | undefined, // M6.5 Phase 2: All edges for nested loading
-  rls?: RlsContext | undefined, relationLoading?: {
-    concurrency?: number;
-  } | undefined, vectorSearch?: VectorSearchProvider | undefined, queryIndex?: PredicateWhereIndexConfig<TTableConfig> | undefined);
-  private createQuery;
-  select(): RelationalSelectChain<TSchema, TTableConfig, BuildQueryResult<TSchema, TTableConfig, true>, THasIndex>;
-  withIndex<TIndexName extends PredicateIndexName<TTableConfig>>(indexName: TIndexName, range?: PredicateIndexConfigByName<TTableConfig, TIndexName>['range']): RelationalQueryBuilder<TSchema, TTableConfig, true>;
-  /**
-   * Find many rows matching the query configuration
-   *
-   * @template TConfig - Query configuration type
-   * @param config - Optional query configuration (columns, with, where, orderBy, limit, offset)
-   * @returns Query promise that resolves to array of results
-   *
-   * @example
-   * const users = await ctx.db.query.users.findMany({
-   *   columns: { id: true, name: true },
-   *   with: { posts: { limit: 5 } },
-   *   where: { name: 'Alice' },
-   *   limit: 10
-   * });
-   */
-  findMany<TConfig extends SearchPaginatedConfig<TSchema, TTableConfig>>(config: KnownKeysOnly<TConfig, SearchPaginatedConfig<TSchema, TTableConfig>> & DisallowWithIndexSearchOrVector<THasIndex>): GelRelationalQuery<TSchema, TTableConfig, PaginatedResult<BuildQueryResult<TSchema, TTableConfig, TConfig>>>;
-  findMany<TConfig extends SearchNonPaginatedConfig<TSchema, TTableConfig>>(config: KnownKeysOnly<TConfig, SearchNonPaginatedConfig<TSchema, TTableConfig>> & DisallowWithIndexSearchOrVector<THasIndex>): GelRelationalQuery<TSchema, TTableConfig, BuildQueryResult<TSchema, TTableConfig, TConfig>[]>;
-  findMany<TConfig extends VectorNonPaginatedConfig<TSchema, TTableConfig>>(config: KnownKeysOnly<TConfig, VectorNonPaginatedConfig<TSchema, TTableConfig>> & DisallowWithIndexSearchOrVector<THasIndex>): GelRelationalQuery<TSchema, TTableConfig, BuildQueryResult<TSchema, TTableConfig, TConfig>[]>;
-  findMany<TConfig extends CursorPaginatedConfigNoSearch<TSchema, TTableConfig>>(config: KnownKeysOnly<TConfig, CursorPaginatedConfigNoSearch<TSchema, TTableConfig>> & EnforcedConfig<TConfig, TTableConfig, THasIndex>): GelRelationalQuery<TSchema, TTableConfig, PaginatedResult<BuildQueryResult<TSchema, TTableConfig, TConfig>>>;
-  findMany<TConfig extends NonCursorConfigNoSearch<TSchema, TTableConfig>>(config?: KnownKeysOnly<TConfig, NonCursorConfigNoSearch<TSchema, TTableConfig>> & EnforcedConfig<TConfig, TTableConfig, THasIndex>): GelRelationalQuery<TSchema, TTableConfig, FindManyResult<TSchema, TTableConfig, TConfig>>;
-  findMany<TConfig extends KeyPageConfig<TSchema, TTableConfig>>(config: KnownKeysOnly<TConfig, KeyPageConfig<TSchema, TTableConfig>> & EnforcedConfig<TConfig, TTableConfig, THasIndex>): GelRelationalQuery<TSchema, TTableConfig, KeyPageResult<BuildQueryResult<TSchema, TTableConfig, TConfig>>>;
-  /**
-   * Find first row matching the query configuration
-   * Automatically applies limit: 1
-   *
-   * @template TConfig - Query configuration type (without limit)
-   * @param config - Optional query configuration (columns, with, where, orderBy, offset)
-   * @returns Query promise that resolves to single result or undefined
-   *
-   * @example
-   * const user = await ctx.db.query.users.findFirst({
-   *   where: { email: 'alice@example.com' },
-   *   with: { profile: true }
-   * });
-   */
-  findFirst<TConfig extends SearchFindFirstConfig<TSchema, TTableConfig>>(config: KnownKeysOnly<TConfig, SearchFindFirstConfig<TSchema, TTableConfig>> & DisallowWithIndexSearchOrVector<THasIndex>): GelRelationalQuery<TSchema, TTableConfig, BuildQueryResult<TSchema, TTableConfig, TConfig> | undefined>;
-  findFirst<TConfig extends FindFirstConfigNoSearch<TSchema, TTableConfig>>(config?: KnownKeysOnly<TConfig, FindFirstConfigNoSearch<TSchema, TTableConfig>> & EnforcedConfig<TConfig, TTableConfig, THasIndex>): GelRelationalQuery<TSchema, TTableConfig, BuildQueryResult<TSchema, TTableConfig, TConfig> | undefined>;
-  /**
-   * Find first row matching the query configuration, or throw if none exists.
-   *
-   * This is the ergonomic companion to `findFirst()` (Prisma-style),
-   * useful when callers expect a row to exist.
-   */
-  findFirstOrThrow<TConfig extends SearchFindFirstConfig<TSchema, TTableConfig>>(config: KnownKeysOnly<TConfig, SearchFindFirstConfig<TSchema, TTableConfig>> & DisallowWithIndexSearchOrVector<THasIndex>): GelRelationalQuery<TSchema, TTableConfig, BuildQueryResult<TSchema, TTableConfig, TConfig>>;
-  findFirstOrThrow<TConfig extends FindFirstConfigNoSearch<TSchema, TTableConfig>>(config?: KnownKeysOnly<TConfig, FindFirstConfigNoSearch<TSchema, TTableConfig>> & EnforcedConfig<TConfig, TTableConfig, THasIndex>): GelRelationalQuery<TSchema, TTableConfig, BuildQueryResult<TSchema, TTableConfig, TConfig>>;
-}
-//#endregion
-//#region src/orm/update.d.ts
-type ConvexUpdateWithout<T extends ConvexUpdateBuilder<any, any, any>, K extends string> = Omit<T, K>;
-declare class ConvexUpdateBuilder<TTable extends ConvexTable<any>, TReturning extends MutationReturning = undefined, TMode extends MutationExecutionMode = 'single'> extends QueryPromise<MutationExecuteResult<TTable, TReturning, TMode>> {
-  private db;
-  private table;
-  readonly _: {
-    readonly table: TTable;
-    readonly returning: TReturning;
-    readonly mode: TMode;
-    readonly result: MutationExecuteResult<TTable, TReturning, TMode>;
-  };
-  private setValues?;
-  private whereExpression?;
-  private returningFields?;
-  private allowFullScanFlag;
-  private paginateConfig?;
-  private executionModeOverride?;
-  constructor(db: GenericDatabaseWriter<any>, table: TTable);
-  set(values: UpdateSet<TTable>): this;
-  where(expression: FilterExpression<boolean>): this;
-  returning(): ConvexUpdateWithout<ConvexUpdateBuilder<TTable, true, TMode>, 'returning'>;
-  returning<TSelection extends ReturningSelection<TTable>>(fields: TSelection): ConvexUpdateWithout<ConvexUpdateBuilder<TTable, TSelection, TMode>, 'returning'>;
-  paginate(config: MutationPaginateConfig): ConvexUpdateWithout<ConvexUpdateBuilder<TTable, TReturning, 'paged'>, 'paginate'>;
-  allowFullScan(): this;
-  private getIdEquality;
-  executeAsync(...args: TMode extends 'single' ? [config?: MutationAsyncConfig] : [config: never]): Promise<TMode extends 'single' ? MutationExecuteResult<TTable, TReturning, 'single'> : never>;
-  execute(...args: TMode extends 'single' ? [config?: MutationExecuteConfig] : [config?: never]): Promise<MutationExecuteResult<TTable, TReturning, TMode>>;
-}
-//#endregion
-//#region src/orm/database.d.ts
-/**
- * Database with query builder API
- *
- * @template TSchema - Schema configuration with tables and relations
- *
- * Following Drizzle's pattern: Validate schema BEFORE mapped type to prevent type widening.
- * The conditional check outside the mapped type prevents distributive conditional behavior
- * that causes TSchema[K] to widen to a union of all table types.
- *
- * Pattern from: drizzle-orm/src/pg-core/db.ts lines 50-54
- * Key insight: TSchema[K] must be captured at mapping time, not evaluated in conditionals later.
- */
-type DatabaseWithQuery<TSchema extends TablesRelationalConfig> = Pick<GenericDatabaseReader<any>, 'system'> & {
-  query: TSchema extends Record<string, never> ? {
-    error: 'Schema is empty - did you forget to add tables?';
-  } : { [K in keyof TSchema]: RelationalQueryBuilder<TSchema, TSchema[K]> };
-};
-type DatabaseWithMutations<TSchema extends TablesRelationalConfig> = DatabaseWithQuery<TSchema> & {
-  insert<TTable extends ConvexTable<any>>(table: TTable): ConvexInsertBuilder<TTable>;
-  update<TTable extends ConvexTable<any>>(table: TTable): ConvexUpdateBuilder<TTable>;
-  delete<TTable extends ConvexTable<any>>(table: TTable): ConvexDeleteBuilder<TTable>;
-};
-type OrmReader<TSchema extends TablesRelationalConfig> = DatabaseWithQuery<TSchema> & {
-  skipRules: DatabaseWithQuery<TSchema>;
-};
-type OrmWriter<TSchema extends TablesRelationalConfig> = DatabaseWithMutations<TSchema> & {
-  skipRules: DatabaseWithMutations<TSchema>;
-};
-type CreateDatabaseOptions = {
-  scheduler?: Scheduler;
-  scheduledDelete?: SchedulableFunctionReference;
-  scheduledMutationBatch?: SchedulableFunctionReference;
-  vectorSearch?: VectorSearchProvider;
-  rls?: RlsContext;
-  relationLoading?: {
-    concurrency?: number;
-  };
-};
-//#endregion
-//#region src/orm/scheduled-delete.d.ts
-type ScheduledDeleteArgs = {
-  table: string;
-  id: GenericId<any>;
-  cascadeMode?: CascadeMode;
-  deletionTime?: number;
-};
-declare function scheduledDeleteFactory<TSchema extends TablesRelationalConfig>(schema: TSchema, edgeMetadata: EdgeMetadata[], scheduledMutationBatch: SchedulableFunctionReference): (ctx: {
-  db: GenericDatabaseWriter<any>;
-  scheduler: Scheduler;
-}, args: ScheduledDeleteArgs) => Promise<void>;
-//#endregion
-//#region src/orm/scheduled-mutation-batch.d.ts
-type ScheduledMutationWorkType = 'root-update' | 'root-delete' | 'cascade-delete' | 'cascade-update';
-type ScheduledMutationBatchArgs = {
-  workType?: ScheduledMutationWorkType;
-  mode?: 'sync' | 'async';
-  operation: 'update' | 'delete';
-  table: string;
-  where?: SerializedFilterExpression;
-  allowFullScan?: boolean;
-  update?: Record<string, unknown>;
-  deleteMode?: DeleteMode;
-  cascadeMode?: CascadeMode;
-  foreignIndexName?: string;
-  foreignSourceColumns?: string[];
-  targetValues?: unknown;
-  newValues?: unknown;
-  foreignAction?: 'cascade' | 'set null' | 'set default' | 'restrict' | 'no action';
-  cursor: string | null;
-  batchSize: number;
-  maxBytesPerBatch?: number;
-  delayMs: number;
-};
-declare function scheduledMutationBatchFactory<TSchema extends TablesRelationalConfig>(schema: TSchema, edgeMetadata: EdgeMetadata[], scheduledMutationBatch: SchedulableFunctionReference): (ctx: {
-  db: GenericDatabaseWriter<any>;
-  scheduler: Scheduler;
-}, args: ScheduledMutationBatchArgs) => Promise<void>;
-//#endregion
-//#region src/orm/create-orm.d.ts
-type OrmFunctions = {
-  scheduledMutationBatch: SchedulableFunctionReference;
-  scheduledDelete: SchedulableFunctionReference;
-};
-type CreateOrmOptions = Omit<CreateDatabaseOptions, never>;
-type OrmWriterCtx = {
-  db: GenericDatabaseWriter<any>;
-  scheduler?: Scheduler;
-  vectorSearch?: VectorSearchProvider;
-};
-type OrmReaderCtx = {
-  db: GenericDatabaseReader<any>;
-  scheduler?: Scheduler;
-  vectorSearch?: VectorSearchProvider;
-};
-type OrmSource = GenericDatabaseReader<any> | GenericDatabaseWriter<any> | OrmReaderCtx | OrmWriterCtx;
-type OrmResult<TSource extends OrmSource, TSchema extends TablesRelationalConfig> = TSource extends GenericDatabaseWriter<any> | OrmWriterCtx ? OrmWriter<TSchema> : OrmReader<TSchema>;
-type GenericOrm<Ctx extends {
-  db: GenericDatabaseReader<any> | GenericDatabaseWriter<any>;
-}, TSchema extends TablesRelationalConfig> = Ctx extends {
-  db: GenericDatabaseWriter<any>;
-} ? OrmWriter<TSchema> : OrmReader<TSchema>;
-type GenericOrmCtx<Ctx extends {
-  db: GenericDatabaseReader<any> | GenericDatabaseWriter<any>;
-}, TSchema extends TablesRelationalConfig> = Ctx & {
-  orm: GenericOrm<Ctx, TSchema>;
-};
-type CreateOrmConfigBase<TSchema extends TablesRelationalConfig> = {
-  schema: TSchema;
-  internalMutation?: typeof internalMutationGeneric;
-};
-type CreateOrmConfigWithFunctions<TSchema extends TablesRelationalConfig> = CreateOrmConfigBase<TSchema> & {
-  ormFunctions: OrmFunctions;
-};
-type CreateOrmConfigWithoutFunctions<TSchema extends TablesRelationalConfig> = CreateOrmConfigBase<TSchema> & {
-  ormFunctions?: undefined;
-};
-type OrmFactory<TSchema extends TablesRelationalConfig> = <TSource extends OrmSource>(source: TSource, options?: CreateOrmOptions) => OrmResult<TSource, TSchema>;
-type OrmApiResult = {
-  scheduledMutationBatch: ReturnType<typeof internalMutationGeneric>;
-  scheduledDelete: ReturnType<typeof internalMutationGeneric>;
-};
-type OrmClientBase<TSchema extends TablesRelationalConfig> = {
-  db: OrmFactory<TSchema>;
-  with: <TContext extends OrmReaderCtx | OrmWriterCtx>(ctx: TContext, options?: CreateOrmOptions) => GenericOrmCtx<TContext, TSchema>;
-};
-type OrmClientWithApi<TSchema extends TablesRelationalConfig> = OrmClientBase<TSchema> & {
-  api: () => OrmApiResult;
-};
-declare function createOrm<TSchema extends TablesRelationalConfig>(config: CreateOrmConfigWithoutFunctions<TSchema>): OrmClientBase<TSchema>;
-declare function createOrm<TSchema extends TablesRelationalConfig>(config: CreateOrmConfigWithFunctions<TSchema>): OrmClientWithApi<TSchema>;
-//#endregion
-//#region src/orm/errors.d.ts
-declare class OrmNotFoundError extends Error {
-  readonly table?: string | undefined;
-  constructor(message: string, table?: string | undefined);
-}
-//#endregion
-//#region src/orm/index-utils.d.ts
-declare function getIndexes(table: ConvexTable<any>): {
-  name: string;
-  fields: string[];
-}[];
-//#endregion
-//#region src/orm/introspection.d.ts
-declare function getTableColumns<TTable extends ConvexTable<any>>(table: TTable): TTable[typeof Columns] & SystemFields<TTable['_']['name']> & SystemFieldAliases<TTable['_']['name'], TTable[typeof Columns]>;
-type TableConfigResult<TTable extends ConvexTable<any>> = {
-  name: string;
-  columns: ReturnType<typeof getTableColumns<TTable>>;
-  indexes: ReturnType<typeof getIndexes>;
-  uniqueIndexes: ReturnType<typeof getUniqueIndexes>;
-  foreignKeys: ReturnType<typeof getForeignKeys>;
-  checks: ReturnType<typeof getChecks>;
-  rls: {
-    enabled: boolean;
-    policies: RlsPolicy[];
-  };
-};
-declare function getTableConfig<TTable extends ConvexTable<any>>(table: TTable): TableConfigResult<TTable>;
-//#endregion
-//#region src/orm/order-by.d.ts
-/**
- * Create ascending order clause
- * Following Drizzle pattern for type-safe ordering
- *
- * @example
- * const posts = await db.query.posts.findMany({
- *   orderBy: asc(posts._creationTime),
- * });
- */
-declare function asc<TBuilder extends ColumnBuilder<any, any, any>>(builder: TBuilder): OrderByClause<TBuilder>;
-/**
- * Create descending order clause
- * Following Drizzle pattern for type-safe ordering
- *
- * @example
- * const posts = await db.query.posts.findMany({
- *   orderBy: desc(posts._creationTime),
- * });
- */
-declare function desc<TBuilder extends ColumnBuilder<any, any, any>>(builder: TBuilder): OrderByClause<TBuilder>;
-//#endregion
-//#region src/orm/schema.d.ts
-type BetterConvexSchemaOptions<StrictTableNameTypes extends boolean> = DefineSchemaOptions$1<StrictTableNameTypes> & {
-  strict?: boolean;
-  defaults?: OrmRuntimeDefaults;
-};
-/**
- * Better Convex schema definition
- *
- * Wraps Convex's defineSchema to keep schema authoring inside better-convex.
- * Mirrors drizzle's schema-first approach while returning a Convex-compatible
- * SchemaDefinition for codegen and convex-test.
- */
-declare function defineSchema<TSchema extends GenericSchema$1, StrictTableNameTypes extends boolean = true>(schema: TSchema, options?: BetterConvexSchemaOptions<StrictTableNameTypes>): SchemaDefinition$1<TSchema, StrictTableNameTypes>;
-//#endregion
-//#region src/orm/where-clause-compiler.d.ts
-/**
- * Result of compiling a where clause
- * Contains index selection and filter expressions
- */
-interface WhereClauseResult {
-  /** Planning strategy used for index compilation */
-  strategy: IndexStrategy;
-  /** Selected index for query optimization (null if no suitable index) */
-  selectedIndex: IndexLike | null;
-  /** Filters that can use the index (eq/range on indexed fields) */
-  indexFilters: FilterExpression<boolean>[];
-  /** Multi-probe filter groups for OR/inArray index union plans */
-  probeFilters: FilterExpression<boolean>[][];
-  /** Filters applied after index scan (gt, lt, and, or, not) */
-  postFilters: FilterExpression<boolean>[];
-}
-type IndexStrategy = 'none' | 'singleIndex' | 'rangeIndex' | 'multiProbe';
-/**
- * Compiles FilterExpression trees into optimized Convex queries
- *
- * Algorithm:
- * 1. Extract field references from expression tree
- * 2. Score available indexes by field match quality
- * 3. Select best index (exact > prefix > partial)
- * 4. Split filters into index-compatible vs post-filters
- */
-interface IndexLike {
-  indexName: string;
-  indexFields: string[];
-}
-//#endregion
-export { type AnyColumn, type BinaryExpression, Brand, type BuildQueryResult, type BuildRelationResult, type ColumnBuilder, type ColumnBuilderBaseConfig, type ColumnBuilderRuntimeConfig, type ColumnBuilderTypeConfig, type ColumnBuilderWithTableName, type ColumnDataType, Columns, type ConvexBigIntBuilder, type ConvexBigIntBuilderInitial, type ConvexBooleanBuilder, type ConvexBooleanBuilderInitial, type ConvexBytesBuilder, type ConvexBytesBuilderInitial, type ConvexCheckBuilder, type ConvexCheckConfig, type ConvexCustomBuilder, type ConvexCustomBuilderInitial, type ConvexDateBuilder, type ConvexDateBuilderInitial, type ConvexDateMode, type ConvexDeletionBuilder, type ConvexDeletionConfig, type ConvexForeignKeyBuilder, type ConvexForeignKeyConfig, type ConvexIdBuilder, type ConvexIdBuilderInitial, type ConvexIndexBuilder, type ConvexIndexBuilderOn, type ConvexLifecycleBuilder, type ConvexNumberBuilder, type ConvexNumberBuilderInitial, type ConvexSearchIndexBuilder, type ConvexSearchIndexBuilderOn, type ConvexSearchIndexConfig, type ConvexTable, type ConvexTextBuilder, type ConvexTextBuilderInitial, type ConvexTextEnumBuilder, type ConvexTextEnumBuilderInitial, type ConvexTimestampBuilder, type ConvexTimestampBuilderInitial, type ConvexTimestampMode, type ConvexUniqueConstraintBuilder, type ConvexUniqueConstraintBuilderOn, type ConvexUniqueConstraintConfig, type ConvexVectorBuilder, type ConvexVectorBuilderInitial, type ConvexVectorIndexBuilder, type ConvexVectorIndexBuilderOn, type ConvexVectorIndexConfig, type CreateOrmOptions, type DBQueryConfig, type DatabaseWithMutations, type DatabaseWithQuery, type DefineSchemaOptions, type DrizzleEntity, type EdgeMetadata, type ExpressionVisitor, type ExtractTablesWithRelations, type FieldReference, type FilterExpression, type FilterOperators, type GenericOrm, type GenericOrmCtx, type GenericSchema, type GetColumnData, type HasDefault, type InferInsertModel, type InferModelFromColumns, type InferSelectModel, type InsertValue, type IsPrimaryKey, type IsUnique, type LogicalExpression, type ManyConfig, type MutationAsyncConfig, type MutationExecuteConfig, type MutationExecuteResult, type MutationExecutionMode, type MutationPaginateConfig, type MutationPaginatedResult, type MutationResult, type MutationReturning, type MutationRunMode, type NotNull, type OneConfig, type OrderByClause, type OrderDirection, type OrmApiResult, type OrmClientBase, type OrmClientWithApi, type OrmFunctions, type OrmLifecycleChange, type OrmLifecycleConfig, type OrmLifecycleHandler, type OrmLifecycleOperation, OrmNotFoundError, type OrmReader, type OrmReaderCtx, type OrmTriggerLike, type OrmWriter, type OrmWriterCtx, type PaginatedResult, type PredicateWhereIndexConfig, type RelationsBuilder, type RelationsBuilderColumnBase, type RelationsBuilderColumnConfig, type ReturningAll, type ReturningResult, type ReturningSelection, type RlsContext, type RlsMode, RlsPolicy, type RlsPolicyConfig, type RlsPolicyToOption, RlsRole, type RlsRoleConfig, type ScheduledDeleteArgs, type ScheduledMutationBatchArgs, type SchemaDefinition, type SystemFields, type TableConfig, type TableConfigResult, TableName, type TableRelationalConfig, type TablesRelationalConfig, type UnaryExpression, type UpdateSet, type VectorQueryConfig, type VectorSearchProvider, type WhereClauseResult, and, asc, between, bigint, boolean, bytes, check, contains, convexTable, createOrm, custom, date, defineRelations, defineRelationsPart, defineSchema, deletion, desc, endsWith, eq, extractRelationsConfig, fieldRef, foreignKey, getTableColumns, getTableConfig, gt, gte, id, ilike, inArray, index, integer, isFieldReference, isNotNull, isNull, json, like, lt, lte, ne, not, notBetween, notInArray, onChange, onDelete, onInsert, onUpdate, or, rlsPolicy, rlsRole, scheduledDeleteFactory, scheduledMutationBatchFactory, searchIndex, startsWith, text, textEnum, timestamp, unique, uniqueIndex, unsetToken, vector, vectorIndex };
+import { $ as ConvexIdBuilder, $n as VectorSearchProvider, $t as ConvexRankIndexBuilderOn, A as DatabaseWithQuery, An as FilterOperators, Ar as Columns, At as defineRelations, B as ConvexTimestampBuilder, Bn as MutationPaginatedResult, Br as DrizzleEntity, Bt as deletion, C as OrmBeforeResult, Cn as AggregateFieldValue, Cr as ne, Ct as ManyConfig, D as OrmTriggers, Dn as CountConfig, Dr as or, Dt as RelationsBuilderColumnConfig, E as OrmTriggerContext, En as BuildRelationResult, Er as notInArray, Et as RelationsBuilderColumnBase, F as EdgeMetadata, Fn as InsertValue, Fr as ColumnBuilderBaseConfig, G as ConvexTextEnumBuilderInitial, Gn as OrderDirection, Gt as RlsRole, H as ConvexTimestampMode, Hn as MutationReturning, Hr as IsPrimaryKey, Ht as RlsPolicyConfig, I as extractRelationsConfig, In as MutationExecuteConfig, Ir as ColumnBuilderRuntimeConfig, It as OrmLifecycleChange, J as ConvexTextBuilderInitial, Jn as ReturningAll, Jt as ConvexAggregateIndexBuilder, K as textEnum, Kn as PaginatedResult, Kt as RlsRoleConfig, L as ConvexVectorBuilder, Ln as MutationExecuteResult, Lr as ColumnBuilderTypeConfig, Lt as OrmLifecycleOperation, M as OrmWriter, Mn as InferInsertModel, Mr as SystemFields, Mt as ConvexDeletionBuilder, N as RlsContext, Nn as InferModelFromColumns, Nr as AnyColumn, Nt as ConvexDeletionConfig, O as defineTriggers, On as CountResult, Or as startsWith, Ot as TableRelationalConfig, P as RlsMode, Pn as InferSelectModel, Pr as ColumnBuilder, Pt as ConvexTable, Q as integer, Qn as VectorQueryConfig, Qt as ConvexRankIndexBuilder, R as ConvexVectorBuilderInitial, Rn as MutationExecutionMode, Rr as ColumnBuilderWithTableName, Rt as TableConfig, S as scheduledDeleteFactory, Sn as AggregateConfig, Sr as lte, St as ExtractTablesWithRelations, T as OrmTriggerChange, Tn as BuildQueryResult, Tr as notBetween, Tt as RelationsBuilder, U as timestamp, Un as MutationRunMode, Ur as IsUnique, Ut as RlsPolicyToOption, V as ConvexTimestampBuilderInitial, Vn as MutationResult, Vr as HasDefault, Vt as RlsPolicy, W as ConvexTextEnumBuilder, Wn as OrderByClause, Wr as NotNull, Wt as rlsPolicy, X as ConvexNumberBuilder, Xn as ReturningSelection, Xt as ConvexIndexBuilder, Y as text, Yn as ReturningResult, Yt as ConvexAggregateIndexBuilderOn, Z as ConvexNumberBuilderInitial, Zn as UpdateSet, Zt as ConvexIndexBuilderOn, _ as OrmWriterCtx, _n as ConvexUniqueConstraintBuilderOn, _r as isFieldReference, _t as ConvexBigIntBuilderInitial, a as TableConfigResult, an as ConvexVectorIndexConfig, ar as LogicalExpression, at as date, b as scheduledMutationBatchFactory, bn as foreignKey, br as like, bt as CountBackfillKickoffArgs, c as OrmNotFoundError, cn as rankIndex, cr as between, ct as custom, d as GenericOrmCtx, dn as vectorIndex, dr as eq, dt as ConvexBytesBuilderInitial, en as ConvexSearchIndexBuilder, er as unsetToken, et as ConvexIdBuilderInitial, f as OrmApiResult, fn as ConvexCheckBuilder, fr as fieldRef, ft as bytes, g as OrmReaderCtx, gn as ConvexUniqueConstraintBuilder, gr as inArray, gt as ConvexBigIntBuilder, h as OrmFunctions, hn as ConvexForeignKeyConfig, hr as ilike, ht as boolean, i as desc, in as ConvexVectorIndexBuilderOn, ir as FilterExpression, it as ConvexDateMode, j as OrmReader, jn as GetColumnData, jr as TableName, jt as defineRelationsPart, k as DatabaseWithMutations, kn as DBQueryConfig, kr as Brand, kt as TablesRelationalConfig, l as CreateOrmOptions, ln as searchIndex, lr as contains, lt as json, m as OrmClientWithApi, mn as ConvexForeignKeyBuilder, mr as gte, mt as ConvexBooleanBuilderInitial, n as defineSchema, nn as ConvexSearchIndexConfig, nr as ExpressionVisitor, nt as ConvexDateBuilder, o as getTableColumns, on as aggregateIndex, or as UnaryExpression, ot as ConvexCustomBuilder, p as OrmClientBase, pn as ConvexCheckConfig, pr as gt, pt as ConvexBooleanBuilder, q as ConvexTextBuilder, qn as PredicateWhereIndexConfig, qt as rlsRole, r as asc, rn as ConvexVectorIndexBuilder, rr as FieldReference, rt as ConvexDateBuilderInitial, s as getTableConfig, sn as index, sr as and, st as ConvexCustomBuilderInitial, t as WhereClauseResult, tn as ConvexSearchIndexBuilderOn, tr as BinaryExpression, tt as id, u as GenericOrm, un as uniqueIndex, ur as endsWith, ut as ConvexBytesBuilder, v as createOrm, vn as ConvexUniqueConstraintConfig, vr as isNotNull, vt as bigint, w as OrmTableTriggers, wn as AggregateResult, wr as not, wt as OneConfig, x as ScheduledDeleteArgs, xn as unique, xr as lt, xt as CountBackfillStatusArgs, y as ScheduledMutationBatchArgs, yn as check, yr as isNull, yt as CountBackfillChunkArgs, z as vector, zn as MutationPaginateConfig, zr as ColumnDataType, zt as convexTable } from "../where-clause-compiler-CRP-i1Qa.js";
+import { a as QueryCtxWithPreferredOrmQueryTable, i as QueryCtxWithOrmQueryTable, n as LookupByIdResultByCtx, o as getByIdWithOrmQueryFallback, r as QueryCtxWithOptionalOrmQueryTable, t as DocByCtx } from "../query-context-DGExXZIV.js";
+import { DefineSchemaOptions, GenericSchema, SchemaDefinition } from "convex/server";
+export { type AggregateConfig, type AggregateFieldValue, type AggregateResult, type AnyColumn, type BinaryExpression, Brand, type BuildQueryResult, type BuildRelationResult, type ColumnBuilder, type ColumnBuilderBaseConfig, type ColumnBuilderRuntimeConfig, type ColumnBuilderTypeConfig, type ColumnBuilderWithTableName, type ColumnDataType, Columns, type ConvexAggregateIndexBuilder, type ConvexAggregateIndexBuilderOn, type ConvexBigIntBuilder, type ConvexBigIntBuilderInitial, type ConvexBooleanBuilder, type ConvexBooleanBuilderInitial, type ConvexBytesBuilder, type ConvexBytesBuilderInitial, type ConvexCheckBuilder, type ConvexCheckConfig, type ConvexCustomBuilder, type ConvexCustomBuilderInitial, type ConvexDateBuilder, type ConvexDateBuilderInitial, type ConvexDateMode, type ConvexDeletionBuilder, type ConvexDeletionConfig, type ConvexForeignKeyBuilder, type ConvexForeignKeyConfig, type ConvexIdBuilder, type ConvexIdBuilderInitial, type ConvexIndexBuilder, type ConvexIndexBuilderOn, type ConvexNumberBuilder, type ConvexNumberBuilderInitial, type ConvexRankIndexBuilder, type ConvexRankIndexBuilderOn, type ConvexSearchIndexBuilder, type ConvexSearchIndexBuilderOn, type ConvexSearchIndexConfig, type ConvexTable, type ConvexTextBuilder, type ConvexTextBuilderInitial, type ConvexTextEnumBuilder, type ConvexTextEnumBuilderInitial, type ConvexTimestampBuilder, type ConvexTimestampBuilderInitial, type ConvexTimestampMode, type ConvexUniqueConstraintBuilder, type ConvexUniqueConstraintBuilderOn, type ConvexUniqueConstraintConfig, type ConvexVectorBuilder, type ConvexVectorBuilderInitial, type ConvexVectorIndexBuilder, type ConvexVectorIndexBuilderOn, type ConvexVectorIndexConfig, type CountBackfillChunkArgs, type CountBackfillKickoffArgs, type CountBackfillStatusArgs, type CountConfig, type CountResult, type CreateOrmOptions, type DBQueryConfig, type DatabaseWithMutations, type DatabaseWithQuery, type DefineSchemaOptions, type DocByCtx, type DrizzleEntity, type EdgeMetadata, type ExpressionVisitor, type ExtractTablesWithRelations, type FieldReference, type FilterExpression, type FilterOperators, type GenericOrm, type GenericOrmCtx, type GenericSchema, type GetColumnData, type HasDefault, type InferInsertModel, type InferModelFromColumns, type InferSelectModel, type InsertValue, type IsPrimaryKey, type IsUnique, type LogicalExpression, type LookupByIdResultByCtx, type ManyConfig, type MutationExecuteConfig, type MutationExecuteResult, type MutationExecutionMode, type MutationPaginateConfig, type MutationPaginatedResult, type MutationResult, type MutationReturning, type MutationRunMode, type NotNull, type OneConfig, type OrderByClause, type OrderDirection, type OrmApiResult, type OrmBeforeResult, type OrmClientBase, type OrmClientWithApi, type OrmFunctions, type OrmLifecycleChange, type OrmLifecycleOperation, OrmNotFoundError, type OrmReader, type OrmReaderCtx, type OrmTableTriggers, type OrmTriggerChange, type OrmTriggerContext, type OrmTriggers, type OrmWriter, type OrmWriterCtx, type PaginatedResult, type PredicateWhereIndexConfig, type QueryCtxWithOptionalOrmQueryTable, type QueryCtxWithOrmQueryTable, type QueryCtxWithPreferredOrmQueryTable, type RelationsBuilder, type RelationsBuilderColumnBase, type RelationsBuilderColumnConfig, type ReturningAll, type ReturningResult, type ReturningSelection, type RlsContext, type RlsMode, RlsPolicy, type RlsPolicyConfig, type RlsPolicyToOption, RlsRole, type RlsRoleConfig, type ScheduledDeleteArgs, type ScheduledMutationBatchArgs, type SchemaDefinition, type SystemFields, type TableConfig, type TableConfigResult, TableName, type TableRelationalConfig, type TablesRelationalConfig, type UnaryExpression, type UpdateSet, type VectorQueryConfig, type VectorSearchProvider, type WhereClauseResult, aggregateIndex, and, asc, between, bigint, boolean, bytes, check, contains, convexTable, createOrm, custom, date, defineRelations, defineRelationsPart, defineSchema, defineTriggers, deletion, desc, endsWith, eq, extractRelationsConfig, fieldRef, foreignKey, getByIdWithOrmQueryFallback, getTableColumns, getTableConfig, gt, gte, id, ilike, inArray, index, integer, isFieldReference, isNotNull, isNull, json, like, lt, lte, ne, not, notBetween, notInArray, or, rankIndex, rlsPolicy, rlsRole, scheduledDeleteFactory, scheduledMutationBatchFactory, searchIndex, startsWith, text, textEnum, timestamp, unique, uniqueIndex, unsetToken, vector, vectorIndex };