import "../validators-BcQFm1oY.js";
import { a as QueryCtxWithPreferredOrmQueryTable, n as LookupByIdResultByCtx, t as DocByCtx } from "../query-context-ji7By8u0.js";
import { t as GetAuth } from "../types-CM67ko7K.js";
import { F as GenericCtx } from "../procedure-caller-Cg6bxkDQ.js";
import "../http-types-BK7FuIcR.js";
import "../server/index.js";
import * as convex_values0 from "convex/values";
import { Infer } from "convex/values";
import * as convex_server0 from "convex/server";
import { DocumentByName, FunctionReference, GenericDataModel, GenericMutationCtx, GenericQueryCtx, GenericSchema, PaginationOptions, PaginationResult, SchemaDefinition, TableNamesInDataModel, internalMutationGeneric } from "convex/server";
import { convex } from "@convex-dev/better-auth/plugins";
import * as better_auth_adapters0 from "better-auth/adapters";
import { DBAdapterDebugLogOption } from "better-auth/adapters";
import { BetterAuthDBSchema } from "better-auth/db";
import { BetterAuthOptions } from "better-auth/minimal";
import * as better_auth0 from "better-auth";
import { Auth, Where } from "better-auth/types";
import { SetOptional } from "type-fest";

//#region src/auth/define-auth.d.ts
type MaybePromise$1<T> = T | Promise<T>;
type TableDoc<DataModel extends GenericDataModel, TableName extends string> = TableName extends TableNamesInDataModel<DataModel> ? DocumentByName<DataModel, TableName> extends Record<string, unknown> ? DocumentByName<DataModel, TableName> : Record<string, unknown> : Record<string, unknown>;
type InsertDocData<TDoc extends Record<string, unknown>> = Omit<TDoc, '_id' | '_creationTime'>;
type UpdateDocData<TDoc extends Record<string, unknown>> = Partial<Omit<TDoc, '_id' | '_creationTime'>>;
type TriggerChangeId<TDoc> = TDoc extends {
  _id: infer TId;
} ? TId : TDoc extends {
  id: infer TId;
} ? TId : unknown;
type GenericAuthTriggerChange<TDoc extends Record<string, unknown> = Record<string, unknown>, TId = TriggerChangeId<TDoc>> = {
  id: TId;
  newDoc: TDoc;
  oldDoc: null;
  operation: 'insert';
} | {
  id: TId;
  newDoc: TDoc;
  oldDoc: TDoc;
  operation: 'update';
} | {
  id: TId;
  newDoc: null;
  oldDoc: TDoc;
  operation: 'delete';
};
type GenericAuthBeforeResult<TData extends Record<string, unknown>> = void | false | {
  data: Partial<TData>;
};
type GenericAuthTriggerHandlers<DataModel extends GenericDataModel, TableName extends string, TriggerCtx, Doc extends Record<string, unknown> = TableDoc<DataModel, TableName>, InsertDoc extends Record<string, unknown> = InsertDocData<Doc>, UpdateDoc extends Record<string, unknown> = UpdateDocData<Doc>> = {
  change?: (change: GenericAuthTriggerChange<Doc>, ctx: TriggerCtx) => MaybePromise$1<void>;
  create?: {
    after?: (doc: Doc, ctx: TriggerCtx) => MaybePromise$1<void>;
    before?: (data: InsertDoc, ctx: TriggerCtx) => MaybePromise$1<GenericAuthBeforeResult<InsertDoc>>;
  };
  delete?: {
    after?: (doc: Doc, ctx: TriggerCtx) => MaybePromise$1<void>;
    before?: (doc: Doc, ctx: TriggerCtx) => MaybePromise$1<GenericAuthBeforeResult<Doc>>;
  };
  update?: {
    after?: (newDoc: Doc, ctx: TriggerCtx) => MaybePromise$1<void>;
    before?: (update: UpdateDoc, ctx: TriggerCtx) => MaybePromise$1<GenericAuthBeforeResult<UpdateDoc>>;
  };
};
type GenericAuthTriggers<DataModel extends GenericDataModel, Schema extends SchemaDefinition<any, any>, TriggerCtx = unknown> = { [K in keyof Schema['tables'] & string]?: GenericAuthTriggerHandlers<DataModel, K, TriggerCtx> };
type BetterAuthOptionsWithoutDatabase = Omit<BetterAuthOptions, 'database'>;
type GenericAuthDefinition<GenericCtx = unknown, DataModel extends GenericDataModel = GenericDataModel, Schema extends SchemaDefinition<GenericSchema, true> = SchemaDefinition<GenericSchema, true>, AuthOptions extends BetterAuthOptionsWithoutDatabase = BetterAuthOptionsWithoutDatabase> = (ctx: GenericCtx) => AuthOptions & {
  triggers?: GenericAuthTriggers<DataModel, Schema, GenericCtx>;
};
declare const defineAuth: <GenericCtx = unknown, DataModel extends GenericDataModel = GenericDataModel, Schema extends SchemaDefinition<GenericSchema, true> = SchemaDefinition<GenericSchema, true>, AuthOptions extends BetterAuthOptionsWithoutDatabase = BetterAuthOptionsWithoutDatabase>(definition: GenericAuthDefinition<GenericCtx, DataModel, Schema, AuthOptions>) => GenericAuthDefinition<GenericCtx, DataModel, Schema, AuthOptions>;
//#endregion
//#region src/auth/create-client.d.ts
type AuthFunctions = {
  create: FunctionReference<'mutation', 'internal', Record<string, any>>;
  deleteMany: FunctionReference<'mutation', 'internal', Record<string, any>>;
  deleteOne: FunctionReference<'mutation', 'internal', Record<string, any>>;
  findMany: FunctionReference<'query', 'internal', Record<string, any>>;
  findOne: FunctionReference<'query', 'internal', Record<string, any>>;
  updateMany: FunctionReference<'mutation', 'internal', Record<string, any>>;
  updateOne: FunctionReference<'mutation', 'internal', Record<string, any>>;
};
type Triggers<DataModel extends GenericDataModel, Schema extends SchemaDefinition<any, any>, TriggerCtx = unknown> = GenericAuthTriggers<DataModel, Schema, TriggerCtx>;
type TriggerResolver<DataModel extends GenericDataModel, Schema extends SchemaDefinition<any, any>, TriggerCtx extends GenericMutationCtx<DataModel> = GenericMutationCtx<DataModel>> = Triggers<DataModel, Schema, TriggerCtx> | ((ctx: TriggerCtx) => Triggers<DataModel, Schema, TriggerCtx> | undefined);
declare const createClient: <DataModel extends GenericDataModel, Schema extends SchemaDefinition<GenericSchema, true>, TriggerCtx extends GenericMutationCtx<DataModel> = GenericMutationCtx<DataModel>>(config: {
  authFunctions: AuthFunctions;
  schema: Schema;
  context?: (ctx: GenericMutationCtx<DataModel>) => TriggerCtx | Promise<TriggerCtx>;
  triggers?: TriggerResolver<DataModel, Schema, TriggerCtx>;
}) => {
  authFunctions: AuthFunctions;
  triggers: TriggerResolver<DataModel, Schema, TriggerCtx> | undefined;
  adapter: (ctx: GenericCtx<DataModel>, getAuthOptions: (ctx: any) => BetterAuthOptions) => better_auth_adapters0.AdapterFactory<BetterAuthOptions>;
};
//#endregion
//#region src/auth/adapter.d.ts
declare const handlePagination: (next: ({
  paginationOpts
}: {
  paginationOpts: PaginationOptions;
}) => Promise<SetOptional<PaginationResult<any>, "page"> & {
  count?: number;
}>, {
  limit,
  numItems
}?: {
  limit?: number;
  numItems?: number;
}) => Promise<{
  count: number;
  cursor: string | null;
  docs: any[];
  isDone: boolean;
}>;
type ConvexCleanedWhere = Where & {
  value: number[] | string[] | boolean | number | string | null;
};
declare const adapterConfig: {
  adapterId: string;
  adapterName: string;
  debugLogs: false;
  disableIdGeneration: true;
  mapKeysTransformInput: {
    id: string;
  };
  mapKeysTransformOutput: {
    _id: string;
  };
  supportsJSON: false;
  supportsNumericIds: false;
  supportsDates: false;
  supportsArrays: true;
  transaction: false;
  usePlural: false;
  customTransformInput: ({
    data,
    fieldAttributes
  }: {
    data: any;
    fieldAttributes: better_auth0.DBFieldAttribute;
    field: string;
    action: "create" | "update" | "findOne" | "findMany" | "updateMany" | "delete" | "deleteMany" | "count";
    model: string;
    schema: BetterAuthDBSchema;
    options: BetterAuthOptions;
  }) => any;
  customTransformOutput: ({
    data,
    fieldAttributes
  }: {
    data: any;
    fieldAttributes: better_auth0.DBFieldAttribute;
    field: string;
    select: string[];
    model: string;
    schema: BetterAuthDBSchema;
    options: BetterAuthOptions;
  }) => any;
};
declare const httpAdapter: <DataModel extends GenericDataModel, Schema extends SchemaDefinition<any, any>>(ctx: GenericCtx<DataModel>, {
  authFunctions,
  debugLogs,
  schema
}: {
  authFunctions: AuthFunctions;
  debugLogs?: DBAdapterDebugLogOption;
  schema?: Schema;
}) => better_auth_adapters0.AdapterFactory<BetterAuthOptions>;
declare const dbAdapter: <DataModel extends GenericDataModel, Schema extends SchemaDefinition<any, any>>(ctx: GenericCtx<DataModel>, getAuthOptions: (ctx: any) => BetterAuthOptions, {
  authFunctions,
  debugLogs,
  schema
}: {
  authFunctions: AuthFunctions;
  schema: Schema;
  debugLogs?: DBAdapterDebugLogOption;
}) => better_auth_adapters0.AdapterFactory<BetterAuthOptions>;
//#endregion
//#region src/auth/adapter-utils.d.ts
type AdapterPaginationOptions = PaginationOptions & {
  endCursor?: string | null;
  maximumRowsRead?: number;
};
declare const adapterWhereValidator: convex_values0.VObject<{
  operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
  connector?: "AND" | "OR" | undefined;
  value: string | number | boolean | string[] | number[] | null;
  field: string;
}, {
  connector: convex_values0.VUnion<"AND" | "OR" | undefined, [convex_values0.VLiteral<"AND", "required">, convex_values0.VLiteral<"OR", "required">], "optional", never>;
  field: convex_values0.VString<string, "required">;
  operator: convex_values0.VUnion<"eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined, [convex_values0.VLiteral<"lt", "required">, convex_values0.VLiteral<"lte", "required">, convex_values0.VLiteral<"gt", "required">, convex_values0.VLiteral<"gte", "required">, convex_values0.VLiteral<"eq", "required">, convex_values0.VLiteral<"in", "required">, convex_values0.VLiteral<"not_in", "required">, convex_values0.VLiteral<"ne", "required">, convex_values0.VLiteral<"contains", "required">, convex_values0.VLiteral<"starts_with", "required">, convex_values0.VLiteral<"ends_with", "required">], "optional", never>;
  value: convex_values0.VUnion<string | number | boolean | string[] | number[] | null, [convex_values0.VString<string, "required">, convex_values0.VFloat64<number, "required">, convex_values0.VBoolean<boolean, "required">, convex_values0.VArray<string[], convex_values0.VString<string, "required">, "required">, convex_values0.VArray<number[], convex_values0.VFloat64<number, "required">, "required">, convex_values0.VNull<null, "required">], "required", never>;
}, "required", "value" | "operator" | "field" | "connector">;
declare const adapterArgsValidator: convex_values0.VObject<{
  limit?: number | undefined;
  where?: {
    operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
    connector?: "AND" | "OR" | undefined;
    value: string | number | boolean | string[] | number[] | null;
    field: string;
  }[] | undefined;
  select?: string[] | undefined;
  offset?: number | undefined;
  sortBy?: {
    direction: "asc" | "desc";
    field: string;
  } | undefined;
  model: string;
}, {
  limit: convex_values0.VFloat64<number | undefined, "optional">;
  model: convex_values0.VString<string, "required">;
  offset: convex_values0.VFloat64<number | undefined, "optional">;
  select: convex_values0.VArray<string[] | undefined, convex_values0.VString<string, "required">, "optional">;
  sortBy: convex_values0.VObject<{
    direction: "asc" | "desc";
    field: string;
  } | undefined, {
    direction: convex_values0.VUnion<"asc" | "desc", [convex_values0.VLiteral<"asc", "required">, convex_values0.VLiteral<"desc", "required">], "required", never>;
    field: convex_values0.VString<string, "required">;
  }, "optional", "direction" | "field">;
  where: convex_values0.VArray<{
    operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
    connector?: "AND" | "OR" | undefined;
    value: string | number | boolean | string[] | number[] | null;
    field: string;
  }[] | undefined, convex_values0.VObject<{
    operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
    connector?: "AND" | "OR" | undefined;
    value: string | number | boolean | string[] | number[] | null;
    field: string;
  }, {
    connector: convex_values0.VUnion<"AND" | "OR" | undefined, [convex_values0.VLiteral<"AND", "required">, convex_values0.VLiteral<"OR", "required">], "optional", never>;
    field: convex_values0.VString<string, "required">;
    operator: convex_values0.VUnion<"eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined, [convex_values0.VLiteral<"lt", "required">, convex_values0.VLiteral<"lte", "required">, convex_values0.VLiteral<"gt", "required">, convex_values0.VLiteral<"gte", "required">, convex_values0.VLiteral<"eq", "required">, convex_values0.VLiteral<"in", "required">, convex_values0.VLiteral<"not_in", "required">, convex_values0.VLiteral<"ne", "required">, convex_values0.VLiteral<"contains", "required">, convex_values0.VLiteral<"starts_with", "required">, convex_values0.VLiteral<"ends_with", "required">], "optional", never>;
    value: convex_values0.VUnion<string | number | boolean | string[] | number[] | null, [convex_values0.VString<string, "required">, convex_values0.VFloat64<number, "required">, convex_values0.VBoolean<boolean, "required">, convex_values0.VArray<string[], convex_values0.VString<string, "required">, "required">, convex_values0.VArray<number[], convex_values0.VFloat64<number, "required">, "required">, convex_values0.VNull<null, "required">], "required", never>;
  }, "required", "value" | "operator" | "field" | "connector">, "optional">;
}, "required", "limit" | "where" | "model" | "select" | "offset" | "sortBy" | "sortBy.direction" | "sortBy.field">;
declare const hasUniqueFields: (betterAuthSchema: BetterAuthDBSchema, model: string, input: Record<string, any>) => boolean;
declare const checkUniqueFields: <Schema extends SchemaDefinition<any, any>>(ctx: GenericQueryCtx<GenericDataModel>, schema: Schema, betterAuthSchema: BetterAuthDBSchema, table: string, input: Record<string, any>, doc?: Record<string, any>) => Promise<void>;
declare const selectFields: <T extends TableNamesInDataModel<GenericDataModel>, D extends DocumentByName<GenericDataModel, T>>(doc: D | null, select?: string[]) => D | null;
declare const paginate: <Doc extends DocumentByName<GenericDataModel, T>, T extends TableNamesInDataModel<GenericDataModel>>(ctx: GenericQueryCtx<GenericDataModel>, schema: SchemaDefinition<any, any>, betterAuthSchema: BetterAuthDBSchema, args: Infer<typeof adapterArgsValidator> & {
  paginationOpts: AdapterPaginationOptions;
}) => Promise<PaginationResult<Doc>>;
declare const listOne: <Doc extends DocumentByName<GenericDataModel, T>, T extends TableNamesInDataModel<GenericDataModel>>(ctx: GenericQueryCtx<GenericDataModel>, schema: SchemaDefinition<any, any>, betterAuthSchema: BetterAuthDBSchema, args: Infer<typeof adapterArgsValidator>) => Promise<Doc | null>;
//#endregion
//#region src/auth/create-api.d.ts
type Schema = SchemaDefinition<any, any>;
type MaybePromise<T> = T | Promise<T>;
type RuntimeBeforeResult = GenericAuthBeforeResult<Record<string, unknown>>;
type RuntimeTriggerChange = GenericAuthTriggerChange<Record<string, unknown>>;
type RuntimeTableTriggers = {
  change?: (change: RuntimeTriggerChange, ctx: unknown) => MaybePromise<void>;
  create?: {
    after?: (doc: Record<string, unknown>, ctx: unknown) => MaybePromise<void>;
    before?: (data: Record<string, unknown>, ctx: unknown) => MaybePromise<RuntimeBeforeResult>;
  };
  delete?: {
    after?: (doc: Record<string, unknown>, ctx: unknown) => MaybePromise<void>;
    before?: (doc: Record<string, unknown>, ctx: unknown) => MaybePromise<RuntimeBeforeResult>;
  };
  update?: {
    after?: (doc: Record<string, unknown>, ctx: unknown) => MaybePromise<void>;
    before?: (update: Record<string, unknown>, ctx: unknown) => MaybePromise<RuntimeBeforeResult>;
  };
};
declare const createHandler: (ctx: any, args: {
  input: {
    data: any;
    model: string;
  };
  select?: string[];
  tableTriggers?: RuntimeTableTriggers;
  triggerCtx?: unknown;
}, schema: Schema, betterAuthSchema: any) => Promise<any>;
declare const findOneHandler: (ctx: any, args: {
  model: string;
  select?: string[];
  where?: any[];
}, schema: Schema, betterAuthSchema: any) => Promise<convex_server0.GenericDocument | null>;
declare const findManyHandler: (ctx: any, args: {
  model: string;
  paginationOpts: any;
  limit?: number;
  offset?: number;
  sortBy?: {
    direction: "asc" | "desc";
    field: string;
  };
  where?: any[];
}, schema: Schema, betterAuthSchema: any) => Promise<convex_server0.PaginationResult<convex_server0.GenericDocument>>;
declare const updateOneHandler: (ctx: any, args: {
  input: {
    model: string;
    update: any;
    where?: any[];
  };
  tableTriggers?: RuntimeTableTriggers;
  triggerCtx?: unknown;
}, schema: Schema, betterAuthSchema: any) => Promise<any>;
declare const updateManyHandler: (ctx: any, args: {
  input: {
    model: string;
    update?: any;
    where?: any[];
  };
  paginationOpts: any;
  tableTriggers?: RuntimeTableTriggers;
  triggerCtx?: unknown;
}, schema: Schema, betterAuthSchema: any) => Promise<{
  count: number;
  ids: any[];
  isDone: boolean;
  continueCursor: convex_server0.Cursor;
  splitCursor?: convex_server0.Cursor | null;
  pageStatus?: "SplitRecommended" | "SplitRequired" | null;
}>;
declare const deleteOneHandler: (ctx: any, args: {
  input: {
    model: string;
    where?: any[];
  };
  tableTriggers?: RuntimeTableTriggers;
  triggerCtx?: unknown;
}, schema: Schema, betterAuthSchema: any) => Promise<Record<string, unknown> | undefined>;
declare const deleteManyHandler: (ctx: any, args: {
  input: {
    model: string;
    where?: any[];
  };
  paginationOpts: any;
  tableTriggers?: RuntimeTableTriggers;
  triggerCtx?: unknown;
}, schema: Schema, betterAuthSchema: any) => Promise<{
  count: number;
  ids: any[];
  isDone: boolean;
  continueCursor: convex_server0.Cursor;
  splitCursor?: convex_server0.Cursor | null;
  pageStatus?: "SplitRecommended" | "SplitRequired" | null;
}>;
declare const createApi: <Schema extends SchemaDefinition<any, any>, DataModel extends GenericDataModel = GenericDataModel, Ctx = unknown, TriggerCtx = Ctx, Auth = unknown>(schema: Schema, getAuth: GetAuth<Ctx, Auth>, options?: {
  internalMutation?: typeof internalMutationGeneric;
  context?: (ctx: any) => TriggerCtx | Promise<TriggerCtx>;
  triggers?: GenericAuthTriggers<DataModel, Schema, TriggerCtx> | ((ctx: TriggerCtx) => GenericAuthTriggers<DataModel, Schema, TriggerCtx> | undefined); /** Validate input validators against auth table schemas. Defaults to false for smaller generated types. */
  validateInput?: boolean;
}) => {
  create: convex_server0.RegisteredMutation<"internal", {
    select?: string[] | undefined;
    input: {
      data: {
        [x: string]: unknown;
        [x: number]: unknown;
        [x: symbol]: unknown;
      };
      model: string;
    } | {
      data: any;
      model: string;
    };
  }, Promise<any>>;
  deleteMany: convex_server0.RegisteredMutation<"internal", {
    paginationOpts: {
      id?: number;
      endCursor?: string | null;
      maximumRowsRead?: number;
      maximumBytesRead?: number;
      numItems: number;
      cursor: string | null;
    };
    input: {
      where?: {
        operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
        connector?: "AND" | "OR" | undefined;
        value: string | number | boolean | string[] | number[] | null;
        field: string;
      }[] | undefined;
      model: string;
    } | {
      where?: any[] | undefined;
      model: string;
    };
  }, Promise<{
    count: number;
    ids: any[];
    isDone: boolean;
    continueCursor: convex_server0.Cursor;
    splitCursor?: convex_server0.Cursor | null;
    pageStatus?: "SplitRecommended" | "SplitRequired" | null;
  }>>;
  deleteOne: convex_server0.RegisteredMutation<"internal", {
    input: {
      where?: {
        operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
        connector?: "AND" | "OR" | undefined;
        value: string | number | boolean | string[] | number[] | null;
        field: string;
      }[] | undefined;
      model: string;
    } | {
      where?: any[] | undefined;
      model: string;
    };
  }, Promise<Record<string, unknown> | undefined>>;
  findMany: convex_server0.RegisteredQuery<"internal", {
    join?: any;
    limit?: number | undefined;
    where?: {
      operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
      connector?: "AND" | "OR" | undefined;
      value: string | number | boolean | string[] | number[] | null;
      field: string;
    }[] | undefined;
    offset?: number | undefined;
    sortBy?: {
      direction: "asc" | "desc";
      field: string;
    } | undefined;
    paginationOpts: {
      id?: number;
      endCursor?: string | null;
      maximumRowsRead?: number;
      maximumBytesRead?: number;
      numItems: number;
      cursor: string | null;
    };
    model: string;
  }, Promise<convex_server0.PaginationResult<convex_server0.GenericDocument>>>;
  findOne: convex_server0.RegisteredQuery<"internal", {
    join?: any;
    where?: {
      operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
      connector?: "AND" | "OR" | undefined;
      value: string | number | boolean | string[] | number[] | null;
      field: string;
    }[] | undefined;
    select?: string[] | undefined;
    model: string;
  }, Promise<convex_server0.GenericDocument | null>>;
  getLatestJwks: convex_server0.RegisteredAction<"internal", {}, Promise<unknown>>;
  rotateKeys: convex_server0.RegisteredAction<"internal", {}, Promise<unknown>>;
  updateMany: convex_server0.RegisteredMutation<"internal", {
    paginationOpts: {
      id?: number;
      endCursor?: string | null;
      maximumRowsRead?: number;
      maximumBytesRead?: number;
      numItems: number;
      cursor: string | null;
    };
    input: {
      where?: {
        operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
        connector?: "AND" | "OR" | undefined;
        value: string | number | boolean | string[] | number[] | null;
        field: string;
      }[] | undefined;
      update: {
        [x: string]: unknown;
        [x: number]: unknown;
        [x: symbol]: unknown;
      };
      model: string;
    } | {
      where?: any[] | undefined;
      update: any;
      model: string;
    };
  }, Promise<{
    count: number;
    ids: any[];
    isDone: boolean;
    continueCursor: convex_server0.Cursor;
    splitCursor?: convex_server0.Cursor | null;
    pageStatus?: "SplitRecommended" | "SplitRequired" | null;
  }>>;
  updateOne: convex_server0.RegisteredMutation<"internal", {
    input: {
      where?: {
        operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
        connector?: "AND" | "OR" | undefined;
        value: string | number | boolean | string[] | number[] | null;
        field: string;
      }[] | undefined;
      update: {
        [x: string]: unknown;
        [x: number]: unknown;
        [x: symbol]: unknown;
      };
      model: string;
    } | {
      where?: any[] | undefined;
      update: any;
      model: string;
    };
  }, Promise<any>>;
};
//#endregion
//#region src/auth/generated-contract.d.ts
type GeneratedAuthDisabledReasonKind = 'default_export_unavailable' | 'missing_auth_file' | 'missing_default_export';
declare const getGeneratedAuthDisabledReason: (kind: GeneratedAuthDisabledReasonKind) => string;
type UnknownFn = (...args: unknown[]) => unknown;
type AuthDefinitionModule<GenericCtx, DataModel extends GenericDataModel, Schema extends SchemaDefinition<GenericSchema, true>, AuthOptions extends BetterAuthOptionsWithoutDatabase> = {
  default: GenericAuthDefinition<GenericCtx, DataModel, Schema, AuthOptions>;
};
type AuthDefinitionInput<GenericCtx, DataModel extends GenericDataModel, Schema extends SchemaDefinition<GenericSchema, true>, AuthOptions extends BetterAuthOptionsWithoutDatabase> = GenericAuthDefinition<GenericCtx, DataModel, Schema, AuthOptions> | AuthDefinitionModule<GenericCtx, DataModel, Schema, AuthOptions>;
declare const resolveGeneratedAuthDefinition: <Definition extends UnknownFn>(input: unknown, reason: string) => Definition;
type BetterAuthRuntime<Options extends BetterAuthOptions = BetterAuthOptions> = Auth<Options>;
declare const createAuthRuntime: <DataModel extends GenericDataModel, Schema extends SchemaDefinition<GenericSchema, true>, TriggerCtx extends GenericMutationCtx<DataModel> = GenericMutationCtx<DataModel>, GenericCtx$1 = GenericMutationCtx<DataModel>, AuthOptions extends BetterAuthOptionsWithoutDatabase = BetterAuthOptionsWithoutDatabase>(config: {
  internal: unknown;
  moduleName: string;
  schema: Schema;
  auth: AuthDefinitionInput<GenericCtx$1, DataModel, Schema, AuthOptions>;
  context?: (ctx: GenericMutationCtx<DataModel>) => TriggerCtx | Promise<TriggerCtx>;
}) => {
  create: convex_server0.RegisteredMutation<"internal", {
    select?: string[] | undefined;
    input: {
      data: {
        [x: string]: unknown;
        [x: number]: unknown;
        [x: symbol]: unknown;
      };
      model: string;
    } | {
      data: any;
      model: string;
    };
  }, Promise<any>>;
  deleteMany: convex_server0.RegisteredMutation<"internal", {
    paginationOpts: {
      id?: number;
      endCursor?: string | null;
      maximumRowsRead?: number;
      maximumBytesRead?: number;
      numItems: number;
      cursor: string | null;
    };
    input: {
      where?: {
        operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
        connector?: "AND" | "OR" | undefined;
        value: string | number | boolean | string[] | number[] | null;
        field: string;
      }[] | undefined;
      model: string;
    } | {
      where?: any[] | undefined;
      model: string;
    };
  }, Promise<{
    count: number;
    ids: any[];
    isDone: boolean;
    continueCursor: convex_server0.Cursor;
    splitCursor?: convex_server0.Cursor | null;
    pageStatus?: "SplitRecommended" | "SplitRequired" | null;
  }>>;
  deleteOne: convex_server0.RegisteredMutation<"internal", {
    input: {
      where?: {
        operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
        connector?: "AND" | "OR" | undefined;
        value: string | number | boolean | string[] | number[] | null;
        field: string;
      }[] | undefined;
      model: string;
    } | {
      where?: any[] | undefined;
      model: string;
    };
  }, Promise<Record<string, unknown> | undefined>>;
  findMany: convex_server0.RegisteredQuery<"internal", {
    join?: any;
    limit?: number | undefined;
    where?: {
      operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
      connector?: "AND" | "OR" | undefined;
      value: string | number | boolean | string[] | number[] | null;
      field: string;
    }[] | undefined;
    offset?: number | undefined;
    sortBy?: {
      direction: "asc" | "desc";
      field: string;
    } | undefined;
    paginationOpts: {
      id?: number;
      endCursor?: string | null;
      maximumRowsRead?: number;
      maximumBytesRead?: number;
      numItems: number;
      cursor: string | null;
    };
    model: string;
  }, Promise<convex_server0.PaginationResult<convex_server0.GenericDocument>>>;
  findOne: convex_server0.RegisteredQuery<"internal", {
    join?: any;
    where?: {
      operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
      connector?: "AND" | "OR" | undefined;
      value: string | number | boolean | string[] | number[] | null;
      field: string;
    }[] | undefined;
    select?: string[] | undefined;
    model: string;
  }, Promise<convex_server0.GenericDocument | null>>;
  getLatestJwks: convex_server0.RegisteredAction<"internal", {}, Promise<unknown>>;
  rotateKeys: convex_server0.RegisteredAction<"internal", {}, Promise<unknown>>;
  updateMany: convex_server0.RegisteredMutation<"internal", {
    paginationOpts: {
      id?: number;
      endCursor?: string | null;
      maximumRowsRead?: number;
      maximumBytesRead?: number;
      numItems: number;
      cursor: string | null;
    };
    input: {
      where?: {
        operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
        connector?: "AND" | "OR" | undefined;
        value: string | number | boolean | string[] | number[] | null;
        field: string;
      }[] | undefined;
      update: {
        [x: string]: unknown;
        [x: number]: unknown;
        [x: symbol]: unknown;
      };
      model: string;
    } | {
      where?: any[] | undefined;
      update: any;
      model: string;
    };
  }, Promise<{
    count: number;
    ids: any[];
    isDone: boolean;
    continueCursor: convex_server0.Cursor;
    splitCursor?: convex_server0.Cursor | null;
    pageStatus?: "SplitRecommended" | "SplitRequired" | null;
  }>>;
  updateOne: convex_server0.RegisteredMutation<"internal", {
    input: {
      where?: {
        operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
        connector?: "AND" | "OR" | undefined;
        value: string | number | boolean | string[] | number[] | null;
        field: string;
      }[] | undefined;
      update: {
        [x: string]: unknown;
        [x: number]: unknown;
        [x: symbol]: unknown;
      };
      model: string;
    } | {
      where?: any[] | undefined;
      update: any;
      model: string;
    };
  }, Promise<any>>;
  authEnabled: true;
  authClient: {
    authFunctions: AuthFunctions;
    triggers: TriggerResolver<DataModel, Schema, TriggerCtx> | undefined;
    adapter: (ctx: GenericCtx<DataModel>, getAuthOptions: (ctx: any) => BetterAuthOptions) => better_auth_adapters0.AdapterFactory<BetterAuthOptions>;
  };
  getAuth: (ctx: GenericCtx$1) => Auth<AuthOptions & {
    database: any;
  }>;
  auth: BetterAuthRuntime<AuthOptions & {
    database: any;
  }>;
};
declare const createDisabledAuthRuntime: <DataModel extends GenericDataModel, Schema extends SchemaDefinition<GenericSchema, true>, TriggerCtx extends GenericMutationCtx<DataModel> = GenericMutationCtx<DataModel>, GenericCtx = GenericMutationCtx<DataModel>>(config?: {
  reason?: string;
}) => {
  authEnabled: false;
  authClient: ReturnType<typeof createClient<DataModel, Schema, TriggerCtx>>;
  auth: BetterAuthRuntime;
  getAuth: (ctx: GenericCtx) => BetterAuthRuntime;
  create: () => never;
  deleteMany: () => never;
  deleteOne: () => never;
  findMany: () => never;
  findOne: () => never;
  updateMany: () => never;
  updateOne: () => never;
  getLatestJwks: () => never;
  rotateKeys: () => never;
};
//#endregion
//#region src/auth/helpers.d.ts
type SessionDoc<TCtx extends GenericQueryCtx<any>> = DocByCtx<TCtx, 'session'>;
type SessionResult<TCtx extends GenericQueryCtx<any>> = LookupByIdResultByCtx<TCtx, 'session'>;
type SessionLookupCtx<TCtx extends GenericQueryCtx<any>> = QueryCtxWithPreferredOrmQueryTable<TCtx, 'session'>;
type SessionClientSignals = {
  ip?: string;
  userAgent?: string;
};
declare const getAuthUserIdentity: <DataModel extends GenericDataModel>(ctx: GenericQueryCtx<DataModel>) => Promise<{
  sessionId: DocumentByName<DataModel, "session">["_id"];
  userId: DocumentByName<DataModel, "user">["_id"];
  tokenIdentifier: string;
  subject: string;
  issuer: string;
  name?: string;
  givenName?: string;
  familyName?: string;
  nickname?: string;
  preferredUsername?: string;
  profileUrl?: string;
  pictureUrl?: string;
  email?: string;
  emailVerified?: boolean;
  gender?: string;
  birthday?: string;
  timezone?: string;
  language?: string;
  phoneNumber?: string;
  phoneNumberVerified?: boolean;
  address?: string;
  updatedAt?: string;
} | null>;
declare const getAuthUserId: <DataModel extends GenericDataModel>(ctx: GenericQueryCtx<DataModel>) => Promise<string | null>;
declare function getSession<TCtx extends GenericQueryCtx<any>>(ctx: TCtx & SessionLookupCtx<TCtx>, _sessionId?: SessionDoc<TCtx>['_id']): Promise<SessionResult<TCtx>>;
declare const getSessionNetworkSignals: <TCtx extends GenericQueryCtx<any>>(ctx: TCtx & QueryCtxWithPreferredOrmQueryTable<TCtx, "session">, session?: SessionResult<TCtx> | null) => Promise<SessionClientSignals>;
declare const getHeaders: <TCtx extends GenericQueryCtx<any>>(ctx: TCtx & QueryCtxWithPreferredOrmQueryTable<TCtx, "session">, session?: SessionResult<TCtx> | null) => Promise<Headers>;
//#endregion
export { type AuthFunctions, BetterAuthOptionsWithoutDatabase, ConvexCleanedWhere, GeneratedAuthDisabledReasonKind, GenericAuthBeforeResult, GenericAuthDefinition, GenericAuthTriggerChange, GenericAuthTriggerHandlers, GenericAuthTriggers, GetAuth, SessionClientSignals, type Triggers, adapterArgsValidator, adapterConfig, adapterWhereValidator, checkUniqueFields, convex, createApi, createAuthRuntime, createClient, createDisabledAuthRuntime, createHandler, dbAdapter, defineAuth, deleteManyHandler, deleteOneHandler, findManyHandler, findOneHandler, getAuthUserId, getAuthUserIdentity, getGeneratedAuthDisabledReason, getHeaders, getSession, getSessionNetworkSignals, handlePagination, hasUniqueFields, httpAdapter, listOne, paginate, resolveGeneratedAuthDefinition, selectFields, updateManyHandler, updateOneHandler };