kitcn 0.23.0 → 0.25.0

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

@@ -0,0 +1,2042 @@
+import { Bn as ConvexTextBuilderInitial, Dr as SystemFieldAliases, F as DeleteMode, Gn as OrmRuntimeDefaults, H as EdgeMetadata, Hn as ConvexColumnBuilder, Hr as entityKind, Ht as RelationsConfigWithSchema, I as SerializedFilterExpression, Jn as OrmSchemaExtensionTriggers, Kn as OrmSchemaExtensionRelations, L as getChecks, M as OrmReader, Mr as ColumnBuilderBaseConfig, N as OrmWriter, Nt as AnyRelationsBuilderConfig, Or as SystemFields, P as CascadeMode, Pt as ExtractTablesFromSchema, Qt as OrmLifecycleChange, R as getForeignKeys, Rr as HasDefault, Rt as RelationsBuilder, St as OrderByClause, Ut as TableRelationalConfig, Vr as NotNull, Vt as RelationsBuilderConfigValue, Wn as Columns, Wt as TablesRelationalConfig, Xn as OrmSchemaRelations, Xt as ConvexTableWithColumns, Yt as ConvexTable, Zn as OrmSchemaTriggers, b as MigrationSet, ft as InferSelectModel, in as RlsPolicy, jr as ColumnBuilder, jt as VectorSearchProvider, k as CreateDatabaseOptions, kr as $Type, nr as FilterExpression$1, r as OrmCapability, ut as InferInsertModel, z as getUniqueIndexes } from "./capabilities-Bem7xvGK.js";
+import * as convex_values0 from "convex/values";
+import { GenericId, Validator, Value } from "convex/values";
+import { DefineSchemaOptions, GenericDatabaseReader, GenericDatabaseWriter, GenericSchema, SchedulableFunctionReference, Scheduler, SchemaDefinition, internalActionGeneric, internalMutationGeneric } from "convex/server";
+
+//#region src/orm/migrations/capability.d.ts
+/**
+ * Registers the migration runtime with `createOrm()`.
+ *
+ * Required by the migration handlers exposed through `orm.api()`. Importing
+ * this pulls the migration runtime into the calling Convex module, so only
+ * register it where it is actually used.
+ */
+declare const migrationCapability: () => OrmCapability;
+//#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/migrations/schema.d.ts
+declare const MIGRATION_STATE_TABLE = "migration_state";
+declare const MIGRATION_RUN_TABLE = "migration_run";
+declare const migrationStorageTables: {
+  readonly migration_state: ConvexTableWithColumns<{
+    name: "migration_state";
+    columns: {
+      status: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_state";
+        };
+      } & {
+        _: {
+          fieldName: "status";
+        };
+      };
+      cursor: ConvexTextBuilderInitial<""> & {
+        _: {
+          tableName: "migration_state";
+        };
+      } & {
+        _: {
+          fieldName: "cursor";
+        };
+      };
+      direction: ConvexTextBuilderInitial<""> & {
+        _: {
+          tableName: "migration_state";
+        };
+      } & {
+        _: {
+          fieldName: "direction";
+        };
+      };
+      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";
+        };
+      };
+      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";
+        };
+      };
+      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: {
+      status: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_run";
+        };
+      } & {
+        _: {
+          fieldName: "status";
+        };
+      };
+      direction: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_run";
+        };
+      } & {
+        _: {
+          fieldName: "direction";
+        };
+      };
+      runId: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_run";
+        };
+      } & {
+        _: {
+          fieldName: "runId";
+        };
+      };
+      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";
+        };
+      };
+      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 const MIGRATION_STORAGE_TABLE_NAMES: Set<string>;
+declare function migrationExtension(): SchemaExtension<typeof migrationStorageTables>;
+declare function injectMigrationStorageTables<TSchema extends Record<string, unknown>>(schema: TSchema): TSchema & typeof migrationStorageTables;
+//#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;
+  /**
+   * Optional subsystems this ORM may use.
+   *
+   * `count()`, `aggregate()`, `groupBy()`, `rank()`, relation `_count`,
+   * `aggregateIndex(...)` / `rankIndex(...)` write maintenance and the
+   * `orm.api()` backfill handlers need `aggregateCapability()` from
+   * `kitcn/orm/aggregate-index`. The `orm.api()` migration handlers need
+   * `migrationCapability()` from `kitcn/orm/migrations`. Anything not
+   * registered here stays out of the Convex bundle for this module.
+   */
+  capabilities?: readonly OrmCapability[];
+  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/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: {
+      updatedAt: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_bucket";
+        };
+      } & {
+        _: {
+          fieldName: "updatedAt";
+        };
+      };
+      tableKey: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_bucket";
+        };
+      } & {
+        _: {
+          fieldName: "tableKey";
+        };
+      };
+      indexName: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_bucket";
+        };
+      } & {
+        _: {
+          fieldName: "indexName";
+        };
+      };
+      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";
+        };
+      };
+      count: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_bucket";
+        };
+      } & {
+        _: {
+          fieldName: "count";
+        };
+      };
+      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";
+        };
+      };
+      updatedAt: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_member";
+        };
+      } & {
+        _: {
+          fieldName: "updatedAt";
+        };
+      };
+      tableKey: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_member";
+        };
+      } & {
+        _: {
+          fieldName: "tableKey";
+        };
+      };
+      indexName: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_member";
+        };
+      } & {
+        _: {
+          fieldName: "indexName";
+        };
+      };
+      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";
+        };
+      };
+      updatedAt: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_extrema";
+        };
+      } & {
+        _: {
+          fieldName: "updatedAt";
+        };
+      };
+      tableKey: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_extrema";
+        };
+      } & {
+        _: {
+          fieldName: "tableKey";
+        };
+      };
+      indexName: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_extrema";
+        };
+      } & {
+        _: {
+          fieldName: "indexName";
+        };
+      };
+      keyHash: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_extrema";
+        };
+      } & {
+        _: {
+          fieldName: "keyHash";
+        };
+      };
+      count: ConvexNumberBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_extrema";
+        };
+      } & {
+        _: {
+          fieldName: "count";
+        };
+      };
+      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: {
+      status: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_state";
+        };
+      } & {
+        _: {
+          fieldName: "status";
+        };
+      };
+      kind: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "aggregate_state";
+        };
+      } & {
+        _: {
+          fieldName: "kind";
+        };
+      };
+      cursor: ConvexTextBuilderInitial<""> & {
+        _: {
+          tableName: "aggregate_state";
+        };
+      } & {
+        _: {
+          fieldName: "cursor";
+        };
+      };
+      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";
+        };
+      };
+      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";
+        };
+      };
+    };
+  }, {
+    by_creation_time: ["_creationTime"];
+    by_kind_table_index: ["kind", "tableKey", "indexName", "_creationTime"];
+    by_kind_status: ["kind", "status", "_creationTime"];
+    by_table_status: ["tableKey", "status", "_creationTime"];
+  }, {}, {}, {}>;
+}>, SchemaExtension<{
+  readonly migration_state: ConvexTableWithColumns<{
+    name: "migration_state";
+    columns: {
+      status: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_state";
+        };
+      } & {
+        _: {
+          fieldName: "status";
+        };
+      };
+      cursor: ConvexTextBuilderInitial<""> & {
+        _: {
+          tableName: "migration_state";
+        };
+      } & {
+        _: {
+          fieldName: "cursor";
+        };
+      };
+      direction: ConvexTextBuilderInitial<""> & {
+        _: {
+          tableName: "migration_state";
+        };
+      } & {
+        _: {
+          fieldName: "direction";
+        };
+      };
+      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";
+        };
+      };
+      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";
+        };
+      };
+      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: {
+      status: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_run";
+        };
+      } & {
+        _: {
+          fieldName: "status";
+        };
+      };
+      direction: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_run";
+        };
+      } & {
+        _: {
+          fieldName: "direction";
+        };
+      };
+      runId: ConvexTextBuilderInitial<""> & {
+        _: {
+          notNull: true;
+        };
+      } & {
+        _: {
+          tableName: "migration_run";
+        };
+      } & {
+        _: {
+          fieldName: "runId";
+        };
+      };
+      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";
+        };
+      };
+      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 { OrmClientWithApi as $, ConvexDateMode as A, ConvexBytesBuilderInitial as B, ConvexNumberBuilderInitial as C, migrationCapability as Ct, id as D, ConvexIdBuilderInitial as E, custom as F, ConvexBigIntBuilder as G, ConvexBooleanBuilder as H, json as I, CreateOrmOptions as J, ConvexBigIntBuilderInitial as K, objectOf as L, ConvexCustomBuilder as M, ConvexCustomBuilderInitial as N, ConvexDateBuilder as O, arrayOf as P, OrmClientBase as Q, unionOf as R, ConvexNumberBuilder as S, defineTriggers as St, ConvexIdBuilder as T, ConvexBooleanBuilderInitial as U, bytes as V, boolean as W, GenericOrmCtx as X, GenericOrm as Y, OrmApiResult as Z, ConvexTimestampMode as _, OrmBeforeResult as _t, requireSchemaRelations as a, ScheduledMutationBatchArgs as at, ConvexTextEnumBuilderInitial as b, OrmTriggerContext as bt, TableConfigResult as c, scheduledDeleteFactory as ct, OrmNotFoundError as d, MIGRATION_STORAGE_TABLE_NAMES as dt, OrmFunctions as et, ConvexVectorBuilder as f, injectMigrationStorageTables as ft, ConvexTimestampBuilderInitial as g, defineSchemaExtension as gt, ConvexTimestampBuilder as h, SchemaExtension as ht, getSchemaTriggers as i, createOrm as it, date as j, ConvexDateBuilderInitial as k, getTableColumns as l, MIGRATION_RUN_TABLE as lt, vector as m, migrationStorageTables as mt, defineSchema$1 as n, OrmWriterCtx as nt, asc as o, scheduledMutationBatchFactory as ot, ConvexVectorBuilderInitial as p, migrationExtension as pt, bigint as q, getSchemaRelations as r, ResolveOrmSchema as rt, desc as s, ScheduledDeleteArgs as st, WhereClauseResult as t, OrmReaderCtx as tt, getTableConfig as u, MIGRATION_STATE_TABLE as ut, timestamp as v, OrmTableTriggers as vt, integer as w, textEnum as x, OrmTriggers as xt, ConvexTextEnumBuilder as y, OrmTriggerChange as yt, ConvexBytesBuilder as z };