@stackframe/tanstack-start 0.0.1 → 2.8.92

package/dist/storage-CKzvsBxG.d.ts

@@ -0,0 +1,1912 @@
+//#region ../../node_modules/.pnpm/convex@1.27.0_react@19.2.3/node_modules/convex/dist/cjs-types/values/value.d.ts
+/**
+ * The type of JavaScript values serializable to JSON.
+ *
+ * @public
+ */
+type JSONValue = null | boolean | number | string | JSONValue[] | {
+  [key: string]: JSONValue;
+};
+/**
+ * An identifier for a document in Convex.
+ *
+ * Convex documents are uniquely identified by their `Id`, which is accessible
+ * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/database/document-ids).
+ *
+ * Documents can be loaded using `db.get(id)` in query and mutation functions.
+ *
+ * IDs are base 32 encoded strings which are URL safe.
+ *
+ * IDs are just strings at runtime, but this type can be used to distinguish them from other
+ * strings at compile time.
+ *
+ * If you're using code generation, use the `Id` type generated for your data model in
+ * `convex/_generated/dataModel.d.ts`.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ *
+ * @public
+ */
+type Id<TableName extends string> = string & {
+  __tableName: TableName;
+};
+/**
+ * A value supported by Convex.
+ *
+ * Values can be:
+ * - stored inside of documents.
+ * - used as arguments and return types to queries and mutation functions.
+ *
+ * You can see the full set of supported types at
+ * [Types](https://docs.convex.dev/using/types).
+ *
+ * @public
+ */
+type Value$1 = null | bigint | number | boolean | string | ArrayBuffer | Value$1[] | {
+  [key: string]: undefined | Value$1;
+};
+/**
+ * The types of {@link Value} that can be used to represent numbers.
+ *
+ * @public
+ */
+type NumericValue = bigint | number;
+//#endregion
+//#region ../../node_modules/.pnpm/convex@1.27.0_react@19.2.3/node_modules/convex/dist/cjs-types/type_utils.d.ts
+/**
+ * Common utilities for manipulating TypeScript types.
+ * @module
+ */
+/**
+ * Hack! This type causes TypeScript to simplify how it renders object types.
+ *
+ * It is functionally the identity for object types, but in practice it can
+ * simplify expressions like `A & B`.
+ */
+type Expand<ObjectType extends Record<any, any>> = ObjectType extends Record<any, any> ? { [Key in keyof ObjectType]: ObjectType[Key] } : never;
+//#endregion
+//#region ../../node_modules/.pnpm/convex@1.27.0_react@19.2.3/node_modules/convex/dist/cjs-types/values/validators.d.ts
+type TableNameFromType<T> = T extends Id<infer TableName> ? TableName : string;
+/**
+ * Avoid using `instanceof BaseValidator`; this is inheritence for code reuse
+ * not type heirarchy.
+ */
+declare abstract class BaseValidator<Type, IsOptional extends OptionalProperty = "required", FieldPaths extends string = never> {
+  /**
+   * Only for TypeScript, the TS type of the JS values validated
+   * by this validator.
+   */
+  readonly type: Type;
+  /**
+   * Only for TypeScript, if this an Object validator, then
+   * this is the TS type of its property names.
+   */
+  readonly fieldPaths: FieldPaths;
+  /**
+   * Whether this is an optional Object property value validator.
+   */
+  readonly isOptional: IsOptional;
+  /**
+   * Always `"true"`.
+   */
+  readonly isConvexValidator: true;
+  constructor({
+    isOptional
+  }: {
+    isOptional: IsOptional;
+  });
+  /** @deprecated - use isOptional instead */
+  get optional(): boolean;
+}
+/**
+ * The type of the `v.id(tableName)` validator.
+ */
+declare class VId<Type, IsOptional extends OptionalProperty = "required"> extends BaseValidator<Type, IsOptional> {
+  /**
+   * The name of the table that the validated IDs must belong to.
+   */
+  readonly tableName: TableNameFromType<Type>;
+  /**
+   * The kind of validator, `"id"`.
+   */
+  readonly kind: "id";
+  /**
+   * Usually you'd use `v.id(tableName)` instead.
+   */
+  constructor({
+    isOptional,
+    tableName
+  }: {
+    isOptional: IsOptional;
+    tableName: TableNameFromType<Type>;
+  });
+}
+/**
+ * The type of the `v.float64()` validator.
+ */
+declare class VFloat64<Type = number, IsOptional extends OptionalProperty = "required"> extends BaseValidator<Type, IsOptional> {
+  /**
+   * The kind of validator, `"float64"`.
+   */
+  readonly kind: "float64";
+}
+/**
+ * The type of the `v.int64()` validator.
+ */
+declare class VInt64<Type = bigint, IsOptional extends OptionalProperty = "required"> extends BaseValidator<Type, IsOptional> {
+  /**
+   * The kind of validator, `"int64"`.
+   */
+  readonly kind: "int64";
+}
+/**
+ * The type of the `v.boolean()` validator.
+ */
+declare class VBoolean<Type = boolean, IsOptional extends OptionalProperty = "required"> extends BaseValidator<Type, IsOptional> {
+  /**
+   * The kind of validator, `"boolean"`.
+   */
+  readonly kind: "boolean";
+}
+/**
+ * The type of the `v.bytes()` validator.
+ */
+declare class VBytes<Type = ArrayBuffer, IsOptional extends OptionalProperty = "required"> extends BaseValidator<Type, IsOptional> {
+  /**
+   * The kind of validator, `"bytes"`.
+   */
+  readonly kind: "bytes";
+}
+/**
+ * The type of the `v.string()` validator.
+ */
+declare class VString<Type = string, IsOptional extends OptionalProperty = "required"> extends BaseValidator<Type, IsOptional> {
+  /**
+   * The kind of validator, `"string"`.
+   */
+  readonly kind: "string";
+}
+/**
+ * The type of the `v.null()` validator.
+ */
+declare class VNull<Type = null, IsOptional extends OptionalProperty = "required"> extends BaseValidator<Type, IsOptional> {
+  /**
+   * The kind of validator, `"null"`.
+   */
+  readonly kind: "null";
+}
+/**
+ * The type of the `v.any()` validator.
+ */
+declare class VAny<Type = any, IsOptional extends OptionalProperty = "required", FieldPaths extends string = string> extends BaseValidator<Type, IsOptional, FieldPaths> {
+  /**
+   * The kind of validator, `"any"`.
+   */
+  readonly kind: "any";
+}
+/**
+ * The type of the `v.object()` validator.
+ */
+declare class VObject<Type, Fields extends Record<string, GenericValidator>, IsOptional extends OptionalProperty = "required", FieldPaths extends string = { [Property in keyof Fields]: JoinFieldPaths<Property & string, Fields[Property]["fieldPaths"]> | Property }[keyof Fields] & string> extends BaseValidator<Type, IsOptional, FieldPaths> {
+  /**
+   * An object with the validator for each property.
+   */
+  readonly fields: Fields;
+  /**
+   * The kind of validator, `"object"`.
+   */
+  readonly kind: "object";
+  /**
+   * Usually you'd use `v.object({ ... })` instead.
+   */
+  constructor({
+    isOptional,
+    fields
+  }: {
+    isOptional: IsOptional;
+    fields: Fields;
+  });
+}
+/**
+ * The type of the `v.literal()` validator.
+ */
+declare class VLiteral<Type, IsOptional extends OptionalProperty = "required"> extends BaseValidator<Type, IsOptional> {
+  /**
+   * The value that the validated values must be equal to.
+   */
+  readonly value: Type;
+  /**
+   * The kind of validator, `"literal"`.
+   */
+  readonly kind: "literal";
+  /**
+   * Usually you'd use `v.literal(value)` instead.
+   */
+  constructor({
+    isOptional,
+    value
+  }: {
+    isOptional: IsOptional;
+    value: Type;
+  });
+}
+/**
+ * The type of the `v.array()` validator.
+ */
+declare class VArray<Type, Element extends Validator<any, "required", any>, IsOptional extends OptionalProperty = "required"> extends BaseValidator<Type, IsOptional> {
+  /**
+   * The validator for the elements of the array.
+   */
+  readonly element: Element;
+  /**
+   * The kind of validator, `"array"`.
+   */
+  readonly kind: "array";
+  /**
+   * Usually you'd use `v.array(element)` instead.
+   */
+  constructor({
+    isOptional,
+    element
+  }: {
+    isOptional: IsOptional;
+    element: Element;
+  });
+}
+/**
+ * The type of the `v.record()` validator.
+ */
+declare class VRecord<Type, Key extends Validator<string, "required", any>, Value extends Validator<any, "required", any>, IsOptional extends OptionalProperty = "required", FieldPaths extends string = string> extends BaseValidator<Type, IsOptional, FieldPaths> {
+  /**
+   * The validator for the keys of the record.
+   */
+  readonly key: Key;
+  /**
+   * The validator for the values of the record.
+   */
+  readonly value: Value;
+  /**
+   * The kind of validator, `"record"`.
+   */
+  readonly kind: "record";
+  /**
+   * Usually you'd use `v.record(key, value)` instead.
+   */
+  constructor({
+    isOptional,
+    key,
+    value
+  }: {
+    isOptional: IsOptional;
+    key: Key;
+    value: Value;
+  });
+}
+/**
+ * The type of the `v.union()` validator.
+ */
+declare class VUnion<Type, T extends Validator<any, "required", any>[], IsOptional extends OptionalProperty = "required", FieldPaths extends string = T[number]["fieldPaths"]> extends BaseValidator<Type, IsOptional, FieldPaths> {
+  /**
+   * The array of validators, one of which must match the value.
+   */
+  readonly members: T;
+  /**
+   * The kind of validator, `"union"`.
+   */
+  readonly kind: "union";
+  /**
+   * Usually you'd use `v.union(...members)` instead.
+   */
+  constructor({
+    isOptional,
+    members
+  }: {
+    isOptional: IsOptional;
+    members: T;
+  });
+}
+/**
+ * Type representing whether a property in an object is optional or required.
+ *
+ * @public
+ */
+type OptionalProperty = "optional" | "required";
+/**
+ * A validator for a Convex value.
+ *
+ * This should be constructed using the validator builder, {@link v}.
+ *
+ * A validator encapsulates:
+ * - The TypeScript type of this value.
+ * - Whether this field should be optional if it's included in an object.
+ * - The TypeScript type for the set of index field paths that can be used to
+ * build indexes on this value.
+ * - A JSON representation of the validator.
+ *
+ * Specific types of validators contain additional information: for example
+ * an `ArrayValidator` contains an `element` property with the validator
+ * used to validate each element of the list. Use the shared 'kind' property
+ * to identity the type of validator.
+ *
+ * More validators can be added in future releases so an exhaustive
+ * switch statement on validator `kind` should be expected to break
+ * in future releases of Convex.
+ *
+ * @public
+ */
+type Validator<Type, IsOptional extends OptionalProperty = "required", FieldPaths extends string = never> = VId<Type, IsOptional> | VString<Type, IsOptional> | VFloat64<Type, IsOptional> | VInt64<Type, IsOptional> | VBoolean<Type, IsOptional> | VNull<Type, IsOptional> | VAny<Type, IsOptional> | VLiteral<Type, IsOptional> | VBytes<Type, IsOptional> | VObject<Type, Record<string, Validator<any, OptionalProperty, any>>, IsOptional, FieldPaths> | VArray<Type, Validator<any, "required", any>, IsOptional> | VRecord<Type, Validator<string, "required", any>, Validator<any, "required", any>, IsOptional, FieldPaths> | VUnion<Type, Validator<any, "required", any>[], IsOptional, FieldPaths>;
+/**
+ * Join together two index field paths.
+ *
+ * This is used within the validator builder, {@link v}.
+ * @public
+ */
+type JoinFieldPaths<Start extends string, End extends string> = `${Start}.${End}`;
+//#endregion
+//#region ../../node_modules/.pnpm/convex@1.27.0_react@19.2.3/node_modules/convex/dist/cjs-types/values/validator.d.ts
+/**
+ * The type that all validators must extend.
+ *
+ * @public
+ */
+type GenericValidator = Validator<any, any, any>;
+//#endregion
+//#region ../../node_modules/.pnpm/convex@1.27.0_react@19.2.3/node_modules/convex/dist/cjs-types/server/authentication.d.ts
+/**
+ * Information about an authenticated user, derived from a
+ * [JWT](https://datatracker.ietf.org/doc/html/rfc7519).
+ *
+ * The only fields guaranteed to be present are
+ * {@link UserIdentity.tokenIdentifier} and {@link UserIdentity.issuer}. All
+ * remaining fields may or may not be present depending on the information given
+ * by the identity provider.
+ *
+ * The explicitly listed fields are derived from the OpenID Connect (OIDC) standard fields,
+ * see the [OIDC specification](https://openid.net/specs/openid-connect-core-1_0.html#StandardClaims)
+ * for more information on these fields.
+ *
+ * Any additional fields are custom claims that may be present in the JWT,
+ * and their type depends on your identity provider configuration. If you
+ * know the type of the field, you can assert it in TypeScript like this
+ * (for example as a `string`):
+ *
+ * ```typescript
+ * const identity = await ctx.auth.getUserIdentity();
+ * if (identity === null) {
+ *   return null;
+ * }
+ * const customClaim = identity.custom_claim as string;
+ * ```
+ *
+ * @public
+ */
+interface UserIdentity {
+  /**
+   * A stable and globally unique string for this identity (i.e. no other
+   * user, even from a different identity provider, will have the same string.)
+   *
+   * JWT claims: `sub` + `iss`
+   */
+  readonly tokenIdentifier: string;
+  /**
+   * Identifier for the end-user from the identity provider, not necessarily
+   * unique across different providers.
+   *
+   * JWT claim: `sub`
+   */
+  readonly subject: string;
+  /**
+   * The hostname of the identity provider used to authenticate this user.
+   *
+   * JWT claim: `iss`
+   */
+  readonly issuer: string;
+  /**
+   * JWT claim: `name`
+   */
+  readonly name?: string;
+  /**
+   * JWT claim: `given_name`
+   */
+  readonly givenName?: string;
+  /**
+   * JWT claim: `family_name`
+   */
+  readonly familyName?: string;
+  /**
+   * JWT claim: `nickname`
+   */
+  readonly nickname?: string;
+  /**
+   * JWT claim: `preferred_username`
+   */
+  readonly preferredUsername?: string;
+  /**
+   * JWT claim: `profile`
+   */
+  readonly profileUrl?: string;
+  /**
+   * JWT claim: `picture`
+   */
+  readonly pictureUrl?: string;
+  /**
+   * JWT claim: `email`
+   */
+  readonly email?: string;
+  /**
+   * JWT claim: `email_verified`
+   */
+  readonly emailVerified?: boolean;
+  /**
+   * JWT claim: `gender`
+   */
+  readonly gender?: string;
+  /**
+   * JWT claim: `birthdate`
+   */
+  readonly birthday?: string;
+  /**
+   * JWT claim: `zoneinfo`
+   */
+  readonly timezone?: string;
+  /**
+   * JWT claim: `locale`
+   */
+  readonly language?: string;
+  /**
+   * JWT claim: `phone_number`
+   */
+  readonly phoneNumber?: string;
+  /**
+   * JWT claim: `phone_number_verified`
+   */
+  readonly phoneNumberVerified?: boolean;
+  /**
+   * JWT claim: `address`
+   */
+  readonly address?: string;
+  /**
+   * JWT claim: `updated_at`
+   */
+  readonly updatedAt?: string;
+  /**
+   * Any custom claims.
+   */
+  [key: string]: JSONValue | undefined;
+}
+/**
+ * An interface to access information about the currently authenticated user
+ * within Convex query and mutation functions.
+ *
+ * @public
+ */
+interface Auth {
+  /**
+   * Get details about the currently authenticated user.
+   *
+   * @returns A promise that resolves to a {@link UserIdentity} if the Convex
+   * client was configured with a valid ID token, or if not, will:
+   * + returns `null` on Convex queries, mutations, actions.
+   * + `throw` on HTTP Actions.
+   */
+  getUserIdentity(): Promise<UserIdentity | null>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/convex@1.27.0_react@19.2.3/node_modules/convex/dist/cjs-types/server/data_model.d.ts
+/**
+ * A document stored in Convex.
+ * @public
+ */
+type GenericDocument = Record<string, Value$1>;
+/**
+ * A type describing all of the document fields in a table.
+ *
+ * These can either be field names (like "name") or references to fields on
+ * nested objects (like "properties.name").
+ * @public
+ */
+type GenericFieldPaths = string;
+/**
+ * A type describing the ordered fields in an index.
+ *
+ * These can either be field names (like "name") or references to fields on
+ * nested objects (like "properties.name").
+ * @public
+ */
+type GenericIndexFields = string[];
+/**
+ * A type describing the indexes in a table.
+ *
+ * It's an object mapping each index name to the fields in the index.
+ * @public
+ */
+type GenericTableIndexes = Record<string, GenericIndexFields>;
+/**
+ * A type describing the configuration of a search index.
+ * @public
+ */
+type GenericSearchIndexConfig = {
+  searchField: string;
+  filterFields: string;
+};
+/**
+ * A type describing all of the search indexes in a table.
+ *
+ * This is an object mapping each index name to the config for the index.
+ * @public
+ */
+type GenericTableSearchIndexes = Record<string, GenericSearchIndexConfig>;
+/**
+ * A type describing the configuration of a vector index.
+ * @public
+ */
+type GenericVectorIndexConfig = {
+  vectorField: string;
+  dimensions: number;
+  filterFields: string;
+};
+/**
+ * A type describing all of the vector indexes in a table.
+ *
+ * This is an object mapping each index name to the config for the index.
+ * @public
+ */
+type GenericTableVectorIndexes = Record<string, GenericVectorIndexConfig>;
+/**
+ * If we have A | B | C, this finds A[Key] | B[Key] | C[Key], where we default to
+ * `Default` if the Key isn't found.
+ *
+ * Conditional types apparently loop over the variants in a union, so the `T extends T`
+ * is enough to force this behavior.
+ * https://stackoverflow.com/questions/49401866/all-possible-keys-of-an-union-type
+ */
+type ValueFromUnion<T, Key, Default> = T extends T ? Key extends keyof T ? T[Key] : Default : never;
+/**
+ * The type of a field in a document.
+ *
+ * Note that this supports both simple fields like "name" and nested fields like
+ * "properties.name".
+ *
+ * If the field is not present in the document it is considered to be `undefined`.
+ *
+ * @public
+ */
+type FieldTypeFromFieldPath<Document extends GenericDocument, FieldPath extends string> = FieldTypeFromFieldPathInner<Document, FieldPath> extends Value$1 | undefined ? FieldTypeFromFieldPathInner<Document, FieldPath> : Value$1 | undefined;
+/**
+ * The inner type of {@link FieldTypeFromFieldPath}.
+ *
+ * It's wrapped in a helper to coerce the type to `Value | undefined` since some
+ * versions of TypeScript fail to infer this type correctly.
+ *
+ * @public
+ */
+type FieldTypeFromFieldPathInner<Document extends GenericDocument, FieldPath extends string> = FieldPath extends `${infer First}.${infer Second}` ? ValueFromUnion<Document, First, Record<never, never>> extends infer FieldValue ? FieldValue extends GenericDocument ? FieldTypeFromFieldPath<FieldValue, Second> : undefined : undefined : ValueFromUnion<Document, FieldPath, undefined>;
+/**
+ * A type describing the document type and indexes in a table.
+ * @public
+ */
+type GenericTableInfo = {
+  document: GenericDocument;
+  fieldPaths: GenericFieldPaths;
+  indexes: GenericTableIndexes;
+  searchIndexes: GenericTableSearchIndexes;
+  vectorIndexes: GenericTableVectorIndexes;
+};
+/**
+ * The type of a document in a table for a given {@link GenericTableInfo}.
+ * @public
+ */
+type DocumentByInfo<TableInfo extends GenericTableInfo> = TableInfo["document"];
+/**
+ * The field paths in a table for a given {@link GenericTableInfo}.
+ *
+ * These can either be field names (like "name") or references to fields on
+ * nested objects (like "properties.name").
+ * @public
+ */
+type FieldPaths$1<TableInfo extends GenericTableInfo> = TableInfo["fieldPaths"];
+/**
+ * The database indexes in a table for a given {@link GenericTableInfo}.
+ *
+ * This will be an object mapping index names to the fields in the index.
+ * @public
+ */
+type Indexes$1<TableInfo extends GenericTableInfo> = TableInfo["indexes"];
+/**
+ * The names of indexes in a table for a given {@link GenericTableInfo}.
+ * @public
+ */
+type IndexNames<TableInfo extends GenericTableInfo> = keyof Indexes$1<TableInfo>;
+/**
+ * Extract the fields of an index from a {@link GenericTableInfo} by name.
+ * @public
+ */
+type NamedIndex<TableInfo extends GenericTableInfo, IndexName extends IndexNames<TableInfo>> = Indexes$1<TableInfo>[IndexName];
+/**
+ * The search indexes in a table for a given {@link GenericTableInfo}.
+ *
+ * This will be an object mapping index names to the search index config.
+ * @public
+ */
+type SearchIndexes$1<TableInfo extends GenericTableInfo> = TableInfo["searchIndexes"];
+/**
+ * The names of search indexes in a table for a given {@link GenericTableInfo}.
+ * @public
+ */
+type SearchIndexNames<TableInfo extends GenericTableInfo> = keyof SearchIndexes$1<TableInfo>;
+/**
+ * Extract the config of a search index from a {@link GenericTableInfo} by name.
+ * @public
+ */
+type NamedSearchIndex<TableInfo extends GenericTableInfo, IndexName extends SearchIndexNames<TableInfo>> = SearchIndexes$1<TableInfo>[IndexName];
+/**
+ * A type describing the tables in a Convex project.
+ *
+ * This is designed to be code generated with `npx convex dev`.
+ * @public
+ */
+type GenericDataModel = Record<string, GenericTableInfo>;
+/**
+ * A {@link GenericDataModel} that considers documents to be `any` and does not
+ * support indexes.
+ *
+ * This is the default before a schema is defined.
+ * @public
+ */
+type AnyDataModel = {
+  [tableName: string]: {
+    document: any;
+    fieldPaths: GenericFieldPaths;
+    indexes: {};
+    searchIndexes: {};
+    vectorIndexes: {};
+  };
+};
+/**
+ * A type of all of the table names defined in a {@link GenericDataModel}.
+ * @public
+ */
+type TableNamesInDataModel<DataModel extends GenericDataModel> = keyof DataModel & string;
+/**
+ * Extract the `TableInfo` for a table in a {@link GenericDataModel} by table
+ * name.
+ *
+ * @public
+ */
+type NamedTableInfo<DataModel extends GenericDataModel, TableName extends keyof DataModel> = DataModel[TableName];
+/**
+ * The type of a document in a {@link GenericDataModel} by table name.
+ * @public
+ */
+type DocumentByName<DataModel extends GenericDataModel, TableName extends TableNamesInDataModel<DataModel>> = DataModel[TableName]["document"];
+//#endregion
+//#region ../../node_modules/.pnpm/convex@1.27.0_react@19.2.3/node_modules/convex/dist/cjs-types/server/filter_builder.d.ts
+/**
+ * Expressions are evaluated to produce a {@link values.Value} in the course of executing a query.
+ *
+ * To construct an expression, use the {@link FilterBuilder} provided within
+ * {@link OrderedQuery.filter}.
+ *
+ * @typeParam T - The type that this expression evaluates to.
+ * @public
+ */
+declare abstract class Expression<T extends Value$1 | undefined> {
+  private _isExpression;
+  private _value;
+}
+/**
+ * An {@link Expression} or a constant {@link values.Value}
+ *
+ * @public
+ */
+type ExpressionOrValue<T extends Value$1 | undefined> = Expression<T> | T;
+/**
+ * An interface for defining filters in queries.
+ *
+ * `FilterBuilder` has various methods that produce {@link Expression}s.
+ * These expressions can be nested together along with constants to express
+ * a filter predicate.
+ *
+ * `FilterBuilder` is used within {@link OrderedQuery.filter} to create query
+ * filters.
+ *
+ * Here are the available methods:
+ *
+ * |                               |                                               |
+ * |-------------------------------|-----------------------------------------------|
+ * | **Comparisons**               | Error when `l` and `r` are not the same type. |
+ * | [`eq(l, r)`](#eq)             | `l === r`                                     |
+ * | [`neq(l, r)`](#neq)           | `l !== r`                                     |
+ * | [`lt(l, r)`](#lt)             | `l < r`                                       |
+ * | [`lte(l, r)`](#lte)           | `l <= r`                                      |
+ * | [`gt(l, r)`](#gt)             | `l > r`                                       |
+ * | [`gte(l, r)`](#gte)           | `l >= r`                                      |
+ * |                               |                                               |
+ * | **Arithmetic**                | Error when `l` and `r` are not the same type. |
+ * | [`add(l, r)`](#add)           | `l + r`                                       |
+ * | [`sub(l, r)`](#sub)           | `l - r`                                       |
+ * | [`mul(l, r)`](#mul)           | `l * r`                                       |
+ * | [`div(l, r)`](#div)           | `l / r`                                       |
+ * | [`mod(l, r)`](#mod)           | `l % r`                                       |
+ * | [`neg(x)`](#neg)              | `-x`                                          |
+ * |                               |                                               |
+ * | **Logic**                     | Error if any param is not a `bool`.           |
+ * | [`not(x)`](#not)              | `!x`                                          |
+ * | [`and(a, b, ..., z)`](#and)   | `a && b && ... && z`                          |
+ * | [`or(a, b, ..., z)`](#or)     | <code>a &#124;&#124; b &#124;&#124; ... &#124;&#124; z</code> |
+ * |                               |                                               |
+ * | **Other**                     |                                               |
+ * | [`field(fieldPath)`](#field)  | Evaluates to the field at `fieldPath`.        |
+ * @public
+ */
+interface FilterBuilder<TableInfo extends GenericTableInfo> {
+  /**
+   * `l === r`
+   *
+   * @public
+   * */
+  eq<T extends Value$1 | undefined>(l: ExpressionOrValue<T>, r: ExpressionOrValue<T>): Expression<boolean>;
+  /**
+   * `l !== r`
+   *
+   * @public
+   * */
+  neq<T extends Value$1 | undefined>(l: ExpressionOrValue<T>, r: ExpressionOrValue<T>): Expression<boolean>;
+  /**
+   * `l < r`
+   *
+   * @public
+   */
+  lt<T extends Value$1>(l: ExpressionOrValue<T>, r: ExpressionOrValue<T>): Expression<boolean>;
+  /**
+   * `l <= r`
+   *
+   * @public
+   */
+  lte<T extends Value$1>(l: ExpressionOrValue<T>, r: ExpressionOrValue<T>): Expression<boolean>;
+  /**
+   * `l > r`
+   *
+   * @public
+   */
+  gt<T extends Value$1>(l: ExpressionOrValue<T>, r: ExpressionOrValue<T>): Expression<boolean>;
+  /**
+   * `l >= r`
+   *
+   * @public
+   */
+  gte<T extends Value$1>(l: ExpressionOrValue<T>, r: ExpressionOrValue<T>): Expression<boolean>;
+  /**
+   * `l + r`
+   *
+   * @public
+   */
+  add<T extends NumericValue>(l: ExpressionOrValue<T>, r: ExpressionOrValue<T>): Expression<T>;
+  /**
+   * `l - r`
+   *
+   * @public
+   */
+  sub<T extends NumericValue>(l: ExpressionOrValue<T>, r: ExpressionOrValue<T>): Expression<T>;
+  /**
+   * `l * r`
+   *
+   * @public
+   */
+  mul<T extends NumericValue>(l: ExpressionOrValue<T>, r: ExpressionOrValue<T>): Expression<T>;
+  /**
+   * `l / r`
+   *
+   * @public
+   */
+  div<T extends NumericValue>(l: ExpressionOrValue<T>, r: ExpressionOrValue<T>): Expression<T>;
+  /**
+   * `l % r`
+   *
+   * @public
+   */
+  mod<T extends NumericValue>(l: ExpressionOrValue<T>, r: ExpressionOrValue<T>): Expression<T>;
+  /**
+   * `-x`
+   *
+   * @public
+   */
+  neg<T extends NumericValue>(x: ExpressionOrValue<T>): Expression<T>;
+  /**
+   * `exprs[0] && exprs[1] && ... && exprs[n]`
+   *
+   * @public
+   */
+  and(...exprs: Array<ExpressionOrValue<boolean>>): Expression<boolean>;
+  /**
+   * `exprs[0] || exprs[1] || ... || exprs[n]`
+   *
+   * @public
+   */
+  or(...exprs: Array<ExpressionOrValue<boolean>>): Expression<boolean>;
+  /**
+   * `!x`
+   *
+   * @public
+   */
+  not(x: ExpressionOrValue<boolean>): Expression<boolean>;
+  /**
+   * Evaluates to the field at the given `fieldPath`.
+   *
+   * For example, in {@link OrderedQuery.filter} this can be used to examine the values being filtered.
+   *
+   * #### Example
+   *
+   * On this object:
+   * ```
+   * {
+   *   "user": {
+   *     "isActive": true
+   *   }
+   * }
+   * ```
+   *
+   * `field("user.isActive")` evaluates to `true`.
+   *
+   * @public
+   */
+  field<FieldPath extends FieldPaths$1<TableInfo>>(fieldPath: FieldPath): Expression<FieldTypeFromFieldPath<DocumentByInfo<TableInfo>, FieldPath>>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/convex@1.27.0_react@19.2.3/node_modules/convex/dist/cjs-types/server/index_range_builder.d.ts
+/**
+ * A type that adds 1 to a number literal type (up to 14).
+ *
+ * This is necessary to step through the fields in an index.
+ */
+type PlusOne<N extends number> = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15][N];
+/**
+ * Builder to define an index range to query.
+ *
+ * An index range is a description of which documents Convex should consider
+ * when running the query.
+ *
+ * An index range is always a chained list of:
+ * 1. 0 or more equality expressions defined with `.eq`.
+ * 2. [Optionally] A lower bound expression defined with `.gt` or `.gte`.
+ * 3. [Optionally] An upper bound expression defined with `.lt` or `.lte`.
+ *
+ * **You must step through fields in index order.**
+ *
+ * Each equality expression must compare a different index field, starting from
+ * the beginning and in order. The upper and lower bounds must follow the
+ * equality expressions and compare the next field.
+ *
+ * For example, if there is an index of messages on
+ * `["projectId", "priority"]`, a range searching for "messages in 'myProjectId'
+ * with priority at least 100" would look like:
+ * ```ts
+ * q.eq("projectId", myProjectId)
+ *  .gte("priority", 100)
+ * ```
+ *
+ * **The performance of your query is based on the specificity of the range.**
+ *
+ * This class is designed to only allow you to specify ranges that Convex can
+ * efficiently use your index to find. For all other filtering use
+ * {@link OrderedQuery.filter}.
+ *
+ * To learn about indexes, see [Indexes](https://docs.convex.dev/using/indexes).
+ * @public
+ */
+interface IndexRangeBuilder<Document extends GenericDocument, IndexFields extends GenericIndexFields, FieldNum extends number = 0> extends LowerBoundIndexRangeBuilder<Document, IndexFields[FieldNum]> {
+  /**
+   * Restrict this range to documents where `doc[fieldName] === value`.
+   *
+   * @param fieldName - The name of the field to compare. Must be the next field
+   * in the index.
+   * @param value - The value to compare against.
+   */
+  eq(fieldName: IndexFields[FieldNum], value: FieldTypeFromFieldPath<Document, IndexFields[FieldNum]>): NextIndexRangeBuilder<Document, IndexFields, FieldNum>;
+}
+/**
+ * An {@link IndexRangeBuilder} for the next field of the index.
+ *
+ * This type is careful to check if adding one to the `FieldNum` will exceed
+ * the length of the `IndexFields`.
+ */
+type NextIndexRangeBuilder<Document extends GenericDocument, IndexFields extends GenericIndexFields, FieldNum extends number> = PlusOne<FieldNum> extends IndexFields["length"] ? IndexRange : IndexRangeBuilder<Document, IndexFields, PlusOne<FieldNum>>;
+/**
+ * Builder to define the lower bound of an index range.
+ *
+ * See {@link IndexRangeBuilder}.
+ *
+ * @public
+ */
+interface LowerBoundIndexRangeBuilder<Document extends GenericDocument, IndexFieldName extends string> extends UpperBoundIndexRangeBuilder<Document, IndexFieldName> {
+  /**
+   * Restrict this range to documents where `doc[fieldName] > value`.
+   *
+   * @param fieldName - The name of the field to compare. Must be the next field
+   * in the index.
+   * @param value - The value to compare against.
+   */
+  gt(fieldName: IndexFieldName, value: FieldTypeFromFieldPath<Document, IndexFieldName>): UpperBoundIndexRangeBuilder<Document, IndexFieldName>;
+  /**
+   * Restrict this range to documents where `doc[fieldName] >= value`.
+   *
+   * @param fieldName - The name of the field to compare. Must be the next field
+   * in the index.
+   * @param value - The value to compare against.
+   */
+  gte(fieldName: IndexFieldName, value: FieldTypeFromFieldPath<Document, IndexFieldName>): UpperBoundIndexRangeBuilder<Document, IndexFieldName>;
+}
+/**
+ * Builder to define the upper bound of an index range.
+ *
+ * See {@link IndexRangeBuilder}.
+ *
+ * @public
+ */
+interface UpperBoundIndexRangeBuilder<Document extends GenericDocument, IndexFieldName extends string> extends IndexRange {
+  /**
+   * Restrict this range to documents where `doc[fieldName] < value`.
+   *
+   * @param fieldName - The name of the field to compare. Must be the same index
+   * field used in the lower bound (`.gt` or `.gte`) or the next field if no
+   * lower bound was specified.
+   * @param value - The value to compare against.
+   */
+  lt(fieldName: IndexFieldName, value: FieldTypeFromFieldPath<Document, IndexFieldName>): IndexRange;
+  /**
+   * Restrict this range to documents where `doc[fieldName] <= value`.
+   *
+   * @param fieldName - The name of the field to compare. Must be the same index
+   * field used in the lower bound (`.gt` or `.gte`) or the next field if no
+   * lower bound was specified.
+   * @param value - The value to compare against.
+   */
+  lte(fieldName: IndexFieldName, value: FieldTypeFromFieldPath<Document, IndexFieldName>): IndexRange;
+}
+/**
+ * An expression representing an index range created by
+ * {@link IndexRangeBuilder}.
+ * @public
+ */
+declare abstract class IndexRange {
+  private _isIndexRange;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/convex@1.27.0_react@19.2.3/node_modules/convex/dist/cjs-types/server/pagination.d.ts
+/**
+ * An opaque identifier used for paginating a database query.
+ *
+ * Cursors are returned from {@link OrderedQuery.paginate} and represent the
+ * point of the query where the page of results ended.
+ *
+ * To continue paginating, pass the cursor back into
+ * {@link OrderedQuery.paginate} in the {@link PaginationOptions} object to
+ * fetch another page of results.
+ *
+ * Note: Cursors can only be passed to _exactly_ the same database query that
+ * they were generated from. You may not reuse a cursor between different
+ * database queries.
+ *
+ * @public
+ */
+type Cursor = string;
+/**
+ * The result of paginating using {@link OrderedQuery.paginate}.
+ *
+ * @public
+ */
+interface PaginationResult<T> {
+  /**
+   * The page of results.
+   */
+  page: T[];
+  /**
+   * Have we reached the end of the results?
+   */
+  isDone: boolean;
+  /**
+   * A {@link Cursor} to continue loading more results.
+   */
+  continueCursor: Cursor;
+  /**
+   * A {@link Cursor} to split the page into two, so the page from
+   * (cursor, continueCursor] can be replaced by two pages (cursor, splitCursor]
+   * and (splitCursor, continueCursor].
+   */
+  splitCursor?: Cursor | null;
+  /**
+   * When a query reads too much data, it may return 'SplitRecommended' to
+   * indicate that the page should be split into two with `splitCursor`.
+   * When a query reads so much data that `page` might be incomplete, its status
+   * becomes 'SplitRequired'.
+   */
+  pageStatus?: "SplitRecommended" | "SplitRequired" | null;
+}
+/**
+ * The options passed to {@link OrderedQuery.paginate}.
+ *
+ * To use this type in [argument validation](https://docs.convex.dev/functions/validation),
+ * use the {@link paginationOptsValidator}.
+ *
+ * @public
+ */
+interface PaginationOptions {
+  /**
+   * Number of items to load in this page of results.
+   *
+   * Note: This is only an initial value!
+   *
+   * If you are running this paginated query in a reactive query function, you
+   * may receive more or less items than this if items were added to or removed
+   * from the query range.
+   */
+  numItems: number;
+  /**
+   * A {@link Cursor} representing the start of this page or `null` to start
+   * at the beginning of the query results.
+   */
+  cursor: Cursor | null;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/convex@1.27.0_react@19.2.3/node_modules/convex/dist/cjs-types/server/search_filter_builder.d.ts
+/**
+ * Builder for defining search filters.
+ *
+ * A search filter is a chained list of:
+ * 1. One search expression constructed with `.search`.
+ * 2. Zero or more equality expressions constructed with `.eq`.
+ *
+ * The search expression must search for text in the index's `searchField`. The
+ * filter expressions can use any of the `filterFields` defined in the index.
+ *
+ * For all other filtering use {@link OrderedQuery.filter}.
+ *
+ * To learn about full text search, see [Indexes](https://docs.convex.dev/text-search).
+ * @public
+ */
+interface SearchFilterBuilder<Document extends GenericDocument, SearchIndexConfig extends GenericSearchIndexConfig> {
+  /**
+   * Search for the terms in `query` within `doc[fieldName]`.
+   *
+   * This will do a full text search that returns results where any word of of
+   * `query` appears in the field.
+   *
+   * Documents will be returned based on their relevance to the query. This
+   * takes into account:
+   * - How many words in the query appear in the text?
+   * - How many times do they appear?
+   * - How long is the text field?
+   *
+   * @param fieldName - The name of the field to search in. This must be listed
+   * as the index's `searchField`.
+   * @param query - The query text to search for.
+   */
+  search(fieldName: SearchIndexConfig["searchField"], query: string): SearchFilterFinalizer<Document, SearchIndexConfig>;
+}
+/**
+ * Builder to define equality expressions as part of a search filter.
+ *
+ * See {@link SearchFilterBuilder}.
+ *
+ * @public
+ */
+interface SearchFilterFinalizer<Document extends GenericDocument, SearchIndexConfig extends GenericSearchIndexConfig> extends SearchFilter {
+  /**
+   * Restrict this query to documents where `doc[fieldName] === value`.
+   *
+   * @param fieldName - The name of the field to compare. This must be listed in
+   * the search index's `filterFields`.
+   * @param value - The value to compare against.
+   */
+  eq<FieldName extends SearchIndexConfig["filterFields"]>(fieldName: FieldName, value: FieldTypeFromFieldPath<Document, FieldName>): SearchFilterFinalizer<Document, SearchIndexConfig>;
+}
+/**
+ * An expression representing a search filter created by
+ * {@link SearchFilterBuilder}.
+ *
+ * @public
+ */
+declare abstract class SearchFilter {
+  private _isSearchFilter;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/convex@1.27.0_react@19.2.3/node_modules/convex/dist/cjs-types/server/query.d.ts
+/**
+ * The {@link QueryInitializer} interface is the entry point for building a {@link Query}
+ * over a Convex database table.
+ *
+ * There are two types of queries:
+ * 1. Full table scans: Queries created with {@link QueryInitializer.fullTableScan} which
+ * iterate over all of the documents in the table in insertion order.
+ * 2. Indexed Queries: Queries created with {@link QueryInitializer.withIndex} which iterate
+ * over an index range in index order.
+ *
+ * For convenience, {@link QueryInitializer} extends the {@link Query} interface, implicitly
+ * starting a full table scan.
+ *
+ * @public
+ */
+interface QueryInitializer<TableInfo extends GenericTableInfo> extends Query<TableInfo> {
+  /**
+   * Query by reading all of the values out of this table.
+   *
+   * This query's cost is relative to the size of the entire table, so this
+   * should only be used on tables that will stay very small (say between a few
+   * hundred and a few thousand documents) and are updated infrequently.
+   *
+   * @returns - The {@link Query} that iterates over every document of the table.
+   */
+  fullTableScan(): Query<TableInfo>;
+  /**
+   * Query by reading documents from an index on this table.
+   *
+   * This query's cost is relative to the number of documents that match the
+   * index range expression.
+   *
+   * Results will be returned in index order.
+   *
+   * To learn about indexes, see [Indexes](https://docs.convex.dev/using/indexes).
+   *
+   * @param indexName - The name of the index to query.
+   * @param indexRange - An optional index range constructed with the supplied
+   *  {@link IndexRangeBuilder}. An index range is a description of which
+   * documents Convex should consider when running the query. If no index
+   * range is present, the query will consider all documents in the index.
+   * @returns - The query that yields documents in the index.
+   */
+  withIndex<IndexName extends IndexNames<TableInfo>>(indexName: IndexName, indexRange?: (q: IndexRangeBuilder<DocumentByInfo<TableInfo>, NamedIndex<TableInfo, IndexName>>) => IndexRange): Query<TableInfo>;
+  /**
+   * Query by running a full text search against a search index.
+   *
+   * Search queries must always search for some text within the index's
+   * `searchField`. This query can optionally add equality filters for any
+   * `filterFields` specified in the index.
+   *
+   * Documents will be returned in relevance order based on how well they
+   * match the search text.
+   *
+   * To learn about full text search, see [Indexes](https://docs.convex.dev/text-search).
+   *
+   * @param indexName - The name of the search index to query.
+   * @param searchFilter - A search filter expression constructed with the
+   * supplied {@link SearchFilterBuilder}. This defines the full text search to run
+   * along with equality filtering to run within the search index.
+   * @returns - A query that searches for matching documents, returning them
+   * in relevancy order.
+   */
+  withSearchIndex<IndexName extends SearchIndexNames<TableInfo>>(indexName: IndexName, searchFilter: (q: SearchFilterBuilder<DocumentByInfo<TableInfo>, NamedSearchIndex<TableInfo, IndexName>>) => SearchFilter): OrderedQuery<TableInfo>;
+}
+/**
+ * The {@link Query} interface allows functions to read values out of the database.
+ *
+ * **If you only need to load an object by ID, use `db.get(id)` instead.**
+ *
+ * Executing a query consists of calling
+ * 1. (Optional) {@link Query.order} to define the order
+ * 2. (Optional) {@link Query.filter} to refine the results
+ * 3. A *consumer* method to obtain the results
+ *
+ * Queries are lazily evaluated. No work is done until iteration begins, so constructing and
+ * extending a query is free. The query is executed incrementally as the results are iterated over,
+ * so early terminating also reduces the cost of the query.
+ *
+ * It is more efficient to use `filter` expression rather than executing JavaScript to filter.
+ *
+ * |                                              | |
+ * |----------------------------------------------|-|
+ * | **Ordering**                                 | |
+ * | [`order("asc")`](#order)                     | Define the order of query results. |
+ * |                                              | |
+ * | **Filtering**                                | |
+ * | [`filter(...)`](#filter)                     | Filter the query results to only the values that match some condition. |
+ * |                                              | |
+ * | **Consuming**                                | Execute a query and return results in different ways. |
+ * | [`[Symbol.asyncIterator]()`](#asynciterator) | The query's results can be iterated over using a `for await..of` loop. |
+ * | [`collect()`](#collect)                      | Return all of the results as an array. |
+ * | [`take(n: number)`](#take)                   | Return the first `n` results as an array. |
+ * | [`first()`](#first)                          | Return the first result. |
+ * | [`unique()`](#unique)                        | Return the only result, and throw if there is more than one result. |
+ *
+ * To learn more about how to write queries, see [Querying the Database](https://docs.convex.dev/using/database-queries).
+ *
+ * @public
+ */
+interface Query<TableInfo extends GenericTableInfo> extends OrderedQuery<TableInfo> {
+  /**
+   * Define the order of the query output.
+   *
+   * Use `"asc"` for an ascending order and `"desc"` for a descending order. If not specified, the order defaults to ascending.
+   * @param order - The order to return results in.
+   */
+  order(order: "asc" | "desc"): OrderedQuery<TableInfo>;
+}
+/**
+ * A {@link Query} with an order that has already been defined.
+ *
+ * @public
+ */
+interface OrderedQuery<TableInfo extends GenericTableInfo> extends AsyncIterable<DocumentByInfo<TableInfo>> {
+  /**
+   * Filter the query output, returning only the values for which `predicate` evaluates to true.
+   *
+   * @param predicate - An {@link Expression} constructed with the supplied {@link FilterBuilder} that specifies which documents to keep.
+   * @returns - A new {@link OrderedQuery} with the given filter predicate applied.
+   */
+  filter(predicate: (q: FilterBuilder<TableInfo>) => ExpressionOrValue<boolean>): this;
+  /**
+   * Load a page of `n` results and obtain a {@link Cursor} for loading more.
+   *
+   * Note: If this is called from a reactive query function the number of
+   * results may not match `paginationOpts.numItems`!
+   *
+   * `paginationOpts.numItems` is only an initial value. After the first invocation,
+   * `paginate` will return all items in the original query range. This ensures
+   * that all pages will remain adjacent and non-overlapping.
+   *
+   * @param paginationOpts - A {@link PaginationOptions} object containing the number
+   * of items to load and the cursor to start at.
+   * @returns A {@link PaginationResult} containing the page of results and a
+   * cursor to continue paginating.
+   */
+  paginate(paginationOpts: PaginationOptions): Promise<PaginationResult<DocumentByInfo<TableInfo>>>;
+  /**
+   * Execute the query and return all of the results as an array.
+   *
+   * Note: when processing a query with a lot of results, it's often better to use the `Query` as an
+   * `AsyncIterable` instead.
+   *
+   * @returns - An array of all of the query's results.
+   */
+  collect(): Promise<Array<DocumentByInfo<TableInfo>>>;
+  /**
+   * Execute the query and return the first `n` results.
+   *
+   * @param n - The number of items to take.
+   * @returns - An array of the first `n` results of the query (or less if the
+   * query doesn't have `n` results).
+   */
+  take(n: number): Promise<Array<DocumentByInfo<TableInfo>>>;
+  /**
+   * Execute the query and return the first result if there is one.
+   *
+   * @returns - The first value of the query or `null` if the query returned no results.
+   * */
+  first(): Promise<DocumentByInfo<TableInfo> | null>;
+  /**
+   * Execute the query and return the singular result if there is one.
+   *
+   * @returns - The single result returned from the query or null if none exists.
+   * @throws  Will throw an error if the query returns more than one result.
+   */
+  unique(): Promise<DocumentByInfo<TableInfo> | null>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/convex@1.27.0_react@19.2.3/node_modules/convex/dist/cjs-types/server/system_fields.d.ts
+/**
+ * The fields that Convex automatically adds to documents, not including `_id`.
+ *
+ * This is an object type mapping field name to field type.
+ * @public
+ */
+type SystemFields = {
+  _creationTime: number;
+};
+/**
+ * The `_id` field that Convex automatically adds to documents.
+ * @public
+ */
+type IdField<TableName extends string> = {
+  _id: Id<TableName>;
+};
+/**
+ * The indexes that Convex automatically adds to every table.
+ *
+ * This is an object mapping index names to index field paths.
+ * @public
+ */
+type SystemIndexes = {
+  by_id: ["_id"];
+  by_creation_time: ["_creationTime"];
+};
+/**
+ * Convex automatically appends "_creationTime" to the end of every index to
+ * break ties if all of the other fields are identical.
+ * @public
+ */
+type IndexTiebreakerField = "_creationTime";
+//#endregion
+//#region ../../node_modules/.pnpm/convex@1.27.0_react@19.2.3/node_modules/convex/dist/cjs-types/server/schema.d.ts
+/**
+ * Extract all of the index field paths within a {@link Validator}.
+ *
+ * This is used within {@link defineTable}.
+ * @public
+ */
+type ExtractFieldPaths<T extends Validator<any, any, any>> = T["fieldPaths"] | keyof SystemFields;
+/**
+ * Extract the {@link GenericDocument} within a {@link Validator} and
+ * add on the system fields.
+ *
+ * This is used within {@link defineTable}.
+ * @public
+ */
+type ExtractDocument<T extends Validator<any, any, any>> = Expand<SystemFields & T["type"]>;
+interface DbIndexConfig<FirstFieldPath extends string, RestFieldPaths extends string[]> {
+  /**
+   * The fields to index, in order. Must specify at least one field.
+   */
+  fields: [FirstFieldPath, ...RestFieldPaths];
+}
+/**
+ * The configuration for a full text search index.
+ *
+ * @public
+ */
+interface SearchIndexConfig<SearchField extends string, FilterFields extends string> {
+  /**
+   * The field to index for full text search.
+   *
+   * This must be a field of type `string`.
+   */
+  searchField: SearchField;
+  /**
+   * Additional fields to index for fast filtering when running search queries.
+   */
+  filterFields?: FilterFields[];
+}
+/**
+ * The configuration for a vector index.
+ *
+ * @public
+ */
+interface VectorIndexConfig<VectorField extends string, FilterFields extends string> {
+  /**
+   * The field to index for vector search.
+   *
+   * This must be a field of type `v.array(v.float64())` (or a union)
+   */
+  vectorField: VectorField;
+  /**
+   * The length of the vectors indexed. This must be between 2 and 2048 inclusive.
+   */
+  dimensions: number;
+  /**
+   * Additional fields to index for fast filtering when running vector searches.
+   */
+  filterFields?: FilterFields[];
+}
+/**
+ * Options for defining an index.
+ *
+ * @public
+ */
+interface IndexOptions {
+  /**
+   * Whether the index should be staged.
+   *
+   * For large tables, index backfill can be slow. Staging an index allows you
+   * to push the schema and enable the index later.
+   *
+   * If `staged` is `true`, the index will be staged and will not be enabled
+   * until the staged flag is removed. Staged indexes do not block push
+   * completion. Staged indexes cannot be used in queries.
+   */
+  staged?: boolean;
+}
+/**
+ * The definition of a table within a schema.
+ *
+ * This should be produced by using {@link defineTable}.
+ * @public
+ */
+declare class TableDefinition<DocumentType extends Validator<any, any, any> = Validator<any, any, any>, Indexes extends GenericTableIndexes = {}, SearchIndexes extends GenericTableSearchIndexes = {}, VectorIndexes extends GenericTableVectorIndexes = {}> {
+  private indexes;
+  private stagedDbIndexes;
+  private searchIndexes;
+  private stagedSearchIndexes;
+  private vectorIndexes;
+  private stagedVectorIndexes;
+  validator: DocumentType;
+  /**
+   * This API is experimental: it may change or disappear.
+   *
+   * Returns indexes defined on this table.
+   * Intended for the advanced use cases of dynamically deciding which index to use for a query.
+   * If you think you need this, please chime in on ths issue in the Convex JS GitHub repo.
+   * https://github.com/get-convex/convex-js/issues/49
+   */
+  " indexes"(): {
+    indexDescriptor: string;
+    fields: string[];
+  }[];
+  /**
+   * Define an index on this table.
+   *
+   * To learn about indexes, see [Defining Indexes](https://docs.convex.dev/using/indexes).
+   *
+   * @param name - The name of the index.
+   * @param indexConfig - The index configuration object.
+   * @returns A {@link TableDefinition} with this index included.
+   */
+  index<IndexName extends string, FirstFieldPath extends ExtractFieldPaths<DocumentType>, RestFieldPaths extends ExtractFieldPaths<DocumentType>[]>(name: IndexName, indexConfig: Expand<DbIndexConfig<FirstFieldPath, RestFieldPaths> & IndexOptions & {
+    staged?: false;
+  }>): TableDefinition<DocumentType, Expand<Indexes & Record<IndexName, [FirstFieldPath, ...RestFieldPaths, IndexTiebreakerField]>>, SearchIndexes, VectorIndexes>;
+  /**
+   * Define an index on this table.
+   *
+   * To learn about indexes, see [Defining Indexes](https://docs.convex.dev/using/indexes).
+   *
+   * @param name - The name of the index.
+   * @param fields - The fields to index, in order. Must specify at least one
+   * field.
+   * @returns A {@link TableDefinition} with this index included.
+   */
+  index<IndexName extends string, FirstFieldPath extends ExtractFieldPaths<DocumentType>, RestFieldPaths extends ExtractFieldPaths<DocumentType>[]>(name: IndexName, fields: [FirstFieldPath, ...RestFieldPaths]): TableDefinition<DocumentType, Expand<Indexes & Record<IndexName, [FirstFieldPath, ...RestFieldPaths, IndexTiebreakerField]>>, SearchIndexes, VectorIndexes>;
+  /**
+   * Define a staged index on this table.
+   *
+   * For large tables, index backfill can be slow. Staging an index allows you
+   * to push the schema and enable the index later.
+   *
+   * If `staged` is `true`, the index will be staged and will not be enabled
+   * until the staged flag is removed. Staged indexes do not block push
+   * completion. Staged indexes cannot be used in queries.
+   *
+   * To learn about indexes, see [Defining Indexes](https://docs.convex.dev/using/indexes).
+   *
+   * @param name - The name of the index.
+   * @param indexConfig - The index configuration object.
+   * @returns A {@link TableDefinition} with this index included.
+   */
+  index<IndexName extends string, FirstFieldPath extends ExtractFieldPaths<DocumentType>, RestFieldPaths extends ExtractFieldPaths<DocumentType>[]>(name: IndexName, indexConfig: Expand<DbIndexConfig<FirstFieldPath, RestFieldPaths> & IndexOptions & {
+    staged: true;
+  }>): TableDefinition<DocumentType, Indexes, SearchIndexes, VectorIndexes>;
+  /**
+   * Define a search index on this table.
+   *
+   * To learn about search indexes, see [Search](https://docs.convex.dev/text-search).
+   *
+   * @param name - The name of the index.
+   * @param indexConfig - The search index configuration object.
+   * @returns A {@link TableDefinition} with this search index included.
+   */
+  searchIndex<IndexName extends string, SearchField extends ExtractFieldPaths<DocumentType>, FilterFields extends ExtractFieldPaths<DocumentType> = never>(name: IndexName, indexConfig: Expand<SearchIndexConfig<SearchField, FilterFields> & IndexOptions & {
+    staged?: false;
+  }>): TableDefinition<DocumentType, Indexes, Expand<SearchIndexes & Record<IndexName, {
+    searchField: SearchField;
+    filterFields: FilterFields;
+  }>>, VectorIndexes>;
+  /**
+   * Define a staged search index on this table.
+   *
+   * For large tables, index backfill can be slow. Staging an index allows you
+   * to push the schema and enable the index later.
+   *
+   * If `staged` is `true`, the index will be staged and will not be enabled
+   * until the staged flag is removed. Staged indexes do not block push
+   * completion. Staged indexes cannot be used in queries.
+   *
+   * To learn about search indexes, see [Search](https://docs.convex.dev/text-search).
+   *
+   * @param name - The name of the index.
+   * @param indexConfig - The search index configuration object.
+   * @returns A {@link TableDefinition} with this search index included.
+   */
+  searchIndex<IndexName extends string, SearchField extends ExtractFieldPaths<DocumentType>, FilterFields extends ExtractFieldPaths<DocumentType> = never>(name: IndexName, indexConfig: Expand<SearchIndexConfig<SearchField, FilterFields> & IndexOptions & {
+    staged: true;
+  }>): TableDefinition<DocumentType, Indexes, SearchIndexes, VectorIndexes>;
+  /**
+   * Define a vector index on this table.
+   *
+   * To learn about vector indexes, see [Vector Search](https://docs.convex.dev/vector-search).
+   *
+   * @param name - The name of the index.
+   * @param indexConfig - The vector index configuration object.
+   * @returns A {@link TableDefinition} with this vector index included.
+   */
+  vectorIndex<IndexName extends string, VectorField extends ExtractFieldPaths<DocumentType>, FilterFields extends ExtractFieldPaths<DocumentType> = never>(name: IndexName, indexConfig: Expand<VectorIndexConfig<VectorField, FilterFields> & IndexOptions & {
+    staged?: false;
+  }>): TableDefinition<DocumentType, Indexes, SearchIndexes, Expand<VectorIndexes & Record<IndexName, {
+    vectorField: VectorField;
+    dimensions: number;
+    filterFields: FilterFields;
+  }>>>;
+  /**
+   * Define a staged vector index on this table.
+   *
+   * For large tables, index backfill can be slow. Staging an index allows you
+   * to push the schema and enable the index later.
+   *
+   * If `staged` is `true`, the index will be staged and will not be enabled
+   * until the staged flag is removed. Staged indexes do not block push
+   * completion. Staged indexes cannot be used in queries.
+   *
+   * To learn about vector indexes, see [Vector Search](https://docs.convex.dev/vector-search).
+   *
+   * @param name - The name of the index.
+   * @param indexConfig - The vector index configuration object.
+   * @returns A {@link TableDefinition} with this vector index included.
+   */
+  vectorIndex<IndexName extends string, VectorField extends ExtractFieldPaths<DocumentType>, FilterFields extends ExtractFieldPaths<DocumentType> = never>(name: IndexName, indexConfig: Expand<VectorIndexConfig<VectorField, FilterFields> & IndexOptions & {
+    staged: true;
+  }>): TableDefinition<DocumentType, Indexes, SearchIndexes, VectorIndexes>;
+  /**
+   * Work around for https://github.com/microsoft/TypeScript/issues/57035
+   */
+  protected self(): TableDefinition<DocumentType, Indexes, SearchIndexes, VectorIndexes>;
+}
+/**
+ * A type describing the schema of a Convex project.
+ *
+ * This should be constructed using {@link defineSchema}, {@link defineTable},
+ * and {@link v}.
+ * @public
+ */
+type GenericSchema = Record<string, TableDefinition>;
+/**
+ *
+ * The definition of a Convex project schema.
+ *
+ * This should be produced by using {@link defineSchema}.
+ * @public
+ */
+declare class SchemaDefinition<Schema extends GenericSchema, StrictTableTypes extends boolean> {
+  tables: Schema;
+  strictTableNameTypes: StrictTableTypes;
+  readonly schemaValidation: boolean;
+}
+/**
+ * Internal type used in Convex code generation!
+ *
+ * Convert a {@link SchemaDefinition} into a {@link server.GenericDataModel}.
+ *
+ * @public
+ */
+type DataModelFromSchemaDefinition<SchemaDef extends SchemaDefinition<any, boolean>> = MaybeMakeLooseDataModel<{ [TableName in keyof SchemaDef["tables"] & string]: SchemaDef["tables"][TableName] extends TableDefinition<infer DocumentType, infer Indexes, infer SearchIndexes, infer VectorIndexes> ? {
+  document: Expand<IdField<TableName> & ExtractDocument<DocumentType>>;
+  fieldPaths: keyof IdField<TableName> | ExtractFieldPaths<DocumentType>;
+  indexes: Expand<Indexes & SystemIndexes>;
+  searchIndexes: SearchIndexes;
+  vectorIndexes: VectorIndexes;
+} : never }, SchemaDef["strictTableNameTypes"]>;
+type MaybeMakeLooseDataModel<DataModel extends GenericDataModel, StrictTableNameTypes extends boolean> = StrictTableNameTypes extends true ? DataModel : Expand<DataModel & AnyDataModel>;
+declare const _systemSchema: SchemaDefinition<{
+  _scheduled_functions: TableDefinition<VObject<{
+    completedTime?: number | undefined;
+    name: string;
+    args: any[];
+    scheduledTime: number;
+    state: {
+      kind: "pending";
+    } | {
+      kind: "inProgress";
+    } | {
+      kind: "success";
+    } | {
+      kind: "failed";
+      error: string;
+    } | {
+      kind: "canceled";
+    };
+  }, {
+    name: VString<string, "required">;
+    args: VArray<any[], VAny<any, "required", string>, "required">;
+    scheduledTime: VFloat64<number, "required">;
+    completedTime: VFloat64<number | undefined, "optional">;
+    state: VUnion<{
+      kind: "pending";
+    } | {
+      kind: "inProgress";
+    } | {
+      kind: "success";
+    } | {
+      kind: "failed";
+      error: string;
+    } | {
+      kind: "canceled";
+    }, [VObject<{
+      kind: "pending";
+    }, {
+      kind: VLiteral<"pending", "required">;
+    }, "required", "kind">, VObject<{
+      kind: "inProgress";
+    }, {
+      kind: VLiteral<"inProgress", "required">;
+    }, "required", "kind">, VObject<{
+      kind: "success";
+    }, {
+      kind: VLiteral<"success", "required">;
+    }, "required", "kind">, VObject<{
+      kind: "failed";
+      error: string;
+    }, {
+      kind: VLiteral<"failed", "required">;
+      error: VString<string, "required">;
+    }, "required", "kind" | "error">, VObject<{
+      kind: "canceled";
+    }, {
+      kind: VLiteral<"canceled", "required">;
+    }, "required", "kind">], "required", "kind" | "error">;
+  }, "required", "name" | "args" | "scheduledTime" | "completedTime" | "state" | "state.kind" | "state.error">, {}, {}, {}>;
+  _storage: TableDefinition<VObject<{
+    contentType?: string | undefined;
+    sha256: string;
+    size: number;
+  }, {
+    sha256: VString<string, "required">;
+    size: VFloat64<number, "required">;
+    contentType: VString<string | undefined, "optional">;
+  }, "required", "sha256" | "size" | "contentType">, {}, {}, {}>;
+}, true>;
+interface SystemDataModel extends DataModelFromSchemaDefinition<typeof _systemSchema> {}
+//#endregion
+//#region ../../node_modules/.pnpm/convex@1.27.0_react@19.2.3/node_modules/convex/dist/cjs-types/server/database.d.ts
+interface BaseDatabaseReader<DataModel extends GenericDataModel> {
+  /**
+   * Fetch a single document from the database by its {@link values.GenericId}.
+   *
+   * @param id - The {@link values.GenericId} of the document to fetch from the database.
+   * @returns - The {@link GenericDocument} of the document at the given {@link values.GenericId}, or `null` if it no longer exists.
+   */
+  get<TableName extends TableNamesInDataModel<DataModel>>(id: Id<TableName>): Promise<DocumentByName<DataModel, TableName> | null>;
+  /**
+   * Begin a query for the given table name.
+   *
+   * Queries don't execute immediately, so calling this method and extending its
+   * query are free until the results are actually used.
+   *
+   * @param tableName - The name of the table to query.
+   * @returns - A {@link QueryInitializer} object to start building a query.
+   */
+  query<TableName extends TableNamesInDataModel<DataModel>>(tableName: TableName): QueryInitializer<NamedTableInfo<DataModel, TableName>>;
+  /**
+   * Returns the string ID format for the ID in a given table, or null if the ID
+   * is from a different table or is not a valid ID.
+   *
+   * This accepts the string ID format as well as the `.toString()` representation
+   * of the legacy class-based ID format.
+   *
+   * This does not guarantee that the ID exists (i.e. `db.get(id)` may return `null`).
+   *
+   * @param tableName - The name of the table.
+   * @param id - The ID string.
+   */
+  normalizeId<TableName extends TableNamesInDataModel<DataModel>>(tableName: TableName, id: string): Id<TableName> | null;
+}
+/**
+ * An interface to read from the database within Convex query functions.
+ *
+ * The two entry points are:
+ *   - {@link GenericDatabaseReader.get}, which fetches a single document
+ *     by its {@link values.GenericId}.
+ *   - {@link GenericDatabaseReader.query}, which starts building a query.
+ *
+ * If you're using code generation, use the `DatabaseReader` type in
+ * `convex/_generated/server.d.ts` which is typed for your data model.
+ *
+ * @public
+ */
+interface GenericDatabaseReader<DataModel extends GenericDataModel> extends BaseDatabaseReader<DataModel> {
+  /**
+   * An interface to read from the system tables within Convex query functions
+   *
+   * The two entry points are:
+   *   - {@link GenericDatabaseReader.get}, which fetches a single document
+   *     by its {@link values.GenericId}.
+   *   - {@link GenericDatabaseReader.query}, which starts building a query.
+   *
+   * @public
+   */
+  system: BaseDatabaseReader<SystemDataModel>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/convex@1.27.0_react@19.2.3/node_modules/convex/dist/cjs-types/server/api.d.ts
+/**
+ * The type of a Convex function.
+ *
+ * @public
+ */
+type FunctionType = "query" | "mutation" | "action";
+/**
+ * A reference to a registered Convex function.
+ *
+ * You can create a {@link FunctionReference} using the generated `api` utility:
+ * ```js
+ * import { api } from "../convex/_generated/api";
+ *
+ * const reference = api.myModule.myFunction;
+ * ```
+ *
+ * If you aren't using code generation, you can create references using
+ * {@link anyApi}:
+ * ```js
+ * import { anyApi } from "convex/server";
+ *
+ * const reference = anyApi.myModule.myFunction;
+ * ```
+ *
+ * Function references can be used to invoke functions from the client. For
+ * example, in React you can pass references to the {@link react.useQuery} hook:
+ * ```js
+ * const result = useQuery(api.myModule.myFunction);
+ * ```
+ *
+ * @typeParam Type - The type of the function ("query", "mutation", or "action").
+ * @typeParam Visibility - The visibility of the function ("public" or "internal").
+ * @typeParam Args - The arguments to this function. This is an object mapping
+ * argument names to their types.
+ * @typeParam ReturnType - The return type of this function.
+ * @public
+ */
+type FunctionReference<Type extends FunctionType, Visibility extends FunctionVisibility = "public", Args extends DefaultFunctionArgs = any, ReturnType = any, ComponentPath = string | undefined> = {
+  _type: Type;
+  _visibility: Visibility;
+  _args: Args;
+  _returnType: ReturnType;
+  _componentPath: ComponentPath;
+};
+/**
+ * A {@link FunctionReference} of any type and any visibility with any
+ * arguments and any return type.
+ *
+ * @public
+ */
+type AnyFunctionReference = FunctionReference<any, any>;
+/**
+ * A tuple type of the (maybe optional) arguments to `FuncRef`.
+ *
+ * This type is used to make methods involving arguments type safe while allowing
+ * skipping the arguments for functions that don't require arguments.
+ *
+ * @public
+ */
+type OptionalRestArgs<FuncRef extends AnyFunctionReference> = FuncRef["_args"] extends EmptyObject ? [args?: EmptyObject] : [args: FuncRef["_args"]];
+/**
+ * Given a {@link FunctionReference}, get the return type of the function.
+ *
+ * @public
+ */
+type FunctionReturnType<FuncRef extends AnyFunctionReference> = FuncRef["_returnType"];
+//#endregion
+//#region ../../node_modules/.pnpm/convex@1.27.0_react@19.2.3/node_modules/convex/dist/cjs-types/server/registration.d.ts
+/**
+ * A set of services for use within Convex query functions.
+ *
+ * The query context is passed as the first argument to any Convex query
+ * function run on the server.
+ *
+ * This differs from the {@link MutationCtx} because all of the services are
+ * read-only.
+ *
+ *
+ * @public
+ */
+interface GenericQueryCtx<DataModel extends GenericDataModel> {
+  /**
+   * A utility for reading data in the database.
+   */
+  db: GenericDatabaseReader<DataModel>;
+  /**
+   * Information about the currently authenticated user.
+   */
+  auth: Auth;
+  /**
+   * A utility for reading files in storage.
+   */
+  storage: StorageReader;
+  /**
+   * Call a query function within the same transaction.
+   *
+   * NOTE: often you can call the query's function directly instead of using this.
+   * `runQuery` incurs overhead of running argument and return value validation,
+   * and creating a new isolated JS context.
+   */
+  runQuery: <Query extends FunctionReference<"query", "public" | "internal">>(query: Query, ...args: OptionalRestArgs<Query>) => Promise<FunctionReturnType<Query>>;
+}
+/**
+ * The default arguments type for a Convex query, mutation, or action function.
+ *
+ * Convex functions always take an arguments object that maps the argument
+ * names to their values.
+ *
+ * @public
+ */
+type DefaultFunctionArgs = Record<string, unknown>;
+/**
+ * A type for the empty object `{}`.
+ *
+ * Note that we don't use `type EmptyObject = {}` because that matches every object.
+ */
+type EmptyObject = Record<string, never>;
+/**
+ * A type representing the visibility of a Convex function.
+ *
+ * @public
+ */
+type FunctionVisibility = "public" | "internal";
+//#endregion
+//#region ../../node_modules/.pnpm/convex@1.27.0_react@19.2.3/node_modules/convex/dist/cjs-types/server/storage.d.ts
+/**
+ * A reference to a file in storage.
+ *
+ * This is used in the {@link StorageReader} and {@link StorageWriter} which are accessible in
+ * Convex queries and mutations via {@link QueryCtx} and {@link MutationCtx} respectively.
+ *
+ * @public
+ */
+type StorageId = string;
+/**
+ * Metadata for a single file as returned by {@link StorageReader.getMetadata | storage.getMetadata}.
+ *
+ * @public
+ */
+type FileMetadata = {
+  /**
+   * ID for referencing the file (eg. via {@link StorageReader.getUrl | storage.getUrl})
+   */
+  storageId: StorageId;
+  /**
+   * Hex encoded sha256 checksum of file contents
+   */
+  sha256: string;
+  /**
+   * Size of the file in bytes
+   */
+  size: number;
+  /**
+   * ContentType of the file if it was provided on upload
+   */
+  contentType: string | null;
+};
+/**
+ * An interface to read files from storage within Convex query functions.
+ *
+ * @public
+ */
+interface StorageReader {
+  /**
+   * Get the URL for a file in storage by its `Id<"_storage">`.
+   *
+   * The GET response includes a standard HTTP Digest header with a sha256 checksum.
+   *
+   * @param storageId - The `Id<"_storage">` of the file to fetch from Convex storage.
+   * @returns - A url which fetches the file via an HTTP GET, or `null` if it no longer exists.
+   */
+  getUrl(storageId: Id<"_storage">): Promise<string | null>;
+  /**
+   * @deprecated Passing a string is deprecated, use `storage.getUrl(Id<"_storage">)` instead.
+   *
+   * Get the URL for a file in storage by its {@link StorageId}.
+   *
+   * The GET response includes a standard HTTP Digest header with a sha256 checksum.
+   *
+   * @param storageId - The {@link StorageId} of the file to fetch from Convex storage.
+   * @returns - A url which fetches the file via an HTTP GET, or `null` if it no longer exists.
+   */
+  getUrl<T extends StorageId>(storageId: T extends {
+    __tableName: any;
+  } ? never : T): Promise<string | null>;
+  /**
+   * @deprecated This function is deprecated, use `db.system.get(Id<"_storage">)` instead.
+   *
+   * Get metadata for a file.
+   *
+   * @param storageId - The `Id<"_storage">` of the file.
+   * @returns - A {@link FileMetadata} object if found or `null` if not found.
+   */
+  getMetadata(storageId: Id<"_storage">): Promise<FileMetadata | null>;
+  /**
+   * @deprecated This function is deprecated, use `db.system.get(Id<"_storage">)` instead.
+   *
+   * Get metadata for a file.
+   *
+   * @param storageId - The {@link StorageId} of the file.
+   * @returns - A {@link FileMetadata} object if found or `null` if not found.
+   */
+  getMetadata<T extends StorageId>(storageId: T extends {
+    __tableName: any;
+  } ? never : T): Promise<FileMetadata | null>;
+}
+//#endregion
+export { FunctionReference as n, UserIdentity as r, GenericQueryCtx as t };
+//# sourceMappingURL=storage-CKzvsBxG.d.ts.map