kitcn 0.0.1 → 0.12.1

package/dist/where-clause-compiler-DdjN63Io.d.ts

@@ -0,0 +1,4756 @@
+import { a as ReturnTypeOrValue, i as KnownKeysOnly, o as Simplify$1, t as Assume } from "./types-BTb_4BaU.js";
+import * as convex_values0 from "convex/values";
+import { GenericId, Validator, Value } from "convex/values";
+import { DefineSchemaOptions, FilterExpression, GenericDatabaseReader, GenericDatabaseWriter, GenericIndexFields, GenericSchema, GenericTableIndexes, GenericTableSearchIndexes, GenericTableVectorIndexes, IndexRange, IndexRangeBuilder, SchedulableFunctionReference, Scheduler, SchemaDefinition, TableDefinition, VectorFilterBuilder, internalActionGeneric, internalMutationGeneric } from "convex/server";
+
+//#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;
+  onDelete?: ForeignKeyAction;
+  onUpdate?: 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> {
+  columnType: TColumnType;
+  data: unknown;
+  dataType: TDataType;
+  driverParam: unknown;
+  enumValues: string[] | undefined;
+  name: string;
+}
+/**
+ * Runtime configuration stored in builder instance
+ * Updated by chaining methods (.notNull(), .default(), etc.)
+ */
+interface ColumnBuilderRuntimeConfig<TData> {
+  columnType: string;
+  dataType: string;
+  default: TData | undefined;
+  defaultFn?: (() => unknown) | undefined;
+  foreignKeyConfigs: {
+    ref: () => ColumnBuilderBase;
+    config: ColumnReferenceConfig;
+  }[];
+  hasDefault: boolean;
+  isUnique: boolean;
+  name: string;
+  notNull: boolean;
+  onUpdateFn?: (() => unknown) | undefined;
+  primaryKey: boolean;
+  referenceTable?: string;
+  table?: unknown;
+  tableName?: string;
+  uniqueName?: string;
+  uniqueNulls?: 'distinct' | 'not distinct';
+}
+/**
+ * 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$1<{
+  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/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$1<_TValue = boolean> {
+  /** Accept visitor for traversal */
+  accept<R>(visitor: ExpressionVisitor<R>): R;
+  /** Expression operands (FieldReference, values, or nested expressions) */
+  readonly operands: readonly any[];
+  /** Operator string (eq, and, not, etc.) */
+  readonly operator: string;
+  /** Expression type discriminator */
+  readonly type: 'binary' | 'logical' | 'unary';
+  /** Brand symbol for nominal typing */
+  readonly [FilterExpressionBrand]: true;
+}
+/**
+ * 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$1<boolean> {
+  /** [field, value] or [field, array] for inArray/notInArray */
+  readonly operands: readonly [FieldReference<TField>, TField | TField[]];
+  readonly operator: 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'inArray' | 'notInArray' | 'arrayContains' | 'arrayContained' | 'arrayOverlaps' | 'like' | 'ilike' | 'notLike' | 'notIlike' | 'startsWith' | 'endsWith' | 'contains';
+  readonly type: 'binary';
+}
+/**
+ * Logical operator expression (and, or)
+ * Combines multiple filter expressions
+ */
+interface LogicalExpression extends FilterExpression$1<boolean> {
+  /** Array of nested filter expressions */
+  readonly operands: readonly FilterExpression$1<boolean>[];
+  readonly operator: 'and' | 'or';
+  readonly type: 'logical';
+}
+/**
+ * Unary operator expression (not, isNull, isNotNull)
+ * Negates or checks null state of an expression
+ */
+interface UnaryExpression extends FilterExpression$1<boolean> {
+  /** Single nested filter expression or field reference for null checks */
+  readonly operands: readonly [FilterExpression$1<boolean> | FieldReference<any>];
+  readonly operator: 'not' | 'isNull' | 'isNotNull';
+  readonly type: 'unary';
+}
+/**
+ * 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';
+  /** Phantom type for type inference - not present at runtime */
+  readonly __type?: TValue;
+  readonly fieldName: string;
+}
+/**
+ * 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$1<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$1<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$1<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$1<boolean> | undefined)[]): LogicalExpression | undefined;
+/**
+ * Logical NOT: negates expression
+ *
+ * @example
+ * const filter = not(eq(fieldRef('isDeleted'), true));
+ */
+declare function not(expression: FilterExpression$1<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/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_values0.VString<string, "required">;
+  /**
+   * Convex validator - runtime access
+   * System fields use v.string() for _id
+   */
+  get convexValidator(): convex_values0.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_values0.VFloat64<number, "required">;
+  /**
+   * Convex validator - runtime access
+   * System fields use v.number() for _creationTime
+   */
+  get convexValidator(): convex_values0.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_values0.VFloat64<number, "required">;
+  get convexValidator(): convex_values0.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/symbols.d.ts
+/**
+ * Symbol-based metadata storage for ORM tables
+ * Following Drizzle's pattern for type-safe runtime introspection
+ */
+type OrmRuntimeDefaults = {
+  defaultLimit?: number;
+  countBackfillBatchSize?: number;
+  relationFanOutMaxKeys?: number;
+  aggregateCartesianMaxKeys?: number;
+  aggregateWorkBudget?: 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;
+};
+type TablePolymorphicVariantRuntime = {
+  fieldNames: readonly string[];
+  requiredFieldNames: readonly string[];
+};
+type TablePolymorphicConfigRuntime = {
+  discriminator: string;
+  alias: string;
+  generatedFieldNames: readonly string[];
+  variants: Readonly<Record<string, TablePolymorphicVariantRuntime>>;
+};
+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 TablePolymorphic: unique symbol;
+declare const OrmSchemaDefinition: unique symbol;
+declare const OrmSchemaExtensionTables: unique symbol;
+declare const OrmSchemaExtensions: unique symbol;
+declare const OrmSchemaExtensionRelations: unique symbol;
+declare const OrmSchemaExtensionTriggers: unique symbol;
+declare const OrmSchemaRelations: unique symbol;
+declare const OrmSchemaTriggers: 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$1<Merge<{
+  id: string;
+  createdAt: number;
+}, { [K in keyof TTable['_']['columns']]: GetColumnData<TTable['_']['columns'][K], 'query'> }>>;
+type RequiredKeyOnly<TKey extends string, TColumn extends ColumnBuilderBase> = TColumn['_']['notNull'] extends true ? TColumn['_']['hasDefault'] extends true ? never : TKey : never;
+type OptionalKeyOnly<TKey extends string, TColumn extends ColumnBuilderBase> = TColumn['_']['notNull'] extends true ? TColumn['_']['hasDefault'] extends true ? TKey : never : TKey;
+type InferInsertModelFromColumns<TColumns extends Record<string, ColumnBuilderBase>, TExcludeKeys extends string = never> = Simplify$1<{ [K in keyof TColumns & string as K extends TExcludeKeys ? never : RequiredKeyOnly<K, TColumns[K]>]: GetColumnData<TColumns[K], 'query'> } & { [K in keyof TColumns & string as K extends TExcludeKeys ? never : OptionalKeyOnly<K, TColumns[K]>]?: GetColumnData<TColumns[K], 'query'> | undefined }>;
+type TablePolymorphicInsertMetadata<TTable extends ConvexTable<any>> = { [K in keyof TTable['_']['columns'] & string]: TTable['_']['columns'][K] extends {
+  __polymorphic: infer TMeta;
+} ? TMeta extends {
+  variants: infer TVariants extends Record<string, Record<string, ColumnBuilderBase>>;
+} ? {
+  discriminator: K;
+  variants: TVariants;
+} : never : never }[keyof TTable['_']['columns'] & string];
+type PolymorphicVariantFieldNames<TVariants extends Record<string, Record<string, ColumnBuilderBase>>> = Extract<TVariants[keyof TVariants & string] extends infer TVariantColumns ? TVariantColumns extends Record<string, ColumnBuilderBase> ? keyof TVariantColumns : never : never, string>;
+type PolymorphicVariantInsertCase<TBase extends Record<string, unknown>, TDiscriminator extends string, TCase extends string, TVariantColumns extends Record<string, ColumnBuilderBase>, TAllGeneratedFields extends string> = Simplify$1<TBase & { [K in TDiscriminator]: TCase } & { [K in keyof TVariantColumns & string as RequiredKeyOnly<K, TVariantColumns[K]>]: GetColumnData<TVariantColumns[K], 'query'> } & { [K in keyof TVariantColumns & string as OptionalKeyOnly<K, TVariantColumns[K]>]?: GetColumnData<TVariantColumns[K], 'query'> | undefined } & { [K in Exclude<TAllGeneratedFields, keyof TVariantColumns & string>]?: never }>;
+type PolymorphicVariantInsertUnion<TBase extends Record<string, unknown>, TMetadata extends {
+  discriminator: string;
+  variants: Record<string, Record<string, ColumnBuilderBase>>;
+}> = { [TCase in keyof TMetadata['variants'] & string]: PolymorphicVariantInsertCase<TBase, TMetadata['discriminator'], TCase, TMetadata['variants'][TCase], PolymorphicVariantFieldNames<TMetadata['variants']>> }[keyof TMetadata['variants'] & string];
+type InferPolymorphicInsertModel<TTable extends ConvexTable<any>, TMetadata extends {
+  discriminator: string;
+  variants: Record<string, Record<string, ColumnBuilderBase>>;
+}> = PolymorphicVariantInsertUnion<InferInsertModelFromColumns<TTable['_']['columns'], TMetadata['discriminator'] | PolymorphicVariantFieldNames<TMetadata['variants']>>, TMetadata>;
+/**
+ * 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$1<[TablePolymorphicInsertMetadata<TTable>] extends [never] ? InferInsertModelFromColumns<TTable['_']['columns']> : InferPolymorphicInsertModel<TTable, Extract<TablePolymorphicInsertMetadata<TTable>, object>>>;
+/**
+ * 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 ColumnBuilderBase, TInferMode extends 'query' | 'raw' = 'query'> = TInferMode extends 'raw' ? ColumnDataWithOverride<TColumn> : TColumn['_']['notNull'] extends true ? ColumnDataWithOverride<TColumn> : ColumnDataWithOverride<TColumn> | null;
+type ColumnDataWithOverride<TColumn extends ColumnBuilderBase> = TColumn['_'] extends {
+  $type: infer TType;
+} ? unknown extends TType ? TColumn['_']['data'] : TType : TColumn['_']['data'];
+type AggregateIndexMap<TTableConfig extends TableRelationalConfig = TableRelationalConfig> = TTableConfig['table'] extends ConvexTable<any, any, any, any, infer TAggregateIndexes extends Record<string, string>> ? TAggregateIndexes : Record<string, string>;
+type AggregateIndexedFieldName<TTableConfig extends TableRelationalConfig = TableRelationalConfig> = Extract<{ [K in keyof AggregateIndexMap<TTableConfig>]: AggregateIndexMap<TTableConfig>[K] }[keyof AggregateIndexMap<TTableConfig>], string>;
+type AggregateScalarFieldName<TTableConfig extends TableRelationalConfig> = Extract<keyof TTableConfig['table']['_']['columns'], string>;
+type AggregateWhereFieldName<TTableConfig extends TableRelationalConfig = TableRelationalConfig> = AggregateIndexedFieldName<TTableConfig>;
+type AggregateWhereFieldValue<TTableConfig extends TableRelationalConfig, TFieldName extends string> = TFieldName extends keyof TTableConfig['table']['_']['columns'] ? TTableConfig['table']['_']['columns'][TFieldName] extends ColumnBuilderBase ? GetColumnData<TTableConfig['table']['_']['columns'][TFieldName], 'query'> : unknown : unknown;
+type AggregateWhereFieldFilter<TValue> = TValue | {
+  eq?: TValue | undefined;
+  in?: readonly TValue[] | undefined;
+  isNull?: true | undefined;
+  gt?: TValue | undefined;
+  gte?: TValue | undefined;
+  lt?: TValue | undefined;
+  lte?: TValue | undefined;
+};
+type AggregateNoScanWhereBase<TTableConfig extends TableRelationalConfig = TableRelationalConfig> = { [K in AggregateWhereFieldName<TTableConfig>]?: AggregateWhereFieldFilter<AggregateWhereFieldValue<TTableConfig, K>> };
+type AggregateNoScanWhere<TTableConfig extends TableRelationalConfig = TableRelationalConfig> = Simplify$1<AggregateNoScanWhereBase<TTableConfig> & {
+  AND?: AggregateNoScanWhereBase<TTableConfig>[] | undefined;
+  OR?: AggregateNoScanWhereBase<TTableConfig>[] | undefined;
+}>;
+type AggregateNoScanWhereArg<TTableConfig extends TableRelationalConfig = TableRelationalConfig> = [AggregateWhereFieldName<TTableConfig>] extends [never] ? never : AggregateNoScanWhere<TTableConfig>;
+/**
+ * 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 } & {
+    _count?: { [K in keyof TTableConfig['relations']]?: true | {
+      where?: AggregateNoScanWhereArg<FindTableByDBName<TSchema, Extract<TTableConfig['relations'][K]['targetTableName'], string>>> | undefined;
+    } } | undefined;
+  }, TTableConfig['relations'] & {
+    _count?: unknown;
+  }> | undefined;
+  /**
+   * Auto-include one() relations for discriminator-backed tables.
+   */
+  withVariants?: true | undefined;
+  /**
+   * Extra computed fields (post-fetch, computed in JS at runtime)
+   */
+  extras?: Record<string, Value | ((row: InferModelFromColumns<TableColumns<TTableConfig>>) => Value)> | ((fields: Simplify$1<[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 CountConfig<_TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTableConfig extends TableRelationalConfig = TableRelationalConfig> = {
+  where?: AggregateNoScanWhereArg<TTableConfig> | undefined;
+  orderBy?: DBQueryConfigOrderBy<TTableConfig> | undefined;
+  skip?: number | undefined;
+  take?: number | undefined;
+  cursor?: { [K in Extract<keyof TTableConfig['table']['_']['columns'], string>]?: GetColumnData<TableColumns<TTableConfig>[K], 'query'> | undefined } | undefined;
+  select?: ({
+    _all?: true | undefined;
+  } & { [K in Extract<keyof TTableConfig['table']['_']['columns'], string>]?: true | undefined }) | undefined;
+};
+type AggregateNumericFieldName<TTableConfig extends TableRelationalConfig> = { [K in AggregateScalarFieldName<TTableConfig>]: NonNullable<GetColumnData<TableColumns<TTableConfig>[K], 'query'>> extends number ? K : never }[AggregateScalarFieldName<TTableConfig>];
+type AggregateFieldValue<TTableConfig extends TableRelationalConfig, TField extends AggregateScalarFieldName<TTableConfig>> = GetColumnData<TableColumns<TTableConfig>[TField], 'query'>;
+type AggregateConfig<_TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTableConfig extends TableRelationalConfig = TableRelationalConfig> = {
+  where?: AggregateNoScanWhereArg<TTableConfig> | undefined;
+  orderBy?: DBQueryConfigOrderBy<TTableConfig> | undefined;
+  skip?: number | undefined;
+  take?: number | undefined;
+  cursor?: { [K in Extract<keyof TTableConfig['table']['_']['columns'], string>]?: GetColumnData<TableColumns<TTableConfig>[K], 'query'> | undefined } | undefined;
+  _count?: true | ({
+    _all?: true | undefined;
+  } & { [K in AggregateScalarFieldName<TTableConfig>]?: true | undefined }) | undefined;
+  _sum?: { [K in AggregateNumericFieldName<TTableConfig>]?: true | undefined } | undefined;
+  _avg?: { [K in AggregateNumericFieldName<TTableConfig>]?: true | undefined } | undefined;
+  _min?: { [K in AggregateScalarFieldName<TTableConfig>]?: true | undefined } | undefined;
+  _max?: { [K in AggregateScalarFieldName<TTableConfig>]?: true | undefined } | undefined;
+};
+type GroupByByInput<TTableConfig extends TableRelationalConfig = TableRelationalConfig> = AggregateWhereFieldName<TTableConfig> | readonly AggregateWhereFieldName<TTableConfig>[];
+type GroupBySelectedFields<TBy> = TBy extends readonly (infer TField)[] ? Extract<TField, string> : Extract<TBy, string>;
+type GroupByByResult<TTableConfig extends TableRelationalConfig, TBy> = Simplify$1<{ [K in GroupBySelectedFields<TBy> & AggregateScalarFieldName<TTableConfig>]: AggregateFieldValue<TTableConfig, K> }>;
+type GroupByOrderDirection = 'asc' | 'desc';
+type GroupByByOrderBy<TBy> = Partial<Record<GroupBySelectedFields<TBy>, GroupByOrderDirection>>;
+type GroupByMetricOrderBy<TTableConfig extends TableRelationalConfig> = {
+  _count?: GroupByOrderDirection | ({
+    _all?: GroupByOrderDirection | undefined;
+  } & { [K in AggregateScalarFieldName<TTableConfig>]?: GroupByOrderDirection | undefined }) | undefined;
+  _sum?: { [K in AggregateNumericFieldName<TTableConfig>]?: GroupByOrderDirection | undefined } | undefined;
+  _avg?: { [K in AggregateNumericFieldName<TTableConfig>]?: GroupByOrderDirection | undefined } | undefined;
+  _min?: { [K in AggregateScalarFieldName<TTableConfig>]?: GroupByOrderDirection | undefined } | undefined;
+  _max?: { [K in AggregateScalarFieldName<TTableConfig>]?: GroupByOrderDirection | undefined } | undefined;
+};
+type GroupByOrderBy<TTableConfig extends TableRelationalConfig, TBy> = ValueOrArray<GroupByByOrderBy<TBy> | GroupByMetricOrderBy<TTableConfig>>;
+type GroupByHavingValue<TValue> = TValue | {
+  eq?: TValue | undefined;
+  in?: readonly TValue[] | undefined;
+  isNull?: true | undefined;
+  gt?: TValue | undefined;
+  gte?: TValue | undefined;
+  lt?: TValue | undefined;
+  lte?: TValue | undefined;
+};
+type GroupByHaving<TTableConfig extends TableRelationalConfig, TBy> = Simplify$1<{ [K in GroupBySelectedFields<TBy>]?: GroupByHavingValue<AggregateFieldValue<TTableConfig, Extract<K, AggregateScalarFieldName<TTableConfig>>>> } & {
+  _count?: GroupByHavingValue<number> | ({
+    _all?: GroupByHavingValue<number> | undefined;
+  } & { [K in AggregateScalarFieldName<TTableConfig>]?: GroupByHavingValue<number> | undefined }) | undefined;
+  _sum?: { [K in AggregateNumericFieldName<TTableConfig>]?: GroupByHavingValue<number | null> | undefined } | undefined;
+  _avg?: { [K in AggregateNumericFieldName<TTableConfig>]?: GroupByHavingValue<number | null> | undefined } | undefined;
+  _min?: { [K in AggregateScalarFieldName<TTableConfig>]?: GroupByHavingValue<AggregateFieldValue<TTableConfig, K> | null> | undefined } | undefined;
+  _max?: { [K in AggregateScalarFieldName<TTableConfig>]?: GroupByHavingValue<AggregateFieldValue<TTableConfig, K> | null> | undefined } | undefined;
+  AND?: GroupByHaving<TTableConfig, TBy>[] | undefined;
+}>;
+type GroupByConfig<_TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTableConfig extends TableRelationalConfig = TableRelationalConfig> = {
+  by: GroupByByInput<TTableConfig>;
+  where?: AggregateNoScanWhereArg<TTableConfig> | undefined;
+  orderBy?: GroupByOrderBy<TTableConfig, GroupByByInput<TTableConfig>> | undefined;
+  skip?: number | undefined;
+  take?: number | undefined;
+  cursor?: Record<string, unknown> | undefined;
+  having?: GroupByHaving<TTableConfig, GroupByByInput<TTableConfig>> | undefined;
+  _count?: true | ({
+    _all?: true | undefined;
+  } & { [K in AggregateScalarFieldName<TTableConfig>]?: true | undefined }) | undefined;
+  _sum?: { [K in AggregateNumericFieldName<TTableConfig>]?: true | undefined } | undefined;
+  _avg?: { [K in AggregateNumericFieldName<TTableConfig>]?: true | undefined } | undefined;
+  _min?: { [K in AggregateScalarFieldName<TTableConfig>]?: true | undefined } | undefined;
+  _max?: { [K in AggregateScalarFieldName<TTableConfig>]?: true | undefined } | undefined;
+};
+type SelectedTrueKeys<TSelection> = Extract<{ [K in keyof TSelection]-?: TSelection[K] extends true ? K : never }[keyof TSelection], string>;
+type CountSelectResult<TTableConfig extends TableRelationalConfig, TSelect extends Record<string, unknown>> = Simplify$1<(TSelect extends {
+  _all: true;
+} ? {
+  _all: number;
+} : {}) & { [K in SelectedTrueKeys<TSelect> & AggregateScalarFieldName<TTableConfig>]: number }>;
+type AggregateCountResult<TTableConfig extends TableRelationalConfig, TCount> = TCount extends true ? number : TCount extends Record<string, unknown> ? CountSelectResult<TTableConfig, TCount> : never;
+type AggregateNumericNullableResult<TSelect> = Simplify$1<{ [K in SelectedTrueKeys<NonNullable<TSelect>>]: number | null }>;
+type AggregateComparableResult<TTableConfig extends TableRelationalConfig, TSelect> = Simplify$1<{ [K in SelectedTrueKeys<NonNullable<TSelect>> & AggregateScalarFieldName<TTableConfig>]: AggregateFieldValue<TTableConfig, K> | null }>;
+type CountResult<TTableConfig extends TableRelationalConfig, TConfig extends CountConfig<any, TTableConfig> | undefined> = TConfig extends {
+  select: infer TSelect extends Record<string, unknown>;
+} ? CountSelectResult<TTableConfig, TSelect> : number;
+type AggregateResult<TTableConfig extends TableRelationalConfig, TConfig extends AggregateConfig<any, TTableConfig>> = Simplify$1<(TConfig extends {
+  _count: infer TCount;
+} ? {
+  _count: AggregateCountResult<TTableConfig, TCount>;
+} : {}) & (TConfig extends {
+  _sum: infer TSum extends Record<string, unknown>;
+} ? {
+  _sum: AggregateNumericNullableResult<TSum>;
+} : {}) & (TConfig extends {
+  _avg: infer TAvg extends Record<string, unknown>;
+} ? {
+  _avg: AggregateNumericNullableResult<TAvg>;
+} : {}) & (TConfig extends {
+  _min: infer TMin extends Record<string, unknown>;
+} ? {
+  _min: AggregateComparableResult<TTableConfig, TMin>;
+} : {}) & (TConfig extends {
+  _max: infer TMax extends Record<string, unknown>;
+} ? {
+  _max: AggregateComparableResult<TTableConfig, TMax>;
+} : {})>;
+type GroupByRowResult<TTableConfig extends TableRelationalConfig, TConfig extends GroupByConfig<any, TTableConfig>> = Simplify$1<GroupByByResult<TTableConfig, TConfig['by']> & (TConfig extends {
+  _count: infer TCount;
+} ? {
+  _count: AggregateCountResult<TTableConfig, TCount>;
+} : {}) & (TConfig extends {
+  _sum: infer TSum extends Record<string, unknown>;
+} ? {
+  _sum: AggregateNumericNullableResult<TSum>;
+} : {}) & (TConfig extends {
+  _avg: infer TAvg extends Record<string, unknown>;
+} ? {
+  _avg: AggregateNumericNullableResult<TAvg>;
+} : {}) & (TConfig extends {
+  _min: infer TMin extends Record<string, unknown>;
+} ? {
+  _min: AggregateComparableResult<TTableConfig, TMin>;
+} : {}) & (TConfig extends {
+  _max: infer TMax extends Record<string, unknown>;
+} ? {
+  _max: AggregateComparableResult<TTableConfig, TMax>;
+} : {})>;
+type GroupByResult<TTableConfig extends TableRelationalConfig, TConfig extends GroupByConfig<any, TTableConfig>> = GroupByRowResult<TTableConfig, TConfig>[];
+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$1<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<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$1<boolean> | undefined)[]): FilterExpression$1<boolean> | undefined;
+  arrayContained<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, values: readonly GetColumnData<TBuilder, 'raw'>[]): FilterExpression$1<boolean>;
+  arrayContains<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, values: readonly GetColumnData<TBuilder, 'raw'>[]): FilterExpression$1<boolean>;
+  arrayOverlaps<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, values: readonly GetColumnData<TBuilder, 'raw'>[]): FilterExpression$1<boolean>;
+  between<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, min: GetColumnData<TBuilder, 'raw'>, max: GetColumnData<TBuilder, 'raw'>): FilterExpression$1<boolean>;
+  contains<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, substring: string): FilterExpression$1<boolean>;
+  endsWith<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, suffix: string): FilterExpression$1<boolean>;
+  eq<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, value: GetColumnData<TBuilder, 'raw'>): FilterExpression$1<boolean>;
+  gt<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, value: GetColumnData<TBuilder, 'raw'>): FilterExpression$1<boolean>;
+  gte<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, value: GetColumnData<TBuilder, 'raw'>): FilterExpression$1<boolean>;
+  ilike<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, pattern: string): FilterExpression$1<boolean>;
+  inArray<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, values: readonly GetColumnData<TBuilder, 'raw'>[]): FilterExpression$1<boolean>;
+  isNotNull<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder): FilterExpression$1<boolean>;
+  isNull<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder extends {
+    _: {
+      notNull: true;
+    };
+  } ? never : TBuilder): FilterExpression$1<boolean>;
+  like<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, pattern: string): FilterExpression$1<boolean>;
+  lt<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, value: GetColumnData<TBuilder, 'raw'>): FilterExpression$1<boolean>;
+  lte<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, value: GetColumnData<TBuilder, 'raw'>): FilterExpression$1<boolean>;
+  ne<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, value: GetColumnData<TBuilder, 'raw'>): FilterExpression$1<boolean>;
+  not(expression: FilterExpression$1<boolean>): FilterExpression$1<boolean>;
+  notBetween<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, min: GetColumnData<TBuilder, 'raw'>, max: GetColumnData<TBuilder, 'raw'>): FilterExpression$1<boolean>;
+  notIlike<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, pattern: string): FilterExpression$1<boolean>;
+  notInArray<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, values: readonly GetColumnData<TBuilder, 'raw'>[]): FilterExpression$1<boolean>;
+  notLike<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, pattern: string): FilterExpression$1<boolean>;
+  or(...expressions: (FilterExpression$1<boolean> | undefined)[]): FilterExpression$1<boolean> | undefined;
+  predicate(predicate: (row: InferModelFromColumns<TableColumns<TTableConfig>>) => boolean | Promise<boolean>): PredicateWhereClause<TTableConfig>;
+  startsWith<TBuilder extends ColumnBuilder<any, any, any>>(field: TBuilder, prefix: string): FilterExpression$1<boolean>;
+}
+/**
+ * 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 TablePolymorphicMetadataFromColumn<TColumn, TDiscriminator extends string> = TColumn extends {
+  __polymorphic: infer TMeta;
+} ? TMeta extends {
+  as: infer TAlias extends string;
+  variants: infer TVariants extends Record<string, Record<string, ColumnBuilderBase>>;
+} ? {
+  as: TAlias;
+  discriminator: TDiscriminator;
+  variants: TVariants;
+} : never : never;
+type TablePolymorphicMetadata<TTableConfig extends TableRelationalConfig> = { [K in Extract<keyof TTableConfig['table']['_']['columns'], string>]: TablePolymorphicMetadataFromColumn<TTableConfig['table']['_']['columns'][K], K> }[Extract<keyof TTableConfig['table']['_']['columns'], string>];
+type PolymorphicResultFromMetadata<TMetadata> = TMetadata extends {
+  as: infer TAlias extends string;
+  discriminator: infer TDiscriminator extends string;
+  variants: infer TVariants extends Record<string, Record<string, ColumnBuilderBase>>;
+} ? { [TCase in keyof TVariants & string]: { [K in TDiscriminator]: TCase } & { [K in TAlias]: InferModelFromColumns<TVariants[TCase]> } }[keyof TVariants & string] : {};
+type TablePolymorphicResult<TTableConfig extends TableRelationalConfig> = [TablePolymorphicMetadata<TTableConfig>] extends [never] ? {} : PolymorphicResultFromMetadata<TablePolymorphicMetadata<TTableConfig>>;
+type RelationNames<TTableConfig extends TableRelationalConfig> = Extract<keyof TTableConfig['relations'], string>;
+type OneRelationNames<TTableConfig extends TableRelationalConfig> = { [K in RelationNames<TTableConfig>]: TTableConfig['relations'][K] extends One<any, any> ? K : never }[RelationNames<TTableConfig>];
+type WithVariantsAutoWithConfig<TTableConfig extends TableRelationalConfig, _TSelection> = { [K in OneRelationNames<TTableConfig>]: true };
+type SelectedTableResult<TTableConfig extends TableRelationalConfig, TFullSelection extends Record<string, unknown>> = InferRelationalQueryTableResult<InferModelFromColumns<TableColumns<TTableConfig>>, TFullSelection['columns'] extends Record<string, unknown> ? TFullSelection['columns'] : 'Full'>;
+type TablePolymorphicResultForSelection<TTableConfig extends TableRelationalConfig, TFullSelection extends Record<string, unknown>> = [TablePolymorphicMetadata<TTableConfig>] extends [never] ? {} : TablePolymorphicMetadata<TTableConfig> extends {
+  discriminator: infer TDiscriminator extends string;
+} ? TDiscriminator extends keyof SelectedTableResult<TTableConfig, TFullSelection> ? PolymorphicResultFromMetadata<TablePolymorphicMetadata<TTableConfig>> : {} : {};
+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 ? Simplify$1<InferModelFromColumns<TableColumns<TTableConfig>> & TablePolymorphicResult<TTableConfig>> : TFullSelection extends Record<string, unknown> ? Simplify$1<SelectedTableResult<TTableConfig, TFullSelection> & (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['withVariants'] extends true ? BuildRelationResult<TSchema, WithVariantsAutoWithConfig<TTableConfig, TFullSelection>, TTableConfig['relations']> : {}) & TablePolymorphicResultForSelection<TTableConfig, TFullSelection> & (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 } & (TInclude extends {
+  _count: infer TCountConfig;
+} ? TCountConfig extends Record<string, unknown> ? {
+  _count: { [K in NonUndefinedKeysOnly$1<TCountConfig> & keyof TRelations]: number };
+} : {} : {});
+/**
+ * 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, ColumnBuilderBase> ? Simplify$1<{ [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 MutationReturningCountSelection = Record<string, true | {
+  where?: Record<string, unknown> | undefined;
+} | undefined>;
+type ReturningSelection<TTable extends ConvexTable<any>> = Record<string, TableColumnsForTable<TTable>[keyof TableColumnsForTable<TTable>] | MutationReturningCountSelection>;
+type ReturningResult<TSelection extends Record<string, unknown>> = Simplify$1<{ [K in keyof TSelection as K extends '_count' ? never : K]: TSelection[K] extends ColumnBuilderBase ? GetColumnData<TSelection[K], 'query'> : never } & (TSelection extends {
+  _count: infer TCount;
+} ? TCount extends Record<string, unknown> ? {
+  _count: { [K in NonUndefinedKeysOnly$1<TCount> & string]: number };
+} : {} : {})>;
+type ReturningAll<TTable extends ConvexTable<any>> = InferSelectModel<TTable>;
+type MutationReturning = true | Record<string, unknown> | undefined;
+type MutationResult<TTable extends ConvexTable<any>, TReturning extends MutationReturning> = TReturning extends true ? ReturningAll<TTable>[] : TReturning extends Record<string, ColumnBuilderBase> ? ReturningResult<TReturning>[] : undefined;
+type MutationPaginateConfig = {
+  cursor: string | null;
+  limit: number;
+};
+type MutationRunMode = 'sync' | 'async';
+type MutationExecuteConfig = {
+  mode?: MutationRunMode;
+  batchSize?: number;
+  delayMs?: number;
+};
+type MutationExecutionMode = 'single' | 'paged';
+type MutationPaginatedResult<TTable extends ConvexTable<any>, TReturning extends MutationReturning> = Simplify$1<{
+  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 ColumnBuilderBase> = GetColumnData<TColumn, 'query'> | (TColumn['_']['notNull'] extends true ? never : UnsetToken) | undefined;
+type UpdateSet<TTable extends ConvexTable<any>> = Simplify$1<{ [K in keyof TTable['_']['columns'] & string]?: UpdateSetValue<TTable['_']['columns'][K]> }>;
+//#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/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/constraints.d.ts
+type ConvexConstraintColumn = ColumnBuilderBase;
+type ConvexForeignKeyColumns = [ConvexConstraintColumn, ...ConvexConstraintColumn[]];
+interface ConvexUniqueConstraintConfig {
+  columns: ConvexConstraintColumn[];
+  name?: string;
+  nullsNotDistinct: boolean;
+}
+interface ConvexForeignKeyConfig<TColumns extends ConvexForeignKeyColumns = ConvexForeignKeyColumns> {
+  columns: TColumns;
+  foreignColumns: { [K in keyof TColumns]: ConvexConstraintColumn };
+  name?: string;
+  onDelete?: ForeignKeyAction;
+  onUpdate?: 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 {
+  expression: FilterExpression$1<boolean>;
+  name: string;
+}
+declare class ConvexCheckBuilder {
+  static readonly [entityKind] = "ConvexCheckBuilder";
+  readonly [entityKind] = "ConvexCheckBuilder";
+  _: {
+    brand: 'ConvexCheckBuilder';
+  };
+  config: ConvexCheckConfig;
+  constructor(name: string, expression: FilterExpression$1<boolean>);
+}
+declare function check(name: string, expression: FilterExpression$1<boolean>): ConvexCheckBuilder;
+//#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> {
+  columns: TColumns;
+  name: TName;
+  unique: TUnique;
+  where?: unknown;
+}
+interface ConvexSearchIndexConfig<TName extends string = string, TSearchField extends ConvexIndexColumn = ConvexIndexColumn, TFilterFields extends readonly ConvexIndexColumn[] = ConvexIndexColumn[]> {
+  filterFields: TFilterFields;
+  name: TName;
+  searchField: TSearchField;
+  staged: boolean;
+}
+interface ConvexVectorIndexConfig<TName extends string = string, TVectorField extends ConvexIndexColumn = ConvexIndexColumn, TFilterFields extends readonly ConvexIndexColumn[] = ConvexIndexColumn[]> {
+  dimensions: number;
+  filterFields: TFilterFields;
+  name: TName;
+  staged: boolean;
+  vectorField: TVectorField;
+}
+interface ConvexAggregateIndexConfig<TName extends string = string, TColumns extends readonly ConvexIndexColumn[] = ConvexIndexColumn[]> {
+  avgFields: readonly ConvexIndexColumn[];
+  columns: TColumns;
+  countFields: readonly ConvexIndexColumn[];
+  maxFields: readonly ConvexIndexColumn[];
+  minFields: readonly ConvexIndexColumn[];
+  name: TName;
+  sumFields: readonly ConvexIndexColumn[];
+}
+interface ConvexRankIndexOrderSpec<TColumn extends ConvexIndexColumn = ConvexIndexColumn> {
+  column: TColumn;
+  direction: 'asc' | 'desc';
+}
+type ConvexRankOrderByInput<TColumn extends ConvexIndexColumn> = TColumn | {
+  column: {
+    builder: TColumn;
+  };
+  direction: 'asc' | 'desc';
+};
+interface ConvexRankIndexConfig<TName extends string = string, TPartitionColumns extends readonly ConvexIndexColumn[] = ConvexIndexColumn[], TOrderColumns extends readonly ConvexRankIndexOrderSpec[] = readonly ConvexRankIndexOrderSpec[]> {
+  name: TName;
+  orderColumns: TOrderColumns;
+  partitionColumns: TPartitionColumns;
+  sumField?: ConvexIndexColumn;
+}
+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 ConvexAggregateIndexBuilderOn<TName extends string = string> {
+  private name;
+  static readonly [entityKind] = "ConvexAggregateIndexBuilderOn";
+  readonly [entityKind] = "ConvexAggregateIndexBuilderOn";
+  constructor(name: TName);
+  on<TColumns extends [ConvexIndexColumn, ...ConvexIndexColumn[]]>(...columns: TColumns): ConvexAggregateIndexBuilder<TName, TColumns>;
+  all(): ConvexAggregateIndexBuilder<TName, []>;
+}
+declare class ConvexAggregateIndexBuilder<TName extends string = string, TColumns extends readonly ConvexIndexColumn[] = ConvexIndexColumn[]> {
+  static readonly [entityKind] = "ConvexAggregateIndexBuilder";
+  readonly [entityKind] = "ConvexAggregateIndexBuilder";
+  _: {
+    brand: 'ConvexAggregateIndexBuilder';
+    name: TName;
+    columns: TColumns;
+  };
+  config: ConvexAggregateIndexConfig<TName, TColumns>;
+  constructor(name: TName, columns: TColumns);
+  count(...fields: readonly ConvexIndexColumn[]): this;
+  sum(...fields: readonly ConvexIndexColumn[]): this;
+  avg(...fields: readonly ConvexIndexColumn[]): this;
+  min(...fields: readonly ConvexIndexColumn[]): this;
+  max(...fields: readonly ConvexIndexColumn[]): this;
+}
+declare class ConvexRankIndexBuilderOn<TName extends string = string> {
+  private name;
+  static readonly [entityKind] = "ConvexRankIndexBuilderOn";
+  readonly [entityKind] = "ConvexRankIndexBuilderOn";
+  constructor(name: TName);
+  partitionBy<TColumns extends readonly ConvexIndexColumn[]>(...columns: TColumns): ConvexRankIndexBuilder<TName, TColumns, []>;
+  all(): ConvexRankIndexBuilder<TName, [], []>;
+}
+declare class ConvexRankIndexBuilder<TName extends string = string, TPartitionColumns extends readonly ConvexIndexColumn[] = ConvexIndexColumn[], TOrderColumns extends readonly ConvexRankIndexOrderSpec[] = readonly ConvexRankIndexOrderSpec[]> {
+  static readonly [entityKind] = "ConvexRankIndexBuilder";
+  readonly [entityKind] = "ConvexRankIndexBuilder";
+  _: {
+    brand: 'ConvexRankIndexBuilder';
+    name: TName;
+    partitionColumns: TPartitionColumns;
+    orderColumns: TOrderColumns;
+  };
+  config: ConvexRankIndexConfig<TName, TPartitionColumns, TOrderColumns>;
+  constructor(name: TName, partitionColumns: TPartitionColumns, orderColumns: TOrderColumns);
+  orderBy<TNextColumns extends readonly ConvexRankIndexOrderSpec[]>(...columns: TNextColumns & readonly ConvexRankOrderByInput<ConvexIndexColumn>[]): ConvexRankIndexBuilder<TName, TPartitionColumns, TNextColumns>;
+  sum(field: ConvexIndexColumn): this;
+}
+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>;
+declare function aggregateIndex<TName extends string>(name: TName): ConvexAggregateIndexBuilderOn<TName>;
+declare function rankIndex<TName extends string>(name: TName): ConvexRankIndexBuilderOn<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$1<boolean> | ((ctx: TCtx, table: TTable) => FilterExpression$1<boolean> | Promise<FilterExpression$1<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
+declare const DEFAULT_POLYMORPHIC_ALIAS: "details";
+type PolymorphicVariantDefinitions = Record<string, Record<string, ColumnBuilderBase>>;
+type PolymorphicDiscriminatorValue<TVariants extends PolymorphicVariantDefinitions> = Extract<keyof TVariants, string>;
+type PolymorphicTypeMetadata<TVariants extends PolymorphicVariantDefinitions = PolymorphicVariantDefinitions, TAlias extends string = string> = {
+  as: TAlias;
+  variants: TVariants;
+};
+type OverrideColumnMeta<TColumn extends ColumnBuilderBase, TOverrides extends object> = TColumn extends {
+  _: infer TMeta extends object;
+} ? Omit<TColumn, '_'> & {
+  _: Omit<TMeta, keyof TOverrides> & TOverrides;
+} : TColumn;
+type PolymorphicGeneratedColumn<TColumn extends ColumnBuilderBase> = OverrideColumnMeta<TColumn, {
+  hasDefault: false;
+  notNull: false;
+}>;
+type PolymorphicDiscriminatorColumn<TVariants extends PolymorphicVariantDefinitions = PolymorphicVariantDefinitions, TAlias extends string = typeof DEFAULT_POLYMORPHIC_ALIAS> = $Type<NotNull<ConvexTextBuilderInitial<''>>, PolymorphicDiscriminatorValue<TVariants>> & {
+  __polymorphic: PolymorphicTypeMetadata<TVariants, TAlias>;
+};
+type ExtractPolymorphicVariants<TColumn> = TColumn extends {
+  __polymorphic: infer TMeta;
+} ? TMeta extends PolymorphicTypeMetadata<infer TVariants extends PolymorphicVariantDefinitions, string> ? TVariants : never : never;
+type ExtractPolymorphicGeneratedColumns<TColumns> = SimplifyObject<UnionToIntersection$1<{ [K in keyof TColumns]: ExtractPolymorphicVariants<TColumns[K]> extends infer TVariants ? [TVariants] extends [never] ? {} : { [V in keyof TVariants & string]: { [F in keyof TVariants[V] & string]: TVariants[V][F] extends ColumnBuilderBase ? PolymorphicGeneratedColumn<TVariants[V][F]> : never } }[keyof TVariants & string] : {} }[keyof TColumns]>>;
+type MergeColumnObjects<TLeft, TRight> = { [K in keyof TLeft | keyof TRight]: K extends keyof TRight ? TRight[K] : K extends keyof TLeft ? TLeft[K] : never };
+type ExpandTableColumns<TColumns> = SimplifyObject<MergeColumnObjects<TColumns, ExtractPolymorphicGeneratedColumns<TColumns>>>;
+/**
+ * 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> {
+  columns: TColumns;
+  name: TName;
+}
+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 DiscriminatorBuilderConfig<TVariants extends PolymorphicVariantDefinitions = PolymorphicVariantDefinitions, TAlias extends string = typeof DEFAULT_POLYMORPHIC_ALIAS> = {
+  as?: TAlias;
+  variants: TVariants;
+};
+declare function discriminator<const TVariants extends PolymorphicVariantDefinitions, const TAlias extends string>(config: DiscriminatorBuilderConfig<TVariants, TAlias> & {
+  as: TAlias;
+}): PolymorphicDiscriminatorColumn<TVariants, TAlias>;
+declare function discriminator<const TVariants extends PolymorphicVariantDefinitions>(config: DiscriminatorBuilderConfig<TVariants>): PolymorphicDiscriminatorColumn<TVariants, typeof DEFAULT_POLYMORPHIC_ALIAS>;
+type ConvexTableExtraConfigValue = ConvexIndexBuilder | ConvexAggregateIndexBuilder | ConvexRankIndexBuilder | ConvexSearchIndexBuilder | ConvexVectorIndexBuilder | ConvexForeignKeyBuilder | ConvexCheckBuilder | ConvexUniqueConstraintBuilder | ConvexDeletionBuilder | RlsPolicy;
+type ConvexTableExtraConfig = Record<string, ConvexTableExtraConfigValue>;
+type UnionToIntersection$1<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 AggregateFieldUnionFromColumns<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 InferAggregateIndexRecordFromExtraValue<TValue> = TValue extends ConvexAggregateIndexBuilder<infer TName extends string, infer TColumns extends readonly ConvexIndexColumn[]> ? Record<TName, AggregateFieldUnionFromColumns<TColumns>> : {};
+type InferredDbIndexesFromExtraConfig<TExtraConfig> = UnionToIntersection$1<InferDbIndexRecordFromExtraValue<ExtraConfigValues<Exclude<TExtraConfig, undefined>>>>;
+type InferredSearchIndexesFromExtraConfig<TExtraConfig> = UnionToIntersection$1<InferSearchIndexRecordFromExtraValue<ExtraConfigValues<Exclude<TExtraConfig, undefined>>>>;
+type InferredVectorIndexesFromExtraConfig<TExtraConfig> = UnionToIntersection$1<InferVectorIndexRecordFromExtraValue<ExtraConfigValues<Exclude<TExtraConfig, undefined>>>>;
+type InferredAggregateIndexesFromExtraConfig<TExtraConfig> = UnionToIntersection$1<InferAggregateIndexRecordFromExtraValue<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 NormalizeAggregateIndexMap<TIndexMap> = { [K in keyof TIndexMap as K extends string ? K : never]: TIndexMap[K] extends string ? TIndexMap[K] : 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 OrmLifecycleChangeId<TDoc> = TDoc extends {
+  _id: infer TId;
+} ? TId : TDoc extends {
+  id: infer TId;
+} ? TId : unknown;
+type OrmLifecycleChange<TDoc = Record<string, unknown>, TId = OrmLifecycleChangeId<TDoc>> = {
+  id: TId;
+} & ({
+  operation: 'insert';
+  oldDoc: null;
+  newDoc: TDoc;
+} | {
+  operation: 'update';
+  oldDoc: TDoc;
+  newDoc: TDoc;
+} | {
+  operation: 'delete';
+  oldDoc: TDoc;
+  newDoc: null;
+});
+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;
+/**
+ * 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 = {}, AggregateIndexes extends Record<string, string> = {}> 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 aggregateIndexes: AggregateIndexes;
+    readonly inferSelect: InferSelectModel<ConvexTable<T>>;
+    readonly inferInsert: InferInsertModel<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>>;
+  tableName: T['name'];
+  /**
+   * Convex schema validator
+   */
+  validator: Validator<any, any, any>;
+  /**
+   * Symbol-based metadata storage
+   */
+  [TableName]: T['name'];
+  [Columns]: T['columns'];
+  [Brand]: 'ConvexTable';
+  [RlsPolicies]: RlsPolicy[];
+  [EnableRLS]: boolean;
+  [TableDeleteConfig]?: OrmTableDeleteConfig;
+  [TablePolymorphic]?: readonly TablePolymorphicConfigRuntime[];
+}
+/**
+ * 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 = {}, AggregateIndexes extends Record<string, string> = {}> = ConvexTable<T, Indexes, SearchIndexes, VectorIndexes, AggregateIndexes> & { [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 'kitcn/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<ExpandTableColumns<TColumns>, TName>) => TExtraConfig) => ConvexTableWithColumns<{
+  name: TName;
+  columns: ColumnsWithTableName<ExpandTableColumns<TColumns>, TName>;
+}, InferDbIndexesFromExtraConfig<TExtraConfig>, InferSearchIndexesFromExtraConfig<TExtraConfig>, InferVectorIndexesFromExtraConfig<TExtraConfig>, NormalizeAggregateIndexMap<InferredAggregateIndexesFromExtraConfig<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 ExtractSchemaEntries<TTables extends object> = { [K in keyof TTables as TTables[K] extends SchemaEntry ? K extends string ? K : never : never]: Extract<TTables[K], SchemaEntry> };
+type ExtractTablesFromSchema<TSchema extends object> = TSchema extends SchemaDefinition<infer TTables, boolean> ? ExtractSchemaEntries<TTables> : ExtractSchemaEntries<TSchema>;
+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 column: ColumnBuilder<any, any, any>;
+  readonly key: string;
+  readonly tableName: TTableName;
+  readonly through?: RelationsBuilderColumnBase;
+}
+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> {
+  alias?: string;
+  from?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
+  optional?: TOptional;
+  to?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
+  where?: TableFilter<TTargetTable>;
+}
+type AnyOneConfig = OneConfig<SchemaEntry, boolean>;
+interface ManyConfig<TTargetTable extends SchemaEntry> {
+  alias?: string;
+  from?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
+  to?: RelationsBuilderColumnBase | [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]];
+  where?: TableFilter<TTargetTable>;
+}
+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 {
+  defaults?: OrmRuntimeDefaults;
+  name: string;
+  polymorphic?: readonly TablePolymorphicConfigRuntime[];
+  relations: RelationsRecord;
+  strict?: boolean;
+  table: SchemaEntry;
+}
+type TablesRelationalConfig<SchemaDef extends SchemaDefinition<any, boolean> = SchemaDefinition<any, true>, Tables extends Record<string, TableRelationalConfig> = Record<string, TableRelationalConfig>> = Tables & {
+  [OrmSchemaDefinition]?: SchemaDef;
+};
+type RelationsConfigWithSchema<TConfig extends AnyRelationsBuilderConfig, TTables extends Schema> = TablesRelationalConfig<SchemaDefinition<TTables, true>, ExtractTablesWithRelations<TConfig, TTables>>;
+type RelationsPartsConfigWithSchema<TConfig extends AnyRelationsBuilderConfig, TTables extends Schema> = TablesRelationalConfig<SchemaDefinition<TTables, true>, ExtractTablesWithRelationsParts<TConfig, TTables>>;
+type Placeholder = {
+  readonly __placeholder?: true;
+};
+type SQLWrapper = {
+  readonly __sqlWrapper?: true;
+};
+interface SQLOperator {
+  sql: (...args: any[]) => unknown;
+}
+interface RelationFieldsFilterInternals<T> {
+  AND?: RelationsFieldFilter<T>[] | undefined;
+  arrayContained?: (T extends Array<infer E> ? (E | Placeholder)[] : (T | Placeholder)[]) | Placeholder | undefined;
+  arrayContains?: (T extends Array<infer E> ? (E | Placeholder)[] : (T | Placeholder)[]) | Placeholder | undefined;
+  arrayOverlaps?: (T extends Array<infer E> ? (E | Placeholder)[] : (T | Placeholder)[]) | Placeholder | undefined;
+  between?: [T | Placeholder, T | Placeholder] | Placeholder | undefined;
+  contains?: string | Placeholder | undefined;
+  endsWith?: string | Placeholder | undefined;
+  eq?: T | Placeholder | undefined;
+  gt?: T | Placeholder | undefined;
+  gte?: T | Placeholder | undefined;
+  ilike?: string | Placeholder | undefined;
+  in?: (T | Placeholder)[] | Placeholder | undefined;
+  isNotNull?: true | undefined;
+  isNull?: true | undefined;
+  like?: string | Placeholder | undefined;
+  lt?: T | Placeholder | undefined;
+  lte?: T | Placeholder | undefined;
+  NOT?: RelationsFieldFilter<T> | undefined;
+  ne?: T | Placeholder | undefined;
+  notBetween?: [T | Placeholder, T | Placeholder] | Placeholder | undefined;
+  notIlike?: string | Placeholder | undefined;
+  notIn?: (T | Placeholder)[] | Placeholder | undefined;
+  notLike?: string | Placeholder | undefined;
+  OR?: RelationsFieldFilter<T>[] | undefined;
+  startsWith?: string | Placeholder | 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> {
+  AND?: RelationsFilter<TTable, TSchema>[] | undefined;
+  NOT?: RelationsFilter<TTable, TSchema> | undefined;
+  OR?: 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$1<RelationsFilterColumns<TColumns> & RelationsFilterRelations<TTable, TSchema> & RelationsFilterCommons<TTable, TSchema>>;
+interface TableFilterCommons<TTable extends SchemaEntry = SchemaEntry, TColumns extends Record<string, unknown> = GetTableColumns<TTable>> {
+  AND?: TableFilter<TTable, TColumns>[] | undefined;
+  NOT?: TableFilter<TTable, TColumns> | undefined;
+  OR?: 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$1<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 object, TTables extends Schema = ExtractTablesFromSchema<TSchema>>(schema: TSchema): RelationsConfigWithSchema<{}, TTables>;
+/** Builds relational config for every table in schema */
+declare function defineRelations<TSchema extends object, 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 object, 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 object, TConfig extends RelationsBuilderConfig<TTables>, TTables extends Schema = ExtractTablesFromSchema<TSchema>>(schema: TSchema, relations: (helpers: RelationsBuilder<TTables>) => TConfig): RelationsPartsConfigWithSchema<TConfig, TTables>;
+//#endregion
+//#region src/orm/extractRelationsConfig.d.ts
+/**
+ * M2-M3 CONTRACT: EdgeMetadata interface
+ * Consumed by query builder for relation traversal
+ */
+interface EdgeMetadata {
+  /** Alias for disambiguation (v1 rename of relationName) */
+  alias?: string;
+  /** Cardinality: one-to-one/many-to-one or one-to-many */
+  cardinality: 'one' | 'many';
+  /** Relation field name on source */
+  edgeName: string;
+  /** Primary source field name (best-effort) */
+  fieldName: string;
+  /** Index fields for compound indexes */
+  indexFields: string[];
+  /** Index name for efficient lookups */
+  indexName: string;
+  /** Inverse edge if bidirectional relation */
+  inverseEdge?: EdgeMetadata;
+  /** Relation optional (one only) */
+  optional: boolean;
+  /** Source field names (from) */
+  sourceFields: 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;
+  /** Source table name (ts name) */
+  sourceTable: string;
+  /** Target field names (to) */
+  targetFields: string[];
+  /** Target table name (ts name) */
+  targetTable: 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/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$1<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, any>, K extends string> = Omit<T, K>;
+type ConvexDeleteExecutableThis<TTable extends ConvexTable<any>, TReturning extends MutationReturning, TMode extends MutationExecutionMode> = {
+  _: {
+    table: TTable;
+    returning: TReturning;
+    mode: TMode;
+    result: MutationExecuteResult<TTable, TReturning, TMode>;
+    hasWhereOrAllowFullScan: true;
+  };
+};
+declare class ConvexDeleteBuilder<TTable extends ConvexTable<any>, TReturning extends MutationReturning = undefined, TMode extends MutationExecutionMode = 'single', THasWhereOrAllowFullScan extends boolean = false> 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>;
+    readonly hasWhereOrAllowFullScan: THasWhereOrAllowFullScan;
+  };
+  private whereExpression?;
+  private returningFields?;
+  private allowFullScanFlag;
+  private deleteModeOverride?;
+  private cascadeMode?;
+  private scheduledDelayMs?;
+  private executionModeOverride?;
+  private paginateConfig?;
+  private _loadReturningCount;
+  constructor(db: GenericDatabaseWriter<any>, table: TTable);
+  where(expression: FilterExpression$1<boolean>): ConvexDeleteBuilder<TTable, TReturning, TMode, true>;
+  returning(): ConvexDeleteWithout<ConvexDeleteBuilder<TTable, true, TMode, THasWhereOrAllowFullScan>, 'returning'>;
+  returning<TSelection extends ReturningSelection<TTable>>(fields: TSelection): ConvexDeleteWithout<ConvexDeleteBuilder<TTable, TSelection, TMode, THasWhereOrAllowFullScan>, 'returning'>;
+  paginate(config: MutationPaginateConfig): ConvexDeleteWithout<ConvexDeleteBuilder<TTable, TReturning, 'paged', THasWhereOrAllowFullScan>, 'paginate'>;
+  allowFullScan(): ConvexDeleteBuilder<TTable, TReturning, TMode, true>;
+  private getIdEquality;
+  soft(): this;
+  hard(): this;
+  scheduled(config: {
+    delayMs: number;
+  }): this;
+  private resolveDeleteModeAndDelay;
+  cascade(config: {
+    mode: CascadeMode;
+  }): this;
+  executeAsync(this: ConvexDeleteExecutableThis<TTable, TReturning, TMode>, ...args: TMode extends 'single' ? [config?: Omit<MutationExecuteConfig, 'mode'>] : [config: never]): Promise<TMode extends 'single' ? MutationExecuteResult<TTable, TReturning, 'single'> : never>;
+  execute(this: ConvexDeleteExecutableThis<TTable, TReturning, TMode>, ...args: TMode extends 'single' ? [config?: MutationExecuteConfig] : [config?: never]): Promise<MutationExecuteResult<TTable, TReturning, TMode>>;
+}
+//#endregion
+//#region src/orm/insert.d.ts
+type InsertOnConflictDoNothingConfig<_TTable extends ConvexTable<any>> = {
+  target?: ColumnBuilder<any, any, any> | ColumnBuilder<any, any, any>[];
+  where?: FilterExpression$1<boolean>;
+};
+type InsertOnConflictDoUpdateConfig<TTable extends ConvexTable<any>> = {
+  target: ColumnBuilder<any, any, any> | ColumnBuilder<any, any, any>[];
+  set: UpdateSet<TTable>;
+  targetWhere?: FilterExpression$1<boolean>;
+  setWhere?: FilterExpression$1<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;
+  private _loadReturningCount;
+  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
+declare class GelRankQuery<TTableConfig extends TableRelationalConfig = TableRelationalConfig> {
+  private readonly db;
+  private readonly tableConfig;
+  private readonly indexName;
+  private readonly config;
+  private readonly rls?;
+  constructor(db: GenericDatabaseReader<any>, tableConfig: TTableConfig, indexName: string, config?: {
+    where?: Record<string, unknown>;
+  }, rls?: RlsContext | undefined);
+  private _plan;
+  count(): Promise<number>;
+  sum(): Promise<number>;
+  at(offset: number): Promise<{
+    id: string;
+    key: unknown;
+    sumValue: number;
+  } | null>;
+  indexOf(args: {
+    id: string;
+  }): Promise<number>;
+  paginate(args: {
+    cursor?: string | null;
+    limit: number;
+  }): Promise<{
+    continueCursor: string;
+    isDone: boolean;
+    page: Array<{
+      id: string;
+      key: unknown;
+      sumValue: number;
+    }>;
+  }>;
+  min(): Promise<{
+    id: string;
+    key: unknown;
+    sumValue: number;
+  } | null>;
+  max(): Promise<{
+    id: string;
+    key: unknown;
+    sumValue: number;
+  } | null>;
+  random(): Promise<{
+    id: string;
+    key: unknown;
+    sumValue: number;
+  } | null>;
+}
+/**
+ * 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;
+  private readonly _countIndexReadinessByKey;
+  private readonly _aggregateIndexReadinessByKey;
+  constructor(schema: TSchema, tableConfig: TTableConfig, edgeMetadata: EdgeMetadata[], db: GenericDatabaseReader<any>, config: DBQueryConfig<'one' | 'many', boolean, TSchema, TTableConfig>, mode: 'many' | 'first' | 'firstOrThrow' | 'count' | 'aggregate' | 'groupBy', _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 _normalizeRelationFieldName;
+  private _toPublicFilterFieldName;
+  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 _resolvePolymorphicFinalizeState;
+  private _resolveWithVariantsState;
+  private _assertPolymorphicAliasCollisions;
+  private _synthesizePolymorphicRows;
+  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;
+  private _tryNativeUnfilteredCount;
+  private _executeCountRequiresObjectWhere;
+  private _normalizeAggregateFieldName;
+  private _isEmptyWhere;
+  private _coerceAggregateReturnValue;
+  private _coerceCountSelect;
+  private _coerceCountWindowConfig;
+  private _coerceAggregateWindowConfig;
+  private _applyCountWindowBounds;
+  private _ensureCountIndexReadyOnce;
+  private _ensureAggregateIndexReadyOnce;
+  private _rethrowAggregateCountError;
+  private _executeCountScalar;
+  private _executeCount;
+  private _coerceAggregateFieldSelection;
+  private _coerceAggregateCountSelection;
+  private _coerceAggregateConfig;
+  private _executeAggregate;
+  private _getAggregateCartesianMaxKeys;
+  private _getAggregateWorkBudget;
+  private _serializeGroupByValue;
+  private _pushGroupByConstraint;
+  private _parseGroupByFieldConstraint;
+  private _collectGroupByFieldValues;
+  private _buildGroupByCandidates;
+  private _coerceGroupByByFields;
+  private _isGroupByOrderDirection;
+  private _groupByOrderPathLabel;
+  private _readGroupByPathValue;
+  private _compareGroupByValues;
+  private _compareGroupByRows;
+  private _coerceGroupByOrderSpecs;
+  private _coerceGroupByWindowConfig;
+  private _isGroupByHavingValueOperatorObject;
+  private _matchesGroupByHavingValuePredicate;
+  private _evaluateGroupByHaving;
+  private _coerceGroupByConfig;
+  private _buildAggregateMetricConfig;
+  private _executeGroupBy;
+  /**
+   * 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;
+  private _createRelationCountError;
+  private _remapRelationCountError;
+  private _coerceRelationCountWhere;
+  private _normalizeRelationCountCacheValue;
+  private _getRelationCountParentKey;
+  private _buildRelationCountExecutionKey;
+  private _readIndexedRelationCount;
+  private _countRelationForRow;
+  private _loadRelationCounts;
+  /**
+   * 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 KnownKeysOnlyStrict<T, K> = 0 extends 1 & T ? never : KnownKeysOnly<T, K>;
+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 RelationCountWithConfig<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig> = Omit<DBQueryConfig<'many', true, TSchema, TTableConfig>, 'with'> & {
+  with: NonNullable<DBQueryConfig<'many', true, TSchema, TTableConfig>['with']> & {
+    _count: NonNullable<NonNullable<DBQueryConfig<'many', true, TSchema, TTableConfig>['with']>['_count']>;
+  };
+};
+type NonCursorConfigNoRelationCount<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig> = Omit<NonCursorConfigNoSearch<TSchema, TTableConfig>, 'with'> & {
+  with?: Exclude<NonCursorConfigNoSearch<TSchema, TTableConfig>['with'], undefined> extends infer TWith extends Record<string, unknown> ? Omit<TWith, '_count'> & {
+    _count?: never;
+  } : never;
+};
+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' | 'count' | 'aggregate', 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 | null>;
+  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>;
+  count(): GelRelationalQuery<TSchema, TTableConfig, number>;
+  count<TConfig extends CountConfig<TSchema, TTableConfig>>(config: KnownKeysOnly<TConfig, CountConfig<TSchema, TTableConfig>>): GelRelationalQuery<TSchema, TTableConfig, CountResult<TTableConfig, TConfig>>;
+  aggregate<TConfig extends AggregateConfig<TSchema, TTableConfig>>(config: KnownKeysOnly<TConfig, AggregateConfig<TSchema, TTableConfig>>): GelRelationalQuery<TSchema, TTableConfig, AggregateResult<TTableConfig, TConfig>>;
+  groupBy<TConfig extends GroupByConfig<TSchema, TTableConfig>>(config: KnownKeysOnly<TConfig, GroupByConfig<TSchema, TTableConfig>>): GelRelationalQuery<TSchema, TTableConfig, GroupByResult<TTableConfig, TConfig>>;
+  rank(indexName: string, config?: {
+    where?: Record<string, unknown>;
+  }): GelRankQuery<TTableConfig>;
+  /**
+   * 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(config: RelationCountWithConfig<TSchema, TTableConfig> & EnforcedConfig<RelationCountWithConfig<TSchema, TTableConfig>, TTableConfig, THasIndex> & DisallowWithIndexSearchOrVector<THasIndex>): GelRelationalQuery<TSchema, TTableConfig, FindManyResult<TSchema, TTableConfig, RelationCountWithConfig<TSchema, TTableConfig>>>;
+  findMany<TConfig extends SearchPaginatedConfig<TSchema, TTableConfig>>(config: KnownKeysOnlyStrict<TConfig, SearchPaginatedConfig<TSchema, TTableConfig>> & DisallowWithIndexSearchOrVector<THasIndex>): GelRelationalQuery<TSchema, TTableConfig, PaginatedResult<BuildQueryResult<TSchema, TTableConfig, TConfig>>>;
+  findMany<TConfig extends SearchNonPaginatedConfig<TSchema, TTableConfig>>(config: KnownKeysOnlyStrict<TConfig, SearchNonPaginatedConfig<TSchema, TTableConfig>> & DisallowWithIndexSearchOrVector<THasIndex>): GelRelationalQuery<TSchema, TTableConfig, BuildQueryResult<TSchema, TTableConfig, TConfig>[]>;
+  findMany<TConfig extends VectorNonPaginatedConfig<TSchema, TTableConfig>>(config: KnownKeysOnlyStrict<TConfig, VectorNonPaginatedConfig<TSchema, TTableConfig>> & DisallowWithIndexSearchOrVector<THasIndex>): GelRelationalQuery<TSchema, TTableConfig, BuildQueryResult<TSchema, TTableConfig, TConfig>[]>;
+  findMany<TConfig extends CursorPaginatedConfigNoSearch<TSchema, TTableConfig>>(config: KnownKeysOnlyStrict<TConfig, CursorPaginatedConfigNoSearch<TSchema, TTableConfig>> & EnforcedConfig<TConfig, TTableConfig, THasIndex>): GelRelationalQuery<TSchema, TTableConfig, PaginatedResult<BuildQueryResult<TSchema, TTableConfig, TConfig>>>;
+  findMany<TConfig extends NonCursorConfigNoRelationCount<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: KnownKeysOnlyStrict<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 null
+   *
+   * @example
+   * const user = await ctx.db.query.users.findFirst({
+   *   where: { email: 'alice@example.com' },
+   *   with: { profile: true }
+   * });
+   */
+  findFirst<TConfig extends SearchFindFirstConfig<TSchema, TTableConfig>>(config: KnownKeysOnlyStrict<TConfig, SearchFindFirstConfig<TSchema, TTableConfig>> & DisallowWithIndexSearchOrVector<THasIndex>): GelRelationalQuery<TSchema, TTableConfig, BuildQueryResult<TSchema, TTableConfig, TConfig> | null>;
+  findFirst<TConfig extends FindFirstConfigNoSearch<TSchema, TTableConfig>>(config?: KnownKeysOnlyStrict<TConfig, FindFirstConfigNoSearch<TSchema, TTableConfig>> & EnforcedConfig<TConfig, TTableConfig, THasIndex>): GelRelationalQuery<TSchema, TTableConfig, BuildQueryResult<TSchema, TTableConfig, TConfig> | null>;
+  /**
+   * 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: KnownKeysOnlyStrict<TConfig, SearchFindFirstConfig<TSchema, TTableConfig>> & DisallowWithIndexSearchOrVector<THasIndex>): GelRelationalQuery<TSchema, TTableConfig, BuildQueryResult<TSchema, TTableConfig, TConfig>>;
+  findFirstOrThrow<TConfig extends FindFirstConfigNoSearch<TSchema, TTableConfig>>(config?: KnownKeysOnlyStrict<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, any>, K extends string> = Omit<T, K>;
+type ConvexUpdateExecutableThis<TTable extends ConvexTable<any>, TReturning extends MutationReturning, TMode extends MutationExecutionMode> = {
+  _: {
+    table: TTable;
+    returning: TReturning;
+    mode: TMode;
+    result: MutationExecuteResult<TTable, TReturning, TMode>;
+    hasWhereOrAllowFullScan: true;
+  };
+};
+declare class ConvexUpdateBuilder<TTable extends ConvexTable<any>, TReturning extends MutationReturning = undefined, TMode extends MutationExecutionMode = 'single', THasWhereOrAllowFullScan extends boolean = false> 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>;
+    readonly hasWhereOrAllowFullScan: THasWhereOrAllowFullScan;
+  };
+  private setValues?;
+  private whereExpression?;
+  private returningFields?;
+  private allowFullScanFlag;
+  private paginateConfig?;
+  private executionModeOverride?;
+  private _loadReturningCount;
+  constructor(db: GenericDatabaseWriter<any>, table: TTable);
+  set(values: UpdateSet<TTable>): this;
+  where(expression: FilterExpression$1<boolean>): ConvexUpdateBuilder<TTable, TReturning, TMode, true>;
+  returning(): ConvexUpdateWithout<ConvexUpdateBuilder<TTable, true, TMode, THasWhereOrAllowFullScan>, 'returning'>;
+  returning<TSelection extends ReturningSelection<TTable>>(fields: TSelection): ConvexUpdateWithout<ConvexUpdateBuilder<TTable, TSelection, TMode, THasWhereOrAllowFullScan>, 'returning'>;
+  paginate(config: MutationPaginateConfig): ConvexUpdateWithout<ConvexUpdateBuilder<TTable, TReturning, 'paged', THasWhereOrAllowFullScan>, 'paginate'>;
+  allowFullScan(): ConvexUpdateBuilder<TTable, TReturning, TMode, true>;
+  private getIdEquality;
+  executeAsync(this: ConvexUpdateExecutableThis<TTable, TReturning, TMode>, ...args: TMode extends 'single' ? [config?: Omit<MutationExecuteConfig, 'mode'>] : [config: never]): Promise<TMode extends 'single' ? MutationExecuteResult<TTable, TReturning, 'single'> : never>;
+  execute(this: ConvexUpdateExecutableThis<TTable, TReturning, TMode>, ...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'> & {
+  withoutTriggers<TResult>(callback: (orm: DatabaseWithQuery<TSchema>) => Promise<TResult>): Promise<TResult>;
+  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> & {
+  withoutTriggers<TResult>(callback: (orm: DatabaseWithMutations<TSchema>) => Promise<TResult>): Promise<TResult>;
+  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/migrations/definitions.d.ts
+type MigrationDirection = 'up' | 'down';
+type MigrationRunStatus = 'pending' | 'running' | 'completed' | 'failed' | 'canceled' | 'dry_run' | 'noop';
+type MigrationWriteMode = 'safe_bypass' | 'normal';
+type MigrationSchemaInput = TablesRelationalConfig | object;
+type ResolveMigrationSchema<TSchema extends MigrationSchemaInput> = [TSchema] extends [TablesRelationalConfig] ? TSchema : TSchema extends {
+  [OrmSchemaRelations]?: infer TRelations;
+} ? Exclude<TRelations, undefined> extends TablesRelationalConfig ? Exclude<TRelations, undefined> : RelationsConfigWithSchema<{}, ExtractTablesFromSchema<TSchema & Record<string, unknown>>> : RelationsConfigWithSchema<{}, ExtractTablesFromSchema<TSchema & Record<string, unknown>>>;
+type MigrationTableName<TSchema extends MigrationSchemaInput = TablesRelationalConfig> = { [K in keyof ResolveMigrationSchema<TSchema>]-?: ResolveMigrationSchema<TSchema>[K] extends TableRelationalConfig ? ResolveMigrationSchema<TSchema>[K]['name'] : never }[keyof ResolveMigrationSchema<TSchema>] & string;
+type MigrationTableConfigByName<TSchema extends MigrationSchemaInput, TTableName extends MigrationTableName<TSchema>> = { [K in keyof ResolveMigrationSchema<TSchema>]-?: ResolveMigrationSchema<TSchema>[K] extends TableRelationalConfig ? ResolveMigrationSchema<TSchema>[K]['name'] extends TTableName ? ResolveMigrationSchema<TSchema>[K] : never : never }[keyof ResolveMigrationSchema<TSchema>];
+type MigrationDoc<TSchema extends MigrationSchemaInput = TablesRelationalConfig, TTableName extends MigrationTableName<TSchema> = MigrationTableName<TSchema>> = MigrationTableConfigByName<TSchema, TTableName> extends TableRelationalConfig ? Partial<InferSelectModel<MigrationTableConfigByName<TSchema, TTableName>['table']>> & Record<string, unknown> : Record<string, unknown>;
+type MigrationDocContext<TSchema extends MigrationSchemaInput = TablesRelationalConfig> = {
+  db: GenericDatabaseWriter<any>;
+  orm: OrmWriter<ResolveMigrationSchema<TSchema>>;
+  migrationId: string;
+  runId: string;
+  direction: MigrationDirection;
+  dryRun: boolean;
+  writeMode: MigrationWriteMode;
+};
+type MigrationMigrateOne<TSchema extends MigrationSchemaInput = TablesRelationalConfig, TTableName extends MigrationTableName<TSchema> = MigrationTableName<TSchema>> = (ctx: MigrationDocContext<TSchema>, doc: MigrationDoc<TSchema, TTableName>) => Promise<unknown> | unknown;
+type MigrationStepByTable<TSchema extends MigrationSchemaInput = TablesRelationalConfig, TTableName extends MigrationTableName<TSchema> = MigrationTableName<TSchema>> = {
+  table: TTableName;
+  batchSize?: number;
+  writeMode?: MigrationWriteMode;
+  migrateOne: MigrationMigrateOne<TSchema, TTableName>;
+};
+type MigrationStep<TSchema extends MigrationSchemaInput = TablesRelationalConfig> = { [TTableName in MigrationTableName<TSchema>]: MigrationStepByTable<TSchema, TTableName> }[MigrationTableName<TSchema>];
+type MigrationDefinition<TSchema extends MigrationSchemaInput = TablesRelationalConfig> = {
+  id: string;
+  name?: string;
+  description?: string;
+  up: MigrationStep<TSchema>;
+  down?: MigrationStep<TSchema>;
+  checksum?: string;
+};
+type MigrationManifestEntry<TSchema extends MigrationSchemaInput = TablesRelationalConfig> = MigrationDefinition<TSchema> & {
+  checksum: string;
+};
+type MigrationSet<TSchema extends MigrationSchemaInput = TablesRelationalConfig> = {
+  migrations: readonly MigrationManifestEntry<TSchema>[];
+  ids: readonly string[];
+  byId: Readonly<Record<string, MigrationManifestEntry<TSchema>>>;
+};
+type MigrationAppliedState = {
+  applied: boolean;
+  checksum?: string;
+  cursor?: string | null;
+  processed?: number;
+};
+type MigrationStateMap = Readonly<Record<string, MigrationAppliedState>>;
+type MigrationDriftIssue = {
+  kind: 'missing_from_manifest';
+  migrationId: string;
+  message: string;
+} | {
+  kind: 'checksum_mismatch';
+  migrationId: string;
+  message: string;
+  expectedChecksum: string;
+  actualChecksum: string;
+};
+type MigrationPlan<TSchema extends MigrationSchemaInput = TablesRelationalConfig> = {
+  direction: MigrationDirection;
+  migrations: readonly MigrationManifestEntry<TSchema>[];
+};
+declare function defineMigration<TSchema extends MigrationSchemaInput = TablesRelationalConfig>(migration: MigrationDefinition<TSchema>): MigrationDefinition<TSchema>;
+declare function defineMigrationSet<TSchema extends MigrationSchemaInput = TablesRelationalConfig>(migrations: readonly MigrationDefinition<TSchema>[]): MigrationSet<TSchema>;
+declare function detectMigrationDrift<TSchema extends MigrationSchemaInput = TablesRelationalConfig>(params: {
+  migrationSet: MigrationSet<TSchema>;
+  appliedState: MigrationStateMap;
+}): MigrationDriftIssue[];
+declare function buildMigrationPlan<TSchema extends MigrationSchemaInput = TablesRelationalConfig>(params: {
+  direction: MigrationDirection;
+  migrationSet: MigrationSet<TSchema>;
+  appliedState: MigrationStateMap;
+  steps?: number;
+  to?: string;
+}): MigrationPlan<TSchema>;
+//#endregion
+//#region src/orm/migrations/runtime.d.ts
+type MigrationRunArgs = {
+  direction?: MigrationDirection;
+  steps?: number;
+  to?: string;
+  dryRun?: boolean;
+  allowDrift?: boolean;
+  batchSize?: number;
+  restart?: boolean;
+};
+type MigrationRunChunkArgs = {
+  runId: string;
+  batchSize?: number;
+};
+type MigrationStatusArgs = {
+  runId?: string;
+  limit?: number;
+};
+type MigrationCancelArgs = {
+  runId?: string;
+};
+//#endregion
+//#region src/orm/triggers.d.ts
+type MaybePromise<T> = T | Promise<T>;
+type AnyRecord = Record<string, unknown>;
+type KnownKeys<T> = { [K in keyof T]-?: string extends K ? never : number extends K ? never : symbol extends K ? never : K }[keyof T];
+type TriggerTableName<TSchema extends TablesRelationalConfig> = { [K in KnownKeys<TSchema>]-?: TSchema[K] extends TableRelationalConfig ? K extends string ? K : never : never }[KnownKeys<TSchema>];
+type TriggerDoc<TSchema extends TablesRelationalConfig, TTableName extends TriggerTableName<TSchema>> = TSchema[TTableName] extends TableRelationalConfig ? InferSelectModel<TSchema[TTableName]['table']> : never;
+type TriggerInsertData<TSchema extends TablesRelationalConfig, TTableName extends TriggerTableName<TSchema>> = TSchema[TTableName] extends TableRelationalConfig ? InferInsertModel<TSchema[TTableName]['table']> : never;
+type TriggerUpdateData<TSchema extends TablesRelationalConfig, TTableName extends TriggerTableName<TSchema>> = Partial<TriggerInsertData<TSchema, TTableName>>;
+type OrmTriggerContext<TSchema extends TablesRelationalConfig, TExtraCtx extends object = {}> = Omit<TExtraCtx, 'db' | 'innerDb' | 'orm'> & {
+  db: GenericDatabaseWriter<any>;
+  innerDb: GenericDatabaseWriter<any>;
+  orm: OrmWriter<TSchema>;
+};
+type TriggerChangeId<TDoc> = TDoc extends {
+  _id: infer TId;
+} ? TId : TDoc extends {
+  id: infer TId;
+} ? TId : unknown;
+type OrmTriggerChange<TDoc = AnyRecord, TId = TriggerChangeId<TDoc>> = OrmLifecycleChange<TDoc, TId>;
+type OrmBeforeResult<TData extends AnyRecord> = void | false | {
+  data: Partial<TData>;
+};
+type OrmBeforeHook<TData extends AnyRecord, TCtx extends object> = (data: TData, ctx: TCtx) => MaybePromise<OrmBeforeResult<TData>>;
+type OrmAfterHook<TDoc extends AnyRecord, TCtx extends object> = (doc: TDoc, ctx: TCtx) => MaybePromise<void>;
+type OrmChangeHook<TDoc extends AnyRecord, TCtx extends object> = ((change: OrmTriggerChange<TDoc>, ctx: TCtx) => MaybePromise<void>) | {
+  (): unknown;
+  (change: OrmTriggerChange<TDoc>, ctx: TCtx): MaybePromise<void>;
+};
+type OrmTableTriggers<TDoc extends AnyRecord, TInsert extends AnyRecord, TUpdate extends AnyRecord, TCtx extends object> = {
+  create?: {
+    before?: OrmBeforeHook<TInsert, TCtx>;
+    after?: OrmAfterHook<TDoc, TCtx>;
+  };
+  update?: {
+    before?: OrmBeforeHook<TUpdate, TCtx>;
+    after?: OrmAfterHook<TDoc, TCtx>;
+  };
+  delete?: {
+    before?: OrmBeforeHook<TDoc, TCtx>;
+    after?: OrmAfterHook<TDoc, TCtx>;
+  };
+  change?: OrmChangeHook<TDoc, TCtx>;
+};
+type OrmTriggers<TSchema extends TablesRelationalConfig, TExtraCtx extends object = {}> = { [TTableName in TriggerTableName<TSchema>]?: OrmTableTriggers<TriggerDoc<TSchema, TTableName>, TriggerInsertData<TSchema, TTableName>, TriggerUpdateData<TSchema, TTableName>, OrmTriggerContext<TSchema, TExtraCtx>> };
+declare function defineTriggers<TSchema extends TablesRelationalConfig>(schema: TSchema, triggers: OrmTriggers<TSchema>): OrmTriggers<TSchema>;
+declare function defineTriggers<TSchema extends TablesRelationalConfig, TExtraCtx extends object>(schema: TSchema, triggers: OrmTriggers<TSchema, TExtraCtx>): OrmTriggers<TSchema, TExtraCtx>;
+//#endregion
+//#region src/orm/extensions.d.ts
+type SafeExtensionRelationsConfig<TRelationsConfig extends AnyRelationsBuilderConfig | undefined> = TRelationsConfig extends AnyRelationsBuilderConfig ? TRelationsConfig : {};
+type SchemaExtensionRelationsAuthoringConfig<TTables extends object> = { [TTableName in keyof ExtractTablesFromSchema<TTables>]?: RelationsBuilderConfigValue };
+type BivariantCallback<TCallback extends (...args: any[]) => unknown> = {
+  bivarianceHack(...args: Parameters<TCallback>): ReturnType<TCallback>;
+}['bivarianceHack'];
+type SchemaExtensionRelationsFactory<TTables extends object, TRelationsConfig extends AnyRelationsBuilderConfig> = (helpers: RelationsBuilder<ExtractTablesFromSchema<TTables>>) => TRelationsConfig;
+type SchemaExtensionTriggersInput<TTables extends object = {}, TRelationsConfig extends AnyRelationsBuilderConfig | undefined = AnyRelationsBuilderConfig | undefined> = OrmTriggers<RelationsConfigWithSchema<SafeExtensionRelationsConfig<TRelationsConfig>, ExtractTablesFromSchema<TTables>>>;
+type SchemaExtension<TTables extends object = {}, TRelationsConfig extends AnyRelationsBuilderConfig | undefined = AnyRelationsBuilderConfig | undefined, TTriggers extends SchemaExtensionTriggersInput<TTables, TRelationsConfig> | undefined = SchemaExtensionTriggersInput<TTables, TRelationsConfig> | undefined> = {
+  key: string;
+  tables: TTables;
+  [OrmSchemaExtensionRelations]?: TRelationsConfig extends AnyRelationsBuilderConfig ? BivariantCallback<SchemaExtensionRelationsFactory<TTables, TRelationsConfig>> : undefined;
+  [OrmSchemaExtensionTriggers]?: TTriggers;
+};
+type AnySchemaExtension = SchemaExtension<object, AnyRelationsBuilderConfig | undefined, SchemaExtensionTriggersInput<object, AnyRelationsBuilderConfig | undefined> | undefined>;
+type SchemaExtensionChain<TTables extends object, TRelationsConfig extends AnyRelationsBuilderConfig | undefined, TCanRelations extends boolean, TCanTriggers extends boolean> = SchemaExtension<TTables, TRelationsConfig, SchemaExtensionTriggersInput<TTables, TRelationsConfig> | undefined> & (TCanRelations extends true ? {
+  relations: <const TNextRelationsConfig extends SchemaExtensionRelationsAuthoringConfig<TTables>>(relations: SchemaExtensionRelationsFactory<TTables, TNextRelationsConfig>) => SchemaExtensionChain<TTables, TNextRelationsConfig, false, true>;
+} : {}) & (TCanTriggers extends true ? {
+  triggers: (triggers: SchemaExtensionTriggersInput<TTables, TRelationsConfig>) => SchemaExtensionChain<TTables, TRelationsConfig, false, false>;
+} : {});
+declare function defineSchemaExtension<const TTables extends object>(key: string, tables: TTables): SchemaExtensionChain<TTables, undefined, true, true>;
+//#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;
+  aggregateBackfillChunk?: SchedulableFunctionReference;
+  migrationRunChunk?: SchedulableFunctionReference;
+  resetChunk?: SchedulableFunctionReference;
+};
+type CreateOrmOptions = CreateDatabaseOptions;
+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 OrmSchemaInput = TablesRelationalConfig | object;
+type ResolveOrmSchema<TSchema extends OrmSchemaInput> = TSchema extends TablesRelationalConfig ? TSchema : TSchema extends {
+  [OrmSchemaRelations]?: infer TRelations;
+} ? Exclude<TRelations, undefined> extends TablesRelationalConfig ? Exclude<TRelations, undefined> : RelationsConfigWithSchema<{}, ExtractTablesFromSchema<TSchema & Record<string, unknown>>> : RelationsConfigWithSchema<{}, ExtractTablesFromSchema<TSchema & Record<string, unknown>>>;
+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 OrmSchemaInput> = {
+  schema: TSchema;
+  migrations?: MigrationSet<any>;
+  internalMutation?: typeof internalMutationGeneric;
+};
+type CreateOrmConfigWithFunctions<TSchema extends OrmSchemaInput> = CreateOrmConfigBase<TSchema> & {
+  ormFunctions: OrmFunctions;
+};
+type CreateOrmConfigWithoutFunctions<TSchema extends OrmSchemaInput> = 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>;
+  aggregateBackfill: ReturnType<typeof internalMutationGeneric>;
+  aggregateBackfillChunk: ReturnType<typeof internalMutationGeneric>;
+  aggregateBackfillStatus: ReturnType<typeof internalMutationGeneric>;
+  migrationRun: ReturnType<typeof internalMutationGeneric>;
+  migrationRunChunk: ReturnType<typeof internalMutationGeneric>;
+  migrationStatus: ReturnType<typeof internalMutationGeneric>;
+  migrationCancel: ReturnType<typeof internalMutationGeneric>;
+  resetChunk: ReturnType<typeof internalMutationGeneric>;
+  reset: ReturnType<typeof internalActionGeneric>;
+};
+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 OrmSchemaInput>(config: CreateOrmConfigWithoutFunctions<TSchema>): OrmClientBase<ResolveOrmSchema<TSchema>>;
+declare function createOrm<TSchema extends OrmSchemaInput>(config: CreateOrmConfigWithFunctions<TSchema>): OrmClientWithApi<ResolveOrmSchema<TSchema>>;
+//#endregion
+//#region src/orm/aggregate-index/backfill.d.ts
+type CountBackfillMode = 'resume' | 'rebuild' | 'prune';
+type CountBackfillKickoffArgs = {
+  tableName?: string;
+  indexName?: string;
+  batchSize?: number;
+  mode?: CountBackfillMode;
+};
+type CountBackfillChunkArgs = {
+  tableName?: string;
+  indexName?: string;
+  batchSize?: number;
+};
+type CountBackfillStatusArgs = {
+  tableName?: string;
+  indexName?: string;
+};
+//#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 AnyColumnBuilder = ColumnBuilder<any, any, any>;
+interface NestedShapeInput {
+  [key: string]: NestedInput;
+}
+type NestedInput = AnyValidator | AnyColumnBuilder | NestedShapeInput;
+type InferBuilderNestedValue<TBuilder extends AnyColumnBuilder> = TBuilder['_'] extends {
+  $type: infer TType;
+} ? TType : TBuilder['_'] extends {
+  data: infer TData;
+} ? TBuilder['_'] extends {
+  notNull: true;
+} ? TData : TData | null : never;
+type InferValidatorNestedValue<TValidator extends AnyValidator> = Exclude<TValidator['type'], undefined>;
+type InferNestedValue<TInput extends NestedInput> = TInput extends AnyColumnBuilder ? InferBuilderNestedValue<TInput> : TInput extends AnyValidator ? InferValidatorNestedValue<TInput> : TInput extends NestedShapeInput ? InferObjectShape<TInput> : never;
+type InferObjectShape<TShape extends NestedShapeInput> = { [K in keyof TShape]: InferNestedValue<TShape[K]> };
+type InferObjectValue<TInput extends NestedInput> = TInput extends AnyColumnBuilder | AnyValidator ? Record<string, InferNestedValue<TInput>> : TInput extends NestedShapeInput ? InferObjectShape<TInput> : never;
+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>;
+/**
+ * Creates an array column from a nested validator or builder.
+ *
+ * Values in nested arrays are always compiled as required validators.
+ */
+declare function arrayOf<TElement extends NestedInput>(element: TElement): $Type<ConvexCustomBuilderInitial<"", convex_values0.VArray<any[], AnyValidator, "required">>, InferNestedValue<TElement>[]>;
+/**
+ * Creates a union column from validators/builders without dropping to `v.union(...)`.
+ */
+declare function unionOf<const TMembers extends readonly [NestedInput, NestedInput, ...NestedInput[]]>(...members: TMembers): $Type<ConvexCustomBuilderInitial<"", convex_values0.VUnion<any, [AnyValidator, AnyValidator, ...AnyValidator[]], "required", any>>, InferNestedValue<TMembers[number]>>;
+/**
+ * Creates an object column from either:
+ * - a nested shape of validators/builders, or
+ * - a validator/builder describing homogeneous record values
+ *
+ * Fields in nested objects are always compiled as required validators.
+ */
+declare function objectOf<TInput extends NestedInput>(input: TInput): $Type<ConvexCustomBuilderInitial<"", convex_values0.VRecord<Record<string, any>, convex_values0.VString<string, "required">, AnyValidator, "required", string>>, InferObjectValue<TInput>> | $Type<ConvexCustomBuilderInitial<"", AnyValidator>, InferObjectValue<TInput>>;
+/**
+ * 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_values0.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/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/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
+type TableAggregateIndex = {
+  name: string;
+  fields: string[];
+  countFields: string[];
+  sumFields: string[];
+  avgFields: string[];
+  minFields: string[];
+  maxFields: string[];
+};
+type TableRankIndex = {
+  name: string;
+  partitionFields: string[];
+  orderFields: Array<{
+    field: string;
+    direction: 'asc' | 'desc';
+  }>;
+  sumField?: string;
+};
+declare function getIndexes(table: ConvexTable<any>): {
+  name: string;
+  fields: string[];
+}[];
+declare function getAggregateIndexes(table: ConvexTable<any>): TableAggregateIndex[];
+declare function getRankIndexes(table: ConvexTable<any>): TableRankIndex[];
+//#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>;
+  aggregateIndexes: ReturnType<typeof getAggregateIndexes>;
+  rankIndexes: ReturnType<typeof getRankIndexes>;
+  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 UnionToIntersection<T> = (T extends unknown ? (value: T) => void : never) extends ((value: infer I) => void) ? I : never;
+type Simplify<T> = { [K in keyof T]: T[K] } & {};
+type ExtensionList = readonly AnySchemaExtension[];
+type ExtensionTables<TExtension extends AnySchemaExtension> = TExtension extends SchemaExtension<infer TTables extends object, any, any> ? TTables : {};
+type ExtensionRelationsConfig<TExtension extends AnySchemaExtension> = TExtension extends SchemaExtension<any, infer TRelationsConfig extends AnyRelationsBuilderConfig | undefined, any> ? TRelationsConfig extends AnyRelationsBuilderConfig ? TRelationsConfig : {} : {};
+type ResolvedSchemaExtensions<TExtensions extends ExtensionList> = readonly [...typeof BUILTIN_SCHEMA_EXTENSIONS, ...TExtensions];
+type InjectedSchemaFromExtensions<TExtensions extends ExtensionList> = Simplify<UnionToIntersection<ExtensionTables<TExtensions[number]>>>;
+type SchemaWithExtensions<TSchema extends object, TExtensions extends ExtensionList> = Simplify<TSchema & InjectedSchemaFromExtensions<ResolvedSchemaExtensions<TExtensions>>>;
+type RelationsConfigFromExtensions<TExtensions extends ExtensionList> = Simplify<UnionToIntersection<ExtensionRelationsConfig<ResolvedSchemaExtensions<TExtensions>[number]>>>;
+type ResolvedRelationsConfig<TExtensions extends ExtensionList, TRelationsConfig extends AnyRelationsBuilderConfig | undefined> = Simplify<RelationsConfigFromExtensions<TExtensions> & (TRelationsConfig extends AnyRelationsBuilderConfig ? TRelationsConfig : {})>;
+type SafeRelationsConfig<TExtensions extends ExtensionList, TRelationsConfig extends AnyRelationsBuilderConfig | undefined> = ResolvedRelationsConfig<TExtensions, TRelationsConfig> extends AnyRelationsBuilderConfig ? ResolvedRelationsConfig<TExtensions, TRelationsConfig> : AnyRelationsBuilderConfig;
+type SchemaRelationsFactory<TSchema extends object, TRelationsConfig extends AnyRelationsBuilderConfig> = (helpers: RelationsBuilder<ExtractTablesFromSchema<TSchema>>) => TRelationsConfig;
+type SchemaRelations<TSchema extends object, TExtensions extends ExtensionList, TRelationsConfig extends AnyRelationsBuilderConfig | undefined> = RelationsConfigWithSchema<SafeRelationsConfig<TExtensions, TRelationsConfig>, ExtractTablesFromSchema<TSchema>>;
+type SchemaRelationsAuthoringConfig<TSchema extends object> = { [TTableName in keyof ExtractTablesFromSchema<TSchema>]?: RelationsBuilderConfigValue };
+type SchemaOptions<StrictTableNameTypes extends boolean> = DefineSchemaOptions<StrictTableNameTypes> & {
+  strict?: boolean;
+  defaults?: OrmRuntimeDefaults;
+};
+type SchemaResult<TSchema extends GenericSchema, StrictTableNameTypes extends boolean, TExtensions extends ExtensionList, TRelationsConfig extends AnyRelationsBuilderConfig | undefined> = SchemaDefinition<SchemaWithExtensions<TSchema, TExtensions>, StrictTableNameTypes> & {
+  [OrmSchemaRelations]?: SchemaRelations<SchemaWithExtensions<TSchema, TExtensions>, TExtensions, TRelationsConfig>;
+  [OrmSchemaTriggers]?: OrmTriggers<SchemaRelations<SchemaWithExtensions<TSchema, TExtensions>, TExtensions, TRelationsConfig>>;
+};
+type SchemaChain<TSchema extends GenericSchema, StrictTableNameTypes extends boolean, TExtensions extends ExtensionList, TRelationsConfig extends AnyRelationsBuilderConfig | undefined, TCanExtend extends boolean, TCanRelations extends boolean, TCanTriggers extends boolean> = SchemaResult<TSchema, StrictTableNameTypes, TExtensions, TRelationsConfig> & (TCanExtend extends true ? {
+  extend: <const TNewExtensions extends ExtensionList>(...extensions: TNewExtensions) => SchemaChain<TSchema, StrictTableNameTypes, readonly [...TExtensions, ...TNewExtensions], TRelationsConfig, true, true, true>;
+} : {}) & (TCanRelations extends true ? {
+  relations: <const TNextRelationsConfig extends SchemaRelationsAuthoringConfig<SchemaWithExtensions<TSchema, TExtensions>>>(relations: SchemaRelationsFactory<SchemaWithExtensions<TSchema, TExtensions>, TNextRelationsConfig>) => SchemaChain<TSchema, StrictTableNameTypes, TExtensions, TNextRelationsConfig, false, false, true>;
+} : {}) & (TCanTriggers extends true ? {
+  triggers: (triggers: OrmTriggers<SchemaRelations<SchemaWithExtensions<TSchema, TExtensions>, TExtensions, TRelationsConfig>>) => SchemaChain<TSchema, StrictTableNameTypes, TExtensions, TRelationsConfig, false, false, false>;
+} : {});
+declare const BUILTIN_SCHEMA_EXTENSIONS: readonly [SchemaExtension<{
+  readonly aggregate_bucket: ConvexTableWithColumns<{
+    name: "aggregate_bucket";
+    columns: {
+      count: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_bucket";
+        };
+      } & {
+        _: {
+          fieldName: "count";
+        };
+      };
+      tableKey: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_bucket";
+        };
+      } & {
+        _: {
+          fieldName: "tableKey";
+        };
+      };
+      indexName: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_bucket";
+        };
+      } & {
+        _: {
+          fieldName: "indexName";
+        };
+      };
+      updatedAt: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_bucket";
+        };
+      } & {
+        _: {
+          fieldName: "updatedAt";
+        };
+      };
+      keyHash: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_bucket";
+        };
+      } & {
+        _: {
+          fieldName: "keyHash";
+        };
+      };
+      keyParts: ConvexCustomBuilderInitial<"", convex_values0.VArray<any[], convex_values0.VId<any, any> | convex_values0.VString<any, any> | convex_values0.VFloat64<any, any> | convex_values0.VInt64<any, any> | convex_values0.VBoolean<any, any> | convex_values0.VNull<any, any> | convex_values0.VAny<any, any, string> | convex_values0.VLiteral<any, any> | convex_values0.VBytes<any, any> | convex_values0.VObject<any, Record<string, convex_values0.Validator<any, convex_values0.OptionalProperty, any>>, any, any> | convex_values0.VArray<any, convex_values0.Validator<any, "required", any>, any> | convex_values0.VRecord<any, convex_values0.Validator<string, "required", any>, convex_values0.Validator<any, "required", any>, any, any> | convex_values0.VUnion<any, convex_values0.Validator<any, "required", any>[], any, any>, "required">> & {
+        _: {
+          $type: convex_values0.Value[];
+        };
+      } & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_bucket";
+        };
+      } & {
+        _: {
+          fieldName: "keyParts";
+        };
+      };
+      sumValues: (NotNull<$Type<ConvexCustomBuilderInitial<"", convex_values0.VRecord<Record<string, any>, convex_values0.VString<string, "required">, convex_values0.VId<any, any> | convex_values0.VString<any, any> | convex_values0.VFloat64<any, any> | convex_values0.VInt64<any, any> | convex_values0.VBoolean<any, any> | convex_values0.VNull<any, any> | convex_values0.VAny<any, any, string> | convex_values0.VLiteral<any, any> | convex_values0.VBytes<any, any> | convex_values0.VObject<any, Record<string, convex_values0.Validator<any, convex_values0.OptionalProperty, any>>, any, any> | convex_values0.VArray<any, convex_values0.Validator<any, "required", any>, any> | convex_values0.VRecord<any, convex_values0.Validator<string, "required", any>, convex_values0.Validator<any, "required", any>, any, any> | convex_values0.VUnion<any, convex_values0.Validator<any, "required", any>[], any, any>, "required", string>>, Record<string, number>>> | NotNull<$Type<ConvexCustomBuilderInitial<"", convex_values0.VId<any, any> | convex_values0.VString<any, any> | convex_values0.VFloat64<any, any> | convex_values0.VInt64<any, any> | convex_values0.VBoolean<any, any> | convex_values0.VNull<any, any> | convex_values0.VAny<any, any, string> | convex_values0.VLiteral<any, any> | convex_values0.VBytes<any, any> | convex_values0.VObject<any, Record<string, convex_values0.Validator<any, convex_values0.OptionalProperty, any>>, any, any> | convex_values0.VArray<any, convex_values0.Validator<any, "required", any>, any> | convex_values0.VRecord<any, convex_values0.Validator<string, "required", any>, convex_values0.Validator<any, "required", any>, any, any> | convex_values0.VUnion<any, convex_values0.Validator<any, "required", any>[], any, any>>, Record<string, number>>>) & {
+        _: {
+          tableName: "aggregate_bucket";
+        };
+      } & {
+        _: {
+          fieldName: "sumValues";
+        };
+      };
+      nonNullCountValues: (NotNull<$Type<ConvexCustomBuilderInitial<"", convex_values0.VRecord<Record<string, any>, convex_values0.VString<string, "required">, convex_values0.VId<any, any> | convex_values0.VString<any, any> | convex_values0.VFloat64<any, any> | convex_values0.VInt64<any, any> | convex_values0.VBoolean<any, any> | convex_values0.VNull<any, any> | convex_values0.VAny<any, any, string> | convex_values0.VLiteral<any, any> | convex_values0.VBytes<any, any> | convex_values0.VObject<any, Record<string, convex_values0.Validator<any, convex_values0.OptionalProperty, any>>, any, any> | convex_values0.VArray<any, convex_values0.Validator<any, "required", any>, any> | convex_values0.VRecord<any, convex_values0.Validator<string, "required", any>, convex_values0.Validator<any, "required", any>, any, any> | convex_values0.VUnion<any, convex_values0.Validator<any, "required", any>[], any, any>, "required", string>>, Record<string, number>>> | NotNull<$Type<ConvexCustomBuilderInitial<"", convex_values0.VId<any, any> | convex_values0.VString<any, any> | convex_values0.VFloat64<any, any> | convex_values0.VInt64<any, any> | convex_values0.VBoolean<any, any> | convex_values0.VNull<any, any> | convex_values0.VAny<any, any, string> | convex_values0.VLiteral<any, any> | convex_values0.VBytes<any, any> | convex_values0.VObject<any, Record<string, convex_values0.Validator<any, convex_values0.OptionalProperty, any>>, any, any> | convex_values0.VArray<any, convex_values0.Validator<any, "required", any>, any> | convex_values0.VRecord<any, convex_values0.Validator<string, "required", any>, convex_values0.Validator<any, "required", any>, any, any> | convex_values0.VUnion<any, convex_values0.Validator<any, "required", any>[], any, any>>, Record<string, number>>>) & {
+        _: {
+          tableName: "aggregate_bucket";
+        };
+      } & {
+        _: {
+          fieldName: "nonNullCountValues";
+        };
+      };
+    };
+  }, {
+    by_creation_time: ["_creationTime"];
+    by_table_index_hash: ["tableKey", "indexName", "keyHash", "_creationTime"];
+    by_table_index: ["tableKey", "indexName", "_creationTime"];
+  }, {}, {}, {}>;
+  readonly aggregate_member: ConvexTableWithColumns<{
+    name: "aggregate_member";
+    columns: {
+      kind: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_member";
+        };
+      } & {
+        _: {
+          fieldName: "kind";
+        };
+      };
+      tableKey: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_member";
+        };
+      } & {
+        _: {
+          fieldName: "tableKey";
+        };
+      };
+      indexName: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_member";
+        };
+      } & {
+        _: {
+          fieldName: "indexName";
+        };
+      };
+      updatedAt: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_member";
+        };
+      } & {
+        _: {
+          fieldName: "updatedAt";
+        };
+      };
+      keyHash: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_member";
+        };
+      } & {
+        _: {
+          fieldName: "keyHash";
+        };
+      };
+      keyParts: ConvexCustomBuilderInitial<"", convex_values0.VArray<any[], convex_values0.VId<any, any> | convex_values0.VString<any, any> | convex_values0.VFloat64<any, any> | convex_values0.VInt64<any, any> | convex_values0.VBoolean<any, any> | convex_values0.VNull<any, any> | convex_values0.VAny<any, any, string> | convex_values0.VLiteral<any, any> | convex_values0.VBytes<any, any> | convex_values0.VObject<any, Record<string, convex_values0.Validator<any, convex_values0.OptionalProperty, any>>, any, any> | convex_values0.VArray<any, convex_values0.Validator<any, "required", any>, any> | convex_values0.VRecord<any, convex_values0.Validator<string, "required", any>, convex_values0.Validator<any, "required", any>, any, any> | convex_values0.VUnion<any, convex_values0.Validator<any, "required", any>[], any, any>, "required">> & {
+        _: {
+          $type: convex_values0.Value[];
+        };
+      } & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_member";
+        };
+      } & {
+        _: {
+          fieldName: "keyParts";
+        };
+      };
+      sumValues: (NotNull<$Type<ConvexCustomBuilderInitial<"", convex_values0.VRecord<Record<string, any>, convex_values0.VString<string, "required">, convex_values0.VId<any, any> | convex_values0.VString<any, any> | convex_values0.VFloat64<any, any> | convex_values0.VInt64<any, any> | convex_values0.VBoolean<any, any> | convex_values0.VNull<any, any> | convex_values0.VAny<any, any, string> | convex_values0.VLiteral<any, any> | convex_values0.VBytes<any, any> | convex_values0.VObject<any, Record<string, convex_values0.Validator<any, convex_values0.OptionalProperty, any>>, any, any> | convex_values0.VArray<any, convex_values0.Validator<any, "required", any>, any> | convex_values0.VRecord<any, convex_values0.Validator<string, "required", any>, convex_values0.Validator<any, "required", any>, any, any> | convex_values0.VUnion<any, convex_values0.Validator<any, "required", any>[], any, any>, "required", string>>, Record<string, number>>> | NotNull<$Type<ConvexCustomBuilderInitial<"", convex_values0.VId<any, any> | convex_values0.VString<any, any> | convex_values0.VFloat64<any, any> | convex_values0.VInt64<any, any> | convex_values0.VBoolean<any, any> | convex_values0.VNull<any, any> | convex_values0.VAny<any, any, string> | convex_values0.VLiteral<any, any> | convex_values0.VBytes<any, any> | convex_values0.VObject<any, Record<string, convex_values0.Validator<any, convex_values0.OptionalProperty, any>>, any, any> | convex_values0.VArray<any, convex_values0.Validator<any, "required", any>, any> | convex_values0.VRecord<any, convex_values0.Validator<string, "required", any>, convex_values0.Validator<any, "required", any>, any, any> | convex_values0.VUnion<any, convex_values0.Validator<any, "required", any>[], any, any>>, Record<string, number>>>) & {
+        _: {
+          tableName: "aggregate_member";
+        };
+      } & {
+        _: {
+          fieldName: "sumValues";
+        };
+      };
+      nonNullCountValues: (NotNull<$Type<ConvexCustomBuilderInitial<"", convex_values0.VRecord<Record<string, any>, convex_values0.VString<string, "required">, convex_values0.VId<any, any> | convex_values0.VString<any, any> | convex_values0.VFloat64<any, any> | convex_values0.VInt64<any, any> | convex_values0.VBoolean<any, any> | convex_values0.VNull<any, any> | convex_values0.VAny<any, any, string> | convex_values0.VLiteral<any, any> | convex_values0.VBytes<any, any> | convex_values0.VObject<any, Record<string, convex_values0.Validator<any, convex_values0.OptionalProperty, any>>, any, any> | convex_values0.VArray<any, convex_values0.Validator<any, "required", any>, any> | convex_values0.VRecord<any, convex_values0.Validator<string, "required", any>, convex_values0.Validator<any, "required", any>, any, any> | convex_values0.VUnion<any, convex_values0.Validator<any, "required", any>[], any, any>, "required", string>>, Record<string, number>>> | NotNull<$Type<ConvexCustomBuilderInitial<"", convex_values0.VId<any, any> | convex_values0.VString<any, any> | convex_values0.VFloat64<any, any> | convex_values0.VInt64<any, any> | convex_values0.VBoolean<any, any> | convex_values0.VNull<any, any> | convex_values0.VAny<any, any, string> | convex_values0.VLiteral<any, any> | convex_values0.VBytes<any, any> | convex_values0.VObject<any, Record<string, convex_values0.Validator<any, convex_values0.OptionalProperty, any>>, any, any> | convex_values0.VArray<any, convex_values0.Validator<any, "required", any>, any> | convex_values0.VRecord<any, convex_values0.Validator<string, "required", any>, convex_values0.Validator<any, "required", any>, any, any> | convex_values0.VUnion<any, convex_values0.Validator<any, "required", any>[], any, any>>, Record<string, number>>>) & {
+        _: {
+          tableName: "aggregate_member";
+        };
+      } & {
+        _: {
+          fieldName: "nonNullCountValues";
+        };
+      };
+      docId: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_member";
+        };
+      } & {
+        _: {
+          fieldName: "docId";
+        };
+      };
+      extremaValues: (NotNull<$Type<ConvexCustomBuilderInitial<"", convex_values0.VRecord<Record<string, any>, convex_values0.VString<string, "required">, convex_values0.VId<any, any> | convex_values0.VString<any, any> | convex_values0.VFloat64<any, any> | convex_values0.VInt64<any, any> | convex_values0.VBoolean<any, any> | convex_values0.VNull<any, any> | convex_values0.VAny<any, any, string> | convex_values0.VLiteral<any, any> | convex_values0.VBytes<any, any> | convex_values0.VObject<any, Record<string, convex_values0.Validator<any, convex_values0.OptionalProperty, any>>, any, any> | convex_values0.VArray<any, convex_values0.Validator<any, "required", any>, any> | convex_values0.VRecord<any, convex_values0.Validator<string, "required", any>, convex_values0.Validator<any, "required", any>, any, any> | convex_values0.VUnion<any, convex_values0.Validator<any, "required", any>[], any, any>, "required", string>>, Record<string, convex_values0.Value>>> | NotNull<$Type<ConvexCustomBuilderInitial<"", convex_values0.VId<any, any> | convex_values0.VString<any, any> | convex_values0.VFloat64<any, any> | convex_values0.VInt64<any, any> | convex_values0.VBoolean<any, any> | convex_values0.VNull<any, any> | convex_values0.VAny<any, any, string> | convex_values0.VLiteral<any, any> | convex_values0.VBytes<any, any> | convex_values0.VObject<any, Record<string, convex_values0.Validator<any, convex_values0.OptionalProperty, any>>, any, any> | convex_values0.VArray<any, convex_values0.Validator<any, "required", any>, any> | convex_values0.VRecord<any, convex_values0.Validator<string, "required", any>, convex_values0.Validator<any, "required", any>, any, any> | convex_values0.VUnion<any, convex_values0.Validator<any, "required", any>[], any, any>>, Record<string, convex_values0.Value>>>) & {
+        _: {
+          tableName: "aggregate_member";
+        };
+      } & {
+        _: {
+          fieldName: "extremaValues";
+        };
+      };
+      rankNamespace: ConvexCustomBuilderInitial<"", convex_values0.VAny<any, "required", string>> & {
+        _: {
+          $type: convex_values0.Value;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_member";
+        };
+      } & {
+        _: {
+          fieldName: "rankNamespace";
+        };
+      };
+      rankKey: ConvexCustomBuilderInitial<"", convex_values0.VAny<any, "required", string>> & {
+        _: {
+          $type: convex_values0.Value;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_member";
+        };
+      } & {
+        _: {
+          fieldName: "rankKey";
+        };
+      };
+      rankSumValue: ConvexNumberBuilderInitial<""> & {
+        _: {
+          tableName: "aggregate_member";
+        };
+      } & {
+        _: {
+          fieldName: "rankSumValue";
+        };
+      };
+    };
+  }, {
+    by_creation_time: ["_creationTime"];
+    by_kind_table_index_doc: ["kind", "tableKey", "indexName", "docId", "_creationTime"];
+    by_kind_table_index: ["kind", "tableKey", "indexName", "_creationTime"];
+  }, {}, {}, {}>;
+  readonly aggregate_extrema: ConvexTableWithColumns<{
+    name: "aggregate_extrema";
+    columns: {
+      value: ConvexCustomBuilderInitial<"", convex_values0.VAny<any, "required", string>> & {
+        _: {
+          $type: convex_values0.Value;
+        };
+      } & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_extrema";
+        };
+      } & {
+        _: {
+          fieldName: "value";
+        };
+      };
+      count: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_extrema";
+        };
+      } & {
+        _: {
+          fieldName: "count";
+        };
+      };
+      tableKey: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_extrema";
+        };
+      } & {
+        _: {
+          fieldName: "tableKey";
+        };
+      };
+      indexName: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_extrema";
+        };
+      } & {
+        _: {
+          fieldName: "indexName";
+        };
+      };
+      updatedAt: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_extrema";
+        };
+      } & {
+        _: {
+          fieldName: "updatedAt";
+        };
+      };
+      keyHash: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_extrema";
+        };
+      } & {
+        _: {
+          fieldName: "keyHash";
+        };
+      };
+      fieldName: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_extrema";
+        };
+      } & {
+        _: {
+          fieldName: "fieldName";
+        };
+      };
+      valueHash: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_extrema";
+        };
+      } & {
+        _: {
+          fieldName: "valueHash";
+        };
+      };
+      sortKey: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_extrema";
+        };
+      } & {
+        _: {
+          fieldName: "sortKey";
+        };
+      };
+    };
+  }, {
+    by_creation_time: ["_creationTime"];
+    by_table_index: ["tableKey", "indexName", "_creationTime"];
+    by_table_index_hash_field_value: ["tableKey", "indexName", "keyHash", "fieldName", "valueHash", "_creationTime"];
+    by_table_index_hash_field_sort: ["tableKey", "indexName", "keyHash", "fieldName", "sortKey", "_creationTime"];
+  }, {}, {}, {}>;
+  readonly aggregate_rank_tree: ConvexTableWithColumns<{
+    name: "aggregate_rank_tree";
+    columns: {
+      aggregateName: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_rank_tree";
+        };
+      } & {
+        _: {
+          fieldName: "aggregateName";
+        };
+      };
+      maxNodeSize: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_rank_tree";
+        };
+      } & {
+        _: {
+          fieldName: "maxNodeSize";
+        };
+      };
+      namespace: ConvexCustomBuilderInitial<"", convex_values0.VAny<any, "required", string>> & {
+        _: {
+          $type: convex_values0.Value;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_rank_tree";
+        };
+      } & {
+        _: {
+          fieldName: "namespace";
+        };
+      };
+      root: ConvexIdBuilderInitial<"", "aggregate_rank_node"> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_rank_tree";
+        };
+      } & {
+        _: {
+          fieldName: "root";
+        };
+      };
+    };
+  }, {
+    by_creation_time: ["_creationTime"];
+    by_namespace: ["namespace", "_creationTime"];
+    by_aggregate_name: ["aggregateName", "_creationTime"];
+  }, {}, {}, {}>;
+  readonly aggregate_rank_node: ConvexTableWithColumns<{
+    name: "aggregate_rank_node";
+    columns: {
+      aggregate: ($Type<ConvexCustomBuilderInitial<"", convex_values0.VRecord<Record<string, any>, convex_values0.VString<string, "required">, convex_values0.VId<any, any> | convex_values0.VString<any, any> | convex_values0.VFloat64<any, any> | convex_values0.VInt64<any, any> | convex_values0.VBoolean<any, any> | convex_values0.VNull<any, any> | convex_values0.VAny<any, any, string> | convex_values0.VLiteral<any, any> | convex_values0.VBytes<any, any> | convex_values0.VObject<any, Record<string, convex_values0.Validator<any, convex_values0.OptionalProperty, any>>, any, any> | convex_values0.VArray<any, convex_values0.Validator<any, "required", any>, any> | convex_values0.VRecord<any, convex_values0.Validator<string, "required", any>, convex_values0.Validator<any, "required", any>, any, any> | convex_values0.VUnion<any, convex_values0.Validator<any, "required", any>[], any, any>, "required", string>>, {
+        count: number;
+        sum: number;
+      }> | $Type<ConvexCustomBuilderInitial<"", convex_values0.VId<any, any> | convex_values0.VString<any, any> | convex_values0.VFloat64<any, any> | convex_values0.VInt64<any, any> | convex_values0.VBoolean<any, any> | convex_values0.VNull<any, any> | convex_values0.VAny<any, any, string> | convex_values0.VLiteral<any, any> | convex_values0.VBytes<any, any> | convex_values0.VObject<any, Record<string, convex_values0.Validator<any, convex_values0.OptionalProperty, any>>, any, any> | convex_values0.VArray<any, convex_values0.Validator<any, "required", any>, any> | convex_values0.VRecord<any, convex_values0.Validator<string, "required", any>, convex_values0.Validator<any, "required", any>, any, any> | convex_values0.VUnion<any, convex_values0.Validator<any, "required", any>[], any, any>>, {
+        count: number;
+        sum: number;
+      }>) & {
+        _: {
+          tableName: "aggregate_rank_node";
+        };
+      } & {
+        _: {
+          fieldName: "aggregate";
+        };
+      };
+      items: ConvexCustomBuilderInitial<"", convex_values0.VArray<any[], convex_values0.VId<any, any> | convex_values0.VString<any, any> | convex_values0.VFloat64<any, any> | convex_values0.VInt64<any, any> | convex_values0.VBoolean<any, any> | convex_values0.VNull<any, any> | convex_values0.VAny<any, any, string> | convex_values0.VLiteral<any, any> | convex_values0.VBytes<any, any> | convex_values0.VObject<any, Record<string, convex_values0.Validator<any, convex_values0.OptionalProperty, any>>, any, any> | convex_values0.VArray<any, convex_values0.Validator<any, "required", any>, any> | convex_values0.VRecord<any, convex_values0.Validator<string, "required", any>, convex_values0.Validator<any, "required", any>, any, any> | convex_values0.VUnion<any, convex_values0.Validator<any, "required", any>[], any, any>, "required">> & {
+        _: {
+          $type: {
+            k: convex_values0.Value;
+            v: convex_values0.Value;
+            s: number;
+          }[];
+        };
+      } & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_rank_node";
+        };
+      } & {
+        _: {
+          fieldName: "items";
+        };
+      };
+      subtrees: ConvexCustomBuilderInitial<"", convex_values0.VArray<any[], convex_values0.VId<any, any> | convex_values0.VString<any, any> | convex_values0.VFloat64<any, any> | convex_values0.VInt64<any, any> | convex_values0.VBoolean<any, any> | convex_values0.VNull<any, any> | convex_values0.VAny<any, any, string> | convex_values0.VLiteral<any, any> | convex_values0.VBytes<any, any> | convex_values0.VObject<any, Record<string, convex_values0.Validator<any, convex_values0.OptionalProperty, any>>, any, any> | convex_values0.VArray<any, convex_values0.Validator<any, "required", any>, any> | convex_values0.VRecord<any, convex_values0.Validator<string, "required", any>, convex_values0.Validator<any, "required", any>, any, any> | convex_values0.VUnion<any, convex_values0.Validator<any, "required", any>[], any, any>, "required">> & {
+        _: {
+          $type: string[];
+        };
+      } & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_rank_node";
+        };
+      } & {
+        _: {
+          fieldName: "subtrees";
+        };
+      };
+    };
+  }, {
+    by_creation_time: ["_creationTime"];
+  }, {}, {}, {}>;
+  readonly aggregate_state: ConvexTableWithColumns<{
+    name: "aggregate_state";
+    columns: {
+      kind: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_state";
+        };
+      } & {
+        _: {
+          fieldName: "kind";
+        };
+      };
+      cursor: ConvexTextBuilderInitial<""> & {
+        _: {
+          tableName: "aggregate_state";
+        };
+      } & {
+        _: {
+          fieldName: "cursor";
+        };
+      };
+      tableKey: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_state";
+        };
+      } & {
+        _: {
+          fieldName: "tableKey";
+        };
+      };
+      indexName: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_state";
+        };
+      } & {
+        _: {
+          fieldName: "indexName";
+        };
+      };
+      keyDefinitionHash: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_state";
+        };
+      } & {
+        _: {
+          fieldName: "keyDefinitionHash";
+        };
+      };
+      metricDefinitionHash: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_state";
+        };
+      } & {
+        _: {
+          fieldName: "metricDefinitionHash";
+        };
+      };
+      status: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_state";
+        };
+      } & {
+        _: {
+          fieldName: "status";
+        };
+      };
+      processed: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_state";
+        };
+      } & {
+        _: {
+          fieldName: "processed";
+        };
+      };
+      startedAt: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_state";
+        };
+      } & {
+        _: {
+          fieldName: "startedAt";
+        };
+      };
+      updatedAt: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_state";
+        };
+      } & {
+        _: {
+          fieldName: "updatedAt";
+        };
+      };
+      completedAt: ConvexNumberBuilderInitial<""> & {
+        _: {
+          tableName: "aggregate_state";
+        };
+      } & {
+        _: {
+          fieldName: "completedAt";
+        };
+      };
+      lastError: ConvexTextBuilderInitial<""> & {
+        _: {
+          tableName: "aggregate_state";
+        };
+      } & {
+        _: {
+          fieldName: "lastError";
+        };
+      };
+    };
+  }, {
+    by_creation_time: ["_creationTime"];
+    by_kind_table_index: ["kind", "tableKey", "indexName", "_creationTime"];
+    by_kind_status: ["kind", "status", "_creationTime"];
+  }, {}, {}, {}>;
+}>, SchemaExtension<{
+  readonly migration_state: ConvexTableWithColumns<{
+    name: "migration_state";
+    columns: {
+      cursor: ConvexTextBuilderInitial<""> & {
+        _: {
+          tableName: "migration_state";
+        };
+      } & {
+        _: {
+          fieldName: "cursor";
+        };
+      };
+      direction: ConvexTextBuilderInitial<""> & {
+        _: {
+          tableName: "migration_state";
+        };
+      } & {
+        _: {
+          fieldName: "direction";
+        };
+      };
+      status: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_state";
+        };
+      } & {
+        _: {
+          fieldName: "status";
+        };
+      };
+      processed: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_state";
+        };
+      } & {
+        _: {
+          fieldName: "processed";
+        };
+      };
+      startedAt: ConvexNumberBuilderInitial<""> & {
+        _: {
+          tableName: "migration_state";
+        };
+      } & {
+        _: {
+          fieldName: "startedAt";
+        };
+      };
+      updatedAt: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_state";
+        };
+      } & {
+        _: {
+          fieldName: "updatedAt";
+        };
+      };
+      completedAt: ConvexNumberBuilderInitial<""> & {
+        _: {
+          tableName: "migration_state";
+        };
+      } & {
+        _: {
+          fieldName: "completedAt";
+        };
+      };
+      lastError: ConvexTextBuilderInitial<""> & {
+        _: {
+          tableName: "migration_state";
+        };
+      } & {
+        _: {
+          fieldName: "lastError";
+        };
+      };
+      migrationId: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_state";
+        };
+      } & {
+        _: {
+          fieldName: "migrationId";
+        };
+      };
+      checksum: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_state";
+        };
+      } & {
+        _: {
+          fieldName: "checksum";
+        };
+      };
+      applied: ConvexBooleanBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_state";
+        };
+      } & {
+        _: {
+          fieldName: "applied";
+        };
+      };
+      runId: ConvexTextBuilderInitial<""> & {
+        _: {
+          tableName: "migration_state";
+        };
+      } & {
+        _: {
+          fieldName: "runId";
+        };
+      };
+      writeMode: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_state";
+        };
+      } & {
+        _: {
+          fieldName: "writeMode";
+        };
+      };
+    };
+  }, {
+    by_creation_time: ["_creationTime"];
+    by_migration_id: ["migrationId", "_creationTime"];
+    by_status: ["status", "_creationTime"];
+  }, {}, {}, {}>;
+  readonly migration_run: ConvexTableWithColumns<{
+    name: "migration_run";
+    columns: {
+      direction: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_run";
+        };
+      } & {
+        _: {
+          fieldName: "direction";
+        };
+      };
+      status: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_run";
+        };
+      } & {
+        _: {
+          fieldName: "status";
+        };
+      };
+      startedAt: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_run";
+        };
+      } & {
+        _: {
+          fieldName: "startedAt";
+        };
+      };
+      updatedAt: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_run";
+        };
+      } & {
+        _: {
+          fieldName: "updatedAt";
+        };
+      };
+      completedAt: ConvexNumberBuilderInitial<""> & {
+        _: {
+          tableName: "migration_run";
+        };
+      } & {
+        _: {
+          fieldName: "completedAt";
+        };
+      };
+      lastError: ConvexTextBuilderInitial<""> & {
+        _: {
+          tableName: "migration_run";
+        };
+      } & {
+        _: {
+          fieldName: "lastError";
+        };
+      };
+      runId: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_run";
+        };
+      } & {
+        _: {
+          fieldName: "runId";
+        };
+      };
+      dryRun: ConvexBooleanBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_run";
+        };
+      } & {
+        _: {
+          fieldName: "dryRun";
+        };
+      };
+      allowDrift: ConvexBooleanBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_run";
+        };
+      } & {
+        _: {
+          fieldName: "allowDrift";
+        };
+      };
+      migrationIds: ConvexCustomBuilderInitial<"", convex_values0.VArray<string[], convex_values0.VString<string, "required">, "required">> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_run";
+        };
+      } & {
+        _: {
+          fieldName: "migrationIds";
+        };
+      };
+      currentIndex: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_run";
+        };
+      } & {
+        _: {
+          fieldName: "currentIndex";
+        };
+      };
+      cancelRequested: ConvexBooleanBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_run";
+        };
+      } & {
+        _: {
+          fieldName: "cancelRequested";
+        };
+      };
+    };
+  }, {
+    by_creation_time: ["_creationTime"];
+    by_status: ["status", "_creationTime"];
+    by_run_id: ["runId", "_creationTime"];
+  }, {}, {}, {}>;
+}>];
+declare function defineSchema$1<TSchema extends GenericSchema, StrictTableNameTypes extends boolean = true>(schema: TSchema, options?: SchemaOptions<StrictTableNameTypes>): SchemaChain<TSchema, StrictTableNameTypes, readonly [], undefined, true, true, true>;
+declare function getSchemaRelations<TSchema extends object>(schema: TSchema): TSchema extends {
+  [OrmSchemaRelations]?: infer TRelations;
+} ? TRelations : undefined;
+declare function getSchemaRelations(schema: unknown): TablesRelationalConfig | undefined;
+declare function requireSchemaRelations<TSchema extends object>(schema: TSchema): Exclude<TSchema extends {
+  [OrmSchemaRelations]?: infer TRelations;
+} ? TRelations : never, undefined>;
+declare function requireSchemaRelations(schema: unknown): TablesRelationalConfig;
+declare function getSchemaTriggers<TSchema extends object>(schema: TSchema): TSchema extends {
+  [OrmSchemaTriggers]?: infer TTriggers;
+} ? TTriggers : undefined;
+declare function getSchemaTriggers(schema: unknown): OrmTriggers<TablesRelationalConfig> | undefined;
+//#endregion
+//#region src/orm/where-clause-compiler.d.ts
+/**
+ * Result of compiling a where clause
+ * Contains index selection and filter expressions
+ */
+interface WhereClauseResult {
+  /** Filters that can use the index (eq/range on indexed fields) */
+  indexFilters: FilterExpression$1<boolean>[];
+  /** Filters applied after index scan (gt, lt, and, or, not) */
+  postFilters: FilterExpression$1<boolean>[];
+  /** Multi-probe filter groups for OR/inArray index union plans */
+  probeFilters: FilterExpression$1<boolean>[][];
+  /** Selected index for query optimization (null if no suitable index) */
+  selectedIndex: IndexLike | null;
+  /** Planning strategy used for index compilation */
+  strategy: IndexStrategy;
+}
+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 {
+  indexFields: string[];
+  indexName: string;
+}
+//#endregion
+export { GenericOrmCtx as $, unique as $n, endsWith as $r, ManyConfig as $t, ConvexDateMode as A, ConvexRankIndexBuilder as An, ReturningResult as Ar, MigrationManifestEntry as At, ConvexBytesBuilderInitial as B, rankIndex as Bn, OrmSchemaRelations as Br, defineMigration as Bt, ConvexNumberBuilderInitial as C, ColumnBuilderWithTableName as Ci, RlsRole as Cn, MutationReturning as Cr, MigrationStatusArgs as Ct, id as D, IsPrimaryKey as Di, ConvexAggregateIndexBuilderOn as Dn, PaginatedResult as Dr, MigrationDoc as Dt, ConvexIdBuilderInitial as E, HasDefault as Ei, ConvexAggregateIndexBuilder as En, OrderDirection as Er, MigrationDirection as Et, custom as F, ConvexVectorIndexBuilder as Fn, unsetToken as Fr, MigrationStateMap as Ft, ConvexBigIntBuilder as G, ConvexCheckConfig as Gn, ExpressionVisitor as Gr, OrmReader as Gt, ConvexBooleanBuilder as H, uniqueIndex as Hn, TableName as Hr, detectMigrationDrift as Ht, json as I, ConvexVectorIndexBuilderOn as In, Brand as Ir, MigrationStep as It, CountBackfillChunkArgs as J, ConvexUniqueConstraintBuilder as Jn, LogicalExpression as Jr, RlsMode as Jt, ConvexBigIntBuilderInitial as K, ConvexForeignKeyBuilder as Kn, FieldReference as Kr, OrmWriter as Kt, objectOf as L, ConvexVectorIndexConfig as Ln, Columns as Lr, MigrationTableName as Lt, ConvexCustomBuilder as M, ConvexSearchIndexBuilder as Mn, UpdateSet as Mr, MigrationPlan as Mt, ConvexCustomBuilderInitial as N, ConvexSearchIndexBuilderOn as Nn, VectorQueryConfig as Nr, MigrationRunStatus as Nt, ConvexDateBuilder as O, IsUnique as Oi, ConvexIndexBuilder as On, PredicateWhereIndexConfig as Or, MigrationDocContext as Ot, arrayOf as P, ConvexSearchIndexConfig as Pn, VectorSearchProvider as Pr, MigrationSet as Pt, GenericOrm as Q, foreignKey as Qn, contains as Qr, ExtractTablesWithRelations as Qt, unionOf as R, aggregateIndex as Rn, OrmSchemaExtensionTables as Rr, MigrationWriteMode as Rt, ConvexNumberBuilder as S, ColumnBuilderTypeConfig as Si, rlsPolicy as Sn, MutationResult as Sr, MigrationRunChunkArgs as St, ConvexIdBuilder as T, DrizzleEntity as Ti, rlsRole as Tn, OrderByClause as Tr, MigrationDefinition as Tt, ConvexBooleanBuilderInitial as U, vectorIndex as Un, SystemFields as Ur, DatabaseWithMutations as Ut, bytes as V, searchIndex as Vn, OrmSchemaTriggers as Vr, defineMigrationSet as Vt, boolean as W, ConvexCheckBuilder as Wn, BinaryExpression as Wr, DatabaseWithQuery as Wt, CountBackfillStatusArgs as X, ConvexUniqueConstraintConfig as Xn, and as Xr, extractRelationsConfig as Xt, CountBackfillKickoffArgs as Y, ConvexUniqueConstraintBuilderOn as Yn, UnaryExpression as Yr, EdgeMetadata as Yt, CreateOrmOptions as Z, check as Zn, between as Zr, ExtractTablesFromSchema as Zt, ConvexTimestampMode as _, startsWith as _i, deletion as _n, MutationExecuteConfig as _r, OrmTriggerContext as _t, requireSchemaRelations as a, inArray as ai, TablesRelationalConfig as an, AggregateResult as ar, OrmWriterCtx as at, ConvexTextEnumBuilderInitial as b, ColumnBuilderBaseConfig as bi, RlsPolicyConfig as bn, MutationPaginateConfig as br, MigrationCancelArgs as bt, TableConfigResult as c, isNull as ci, ConvexDeletionBuilder as cn, CountConfig as cr, ScheduledMutationBatchArgs as ct, OrmNotFoundError as d, lte as di, ConvexTableWithColumns as dn, FilterOperators as dr, scheduledDeleteFactory as dt, eq as ei, OneConfig as en, ConvexTextBuilder as er, OrmApiResult as et, ConvexVectorBuilder as f, ne as fi, DiscriminatorBuilderConfig as fn, GetColumnData as fr, SchemaExtension as ft, ConvexTimestampBuilderInitial as g, or as gi, convexTable as gn, InsertValue as gr, OrmTriggerChange as gt, ConvexTimestampBuilder as h, notInArray as hi, TableConfig as hn, InferSelectModel as hr, OrmTableTriggers as ht, getSchemaTriggers as i, ilike as ii, TableRelationalConfig as in, AggregateFieldValue as ir, OrmReaderCtx as it, date as j, ConvexRankIndexBuilderOn as jn, ReturningSelection as jr, MigrationMigrateOne as jt, ConvexDateBuilderInitial as k, NotNull as ki, ConvexIndexBuilderOn as kn, ReturningAll as kr, MigrationDriftIssue as kt, getTableColumns as l, like as li, ConvexDeletionConfig as ln, CountResult as lr, scheduledMutationBatchFactory as lt, vector as m, notBetween as mi, OrmLifecycleOperation as mn, InferModelFromColumns as mr, OrmBeforeResult as mt, defineSchema$1 as n, gt as ni, RelationsBuilderColumnBase as nn, text as nr, OrmClientWithApi as nt, asc as o, isFieldReference as oi, defineRelations as on, BuildQueryResult as or, ResolveOrmSchema as ot, ConvexVectorBuilderInitial as p, not as pi, OrmLifecycleChange as pn, InferInsertModel as pr, defineSchemaExtension as pt, bigint as q, ConvexForeignKeyConfig as qn, FilterExpression$1 as qr, RlsContext as qt, getSchemaRelations as r, gte as ri, RelationsBuilderColumnConfig as rn, AggregateConfig as rr, OrmFunctions as rt, desc as s, isNotNull as si, defineRelationsPart as sn, BuildRelationResult as sr, createOrm as st, WhereClauseResult as t, fieldRef as ti, RelationsBuilder as tn, ConvexTextBuilderInitial as tr, OrmClientBase as tt, getTableConfig as u, lt as ui, ConvexTable as un, DBQueryConfig as ur, ScheduledDeleteArgs as ut, timestamp as v, AnyColumn as vi, discriminator as vn, MutationExecuteResult as vr, OrmTriggers as vt, integer as w, ColumnDataType as wi, RlsRoleConfig as wn, MutationRunMode as wr, MigrationAppliedState as wt, textEnum as x, ColumnBuilderRuntimeConfig as xi, RlsPolicyToOption as xn, MutationPaginatedResult as xr, MigrationRunArgs as xt, ConvexTextEnumBuilder as y, ColumnBuilder as yi, RlsPolicy as yn, MutationExecutionMode as yr, defineTriggers as yt, ConvexBytesBuilder as z, index as zn, OrmSchemaExtensions as zr, buildMigrationPlan as zt };