@zodmon/core 0.7.0 → 0.8.0

package/dist/index.d.ts

@@ -252,17 +252,132 @@ type InferInsert<TDef extends {
 /**
  * The immutable definition object returned by collection().
  * Holds everything needed to later create a live collection handle.
+ *
+ * @typeParam TShape - The Zod shape defining document fields.
+ * @typeParam TIndexes - The compound indexes array type, preserving literal name types.
  */
-type CollectionDefinition<TShape extends z.core.$ZodShape = z.core.$ZodShape> = {
+type CollectionDefinition<TShape extends z.core.$ZodShape = z.core.$ZodShape, TIndexes extends readonly CompoundIndexDefinition<Extract<keyof TShape, string>>[] = readonly CompoundIndexDefinition<Extract<keyof TShape, string>>[]> = {
     readonly name: string;
     readonly schema: z.ZodObject<ResolvedShape<TShape>>;
     readonly shape: TShape;
     readonly fieldIndexes: FieldIndexDefinition[];
-    readonly compoundIndexes: CompoundIndexDefinition<Extract<keyof TShape, string>>[];
+    readonly compoundIndexes: TIndexes;
     readonly options: Required<Pick<CollectionOptions, 'validation'>> & Omit<CollectionOptions, 'indexes' | 'validation'>;
 };
 /** Erased collection type for use in generic contexts. */
 type AnyCollection = CollectionDefinition<z.core.$ZodShape>;
+/**
+ * Extract declared index names from a collection definition.
+ *
+ * Walks the `compoundIndexes` tuple and extracts the literal `name` string
+ * from each index that declared one via `.name()`. Falls back to `string`
+ * when no compound indexes have names, allowing any string as a hint.
+ *
+ * @example
+ * ```ts
+ * const Users = collection('users', { email: z.string() }, {
+ *   indexes: [
+ *     index({ email: 1 }).name('email_idx'),
+ *   ],
+ * })
+ * type Names = IndexNames<typeof Users> // 'email_idx'
+ * ```
+ */
+type IndexNames<TDef extends {
+    readonly compoundIndexes: readonly {
+        options?: {
+            name?: string;
+        };
+    }[];
+}> = ExtractNames<TDef['compoundIndexes']> extends never ? string : ExtractNames<TDef['compoundIndexes']>;
+/** @internal Helper that extracts the `name` literal from each index in a tuple. */
+type ExtractNames<T extends readonly {
+    options?: {
+        name?: string;
+    };
+}[]> = {
+    [K in keyof T]: T[K] extends {
+        readonly options: {
+            readonly name: infer N;
+        };
+    } ? N extends string ? N : never : never;
+}[number];
+
+/**
+ * Options controlling how {@link syncIndexes} behaves.
+ *
+ * @example
+ * ```ts
+ * await users.syncIndexes({ dryRun: true })
+ * await users.syncIndexes({ dropOrphaned: true })
+ * ```
+ */
+type SyncIndexesOptions = {
+    /**
+     * When `true`, compute the diff without actually creating, dropping, or
+     * modifying any indexes. The returned {@link SyncIndexesResult} shows what
+     * *would* happen.
+     */
+    dryRun?: boolean;
+    /**
+     * When `true`, drop indexes that exist in MongoDB but are not declared in
+     * the schema. Also drops and recreates stale indexes (same key, different
+     * options). When `false` (the default), orphaned and stale indexes are
+     * reported but left untouched.
+     */
+    dropOrphaned?: boolean;
+};
+/**
+ * Describes an index whose key matches a desired index but whose options differ.
+ *
+ * Returned in {@link SyncIndexesResult.stale} so the caller can decide whether
+ * to manually reconcile or re-run with `dropOrphaned: true`.
+ *
+ * @example
+ * ```ts
+ * const result = await users.syncIndexes()
+ * for (const s of result.stale) {
+ *   console.log(`${s.name}: key=${JSON.stringify(s.key)}`)
+ *   console.log(`  existing=${JSON.stringify(s.existing)}`)
+ *   console.log(`  desired=${JSON.stringify(s.desired)}`)
+ * }
+ * ```
+ */
+type StaleIndex = {
+    /** The MongoDB index name (e.g. `'email_1'`). */
+    name: string;
+    /** The index key spec (e.g. `{ email: 1 }`). */
+    key: Record<string, 1 | -1 | 'text'>;
+    /** The relevant options currently set on the existing index. */
+    existing: Record<string, unknown>;
+    /** The options the schema declares for this index. */
+    desired: Record<string, unknown>;
+};
+/**
+ * The result of a {@link syncIndexes} call.
+ *
+ * Every array contains index names. `stale` contains full details so the
+ * caller can inspect the mismatch.
+ *
+ * @example
+ * ```ts
+ * const result = await users.syncIndexes()
+ * console.log('created:', result.created)
+ * console.log('dropped:', result.dropped)
+ * console.log('skipped:', result.skipped)
+ * console.log('stale:', result.stale.map(s => s.name))
+ * ```
+ */
+type SyncIndexesResult = {
+    /** Names of indexes that were created (or would be created in dryRun mode). */
+    created: string[];
+    /** Names of indexes that were dropped (or would be dropped in dryRun mode). */
+    dropped: string[];
+    /** Names of indexes that already existed with matching options — no action taken. */
+    skipped: string[];
+    /** Indexes whose key matches a desired spec but whose options differ. */
+    stale: StaleIndex[];
+};
 
 /**
  * Comparison operators for a field value of type `V`.
@@ -554,7 +669,7 @@ type TypedSort<T> = Partial<Record<keyof T & string, 1 | -1>>;
 /**
  * Type-safe cursor wrapping MongoDB's `FindCursor`.
  *
- * Provides chainable query modifiers (`sort`, `skip`, `limit`) that return
+ * Provides chainable query modifiers (`sort`, `skip`, `limit`, `hint`) that return
  * `this` for fluent chaining, and terminal methods (`toArray`,
  * `[Symbol.asyncIterator]`) that validate each document against the
  * collection's Zod schema before returning.
@@ -562,6 +677,7 @@ type TypedSort<T> = Partial<Record<keyof T & string, 1 | -1>>;
  * Created by {@link find} — do not construct directly.
  *
  * @typeParam TDef - The collection definition type, used to infer the document type.
+ * @typeParam TIndexNames - Union of declared index names accepted by `.hint()`.
  *
  * @example
  * ```ts
@@ -571,7 +687,7 @@ type TypedSort<T> = Partial<Record<keyof T & string, 1 | -1>>;
  *   .toArray()
  * ```
  */
-declare class TypedFindCursor<TDef extends AnyCollection> {
+declare class TypedFindCursor<TDef extends AnyCollection, TIndexNames extends string = string> {
     /** @internal */
     private cursor;
     /** @internal */
@@ -627,6 +743,26 @@ declare class TypedFindCursor<TDef extends AnyCollection> {
      * ```
      */
     limit(n: number): this;
+    /**
+     * Force the query optimizer to use the specified index.
+     *
+     * Only accepts index names that were declared via `.name()` in the
+     * collection definition. If no named indexes exist, any string is accepted.
+     *
+     * @param indexName - The name of a declared compound index.
+     * @returns `this` for chaining.
+     *
+     * @example
+     * ```ts
+     * const Users = collection('users', { email: z.string(), role: z.string() }, {
+     *   indexes: [index({ email: 1, role: -1 }).name('email_role_idx')],
+     * })
+     * const admins = await users.find({ role: 'admin' })
+     *   .hint('email_role_idx')
+     *   .toArray()
+     * ```
+     */
+    hint(indexName: TIndexNames): this;
     /**
      * Execute the query with offset-based pagination, returning a page of documents
      * with total count and navigation metadata.
@@ -794,7 +930,7 @@ type FindOptions = {
  * }
  * ```
  */
-declare function find<TDef extends AnyCollection>(handle: CollectionHandle<TDef>, filter: TypedFilter<InferDocument<TDef>>, options?: FindOptions): TypedFindCursor<TDef>;
+declare function find<TDef extends AnyCollection>(handle: CollectionHandle<TDef>, filter: TypedFilter<InferDocument<TDef>>, options?: FindOptions): TypedFindCursor<TDef, IndexNames<TDef>>;
 
 /**
  * Extracts the element type from an array type.
@@ -1220,7 +1356,7 @@ declare class CollectionHandle<TDef extends AnyCollection = AnyCollection> {
      *   .toArray()
      * ```
      */
-    find(filter: TypedFilter<InferDocument<TDef>>, options?: FindOptions): TypedFindCursor<TDef>;
+    find(filter: TypedFilter<InferDocument<TDef>>, options?: FindOptions): TypedFindCursor<TDef, IndexNames<TDef>>;
     /**
      * Update a single document matching the filter.
      *
@@ -1342,6 +1478,34 @@ declare class CollectionHandle<TDef extends AnyCollection = AnyCollection> {
      * ```
      */
     findOneAndDelete(filter: TypedFilter<InferDocument<TDef>>, options?: FindOneAndDeleteOptions): Promise<InferDocument<TDef> | null>;
+    /**
+     * Synchronize the indexes declared in this collection's schema with MongoDB.
+     *
+     * Compares the desired indexes (from field-level `.index()` / `.unique()` /
+     * `.text()` / `.expireAfter()` and compound `indexes` in collection options)
+     * with the indexes that currently exist in MongoDB, then creates, drops, or
+     * reports differences depending on the options.
+     *
+     * @param options - Optional sync behavior (dryRun, dropOrphaned).
+     * @returns A summary of created, dropped, skipped, and stale indexes.
+     *
+     * @example
+     * ```ts
+     * const users = db.use(Users)
+     * const result = await users.syncIndexes()
+     * console.log('Created:', result.created)
+     * console.log('Stale:', result.stale.map(s => s.name))
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Dry run to preview changes without modifying the database
+     * const diff = await users.syncIndexes({ dryRun: true })
+     * console.log('Would create:', diff.created)
+     * console.log('Would drop:', diff.dropped)
+     * ```
+     */
+    syncIndexes(options?: SyncIndexesOptions): Promise<SyncIndexesResult>;
 }
 
 /**
@@ -1376,13 +1540,28 @@ declare class Database {
      * @param def - A collection definition created by `collection()`.
      * @returns A typed collection handle for CRUD operations.
      */
-    use<TShape extends z.core.$ZodShape>(def: CollectionDefinition<TShape>): CollectionHandle<CollectionDefinition<TShape>>;
+    use<TShape extends z.core.$ZodShape, TIndexes extends readonly CompoundIndexDefinition<Extract<keyof TShape, string>>[] = readonly CompoundIndexDefinition<Extract<keyof TShape, string>>[]>(def: CollectionDefinition<TShape, TIndexes>): CollectionHandle<CollectionDefinition<TShape, TIndexes>>;
     /**
-     * Synchronize indexes defined in registered collections with MongoDB.
+     * Synchronize indexes for all registered collections with MongoDB.
+     *
+     * Iterates every collection registered via {@link use} and calls
+     * {@link syncIndexes} on each one. Returns a record keyed by collection
+     * name with the sync result for each.
+     *
+     * @param options - Optional sync behavior (dryRun, dropOrphaned).
+     * @returns A record mapping collection names to their sync results.
      *
-     * Stub — full implementation in TASK-92.
+     * @example
+     * ```ts
+     * const db = createClient('mongodb://localhost:27017', 'myapp')
+     * db.use(Users)
+     * db.use(Posts)
+     * const results = await db.syncIndexes()
+     * console.log(results['users'].created) // ['email_1']
+     * console.log(results['posts'].created) // ['title_1']
+     * ```
      */
-    syncIndexes(): Promise<void>;
+    syncIndexes(options?: SyncIndexesOptions): Promise<Record<string, SyncIndexesResult>>;
     /**
      * Execute a function within a MongoDB transaction with auto-commit/rollback.
      *
@@ -1457,7 +1636,9 @@ declare function extractFieldIndexes(shape: z.core.$ZodShape): FieldIndexDefinit
  * })
  * ```
  */
-declare function collection<TShape extends z.core.$ZodShape>(name: string, shape: TShape, options?: CollectionOptions<Extract<keyof TShape, string>>): CollectionDefinition<TShape>;
+declare function collection<TShape extends z.core.$ZodShape, const TIndexes extends readonly CompoundIndexDefinition<Extract<keyof TShape, string>>[] = readonly CompoundIndexDefinition<Extract<keyof TShape, string>>[]>(name: string, shape: TShape, options?: Omit<CollectionOptions<Extract<keyof TShape, string>>, 'indexes'> & {
+    indexes?: TIndexes;
+}): CollectionDefinition<TShape, [...TIndexes]>;
 
 type IndexDirection = 1 | -1;
 type CompoundIndexOptions = NonNullable<CompoundIndexDefinition['options']>;
@@ -1485,9 +1666,27 @@ declare class IndexBuilder<TKeys extends string> {
     readonly options: CompoundIndexOptions;
     constructor(fields: Record<TKeys, IndexDirection>);
     private _clone;
-    unique(): IndexBuilder<TKeys>;
-    sparse(): IndexBuilder<TKeys>;
-    name(name: string): IndexBuilder<TKeys>;
+    unique(): this;
+    sparse(): this;
+    /**
+     * Set a custom name for this index, preserving the literal type.
+     *
+     * The returned builder carries the literal name type via an intersection,
+     * enabling type-safe `.hint()` on cursors that only accepts declared names.
+     *
+     * @param name - The index name.
+     * @returns A new IndexBuilder with the name recorded at the type level.
+     *
+     * @example
+     * ```ts
+     * index({ email: 1, role: -1 }).name('email_role_idx')
+     * ```
+     */
+    name<TName extends string>(name: TName): IndexBuilder<TKeys> & {
+        readonly options: {
+            readonly name: TName;
+        };
+    };
 }
 /**
  * Create a compound index definition with a fluent builder API.
@@ -1652,6 +1851,231 @@ declare function oid(value: ObjectId): ObjectId;
  */
 declare function isOid(value: unknown): value is ObjectId;
 
+/**
+ * A normalized index specification ready for comparison and creation.
+ *
+ * `key` maps field paths to direction (`1`, `-1`, or `'text'`).
+ * `options` holds MongoDB index options (`unique`, `sparse`, etc.).
+ *
+ * @example
+ * ```ts
+ * const spec: IndexSpec = {
+ *   key: { email: 1 },
+ *   options: { unique: true },
+ * }
+ * ```
+ */
+type IndexSpec = {
+    key: Record<string, 1 | -1 | 'text'>;
+    options: Record<string, unknown>;
+};
+/**
+ * Convert a field-level index definition to a normalized {@link IndexSpec}.
+ *
+ * Maps schema metadata (`text`, `descending`, `unique`, `sparse`, `expireAfter`,
+ * `partial`) to their MongoDB driver equivalents.
+ *
+ * @param def - A field index definition extracted from schema metadata.
+ * @returns A normalized index spec with key and options.
+ *
+ * @example
+ * ```ts
+ * const spec = toFieldIndexSpec({ field: 'email', indexed: true, unique: true })
+ * // => { key: { email: 1 }, options: { unique: true } }
+ *
+ * const ttl = toFieldIndexSpec({ field: 'expiresAt', indexed: true, expireAfter: 3600 })
+ * // => { key: { expiresAt: 1 }, options: { expireAfterSeconds: 3600 } }
+ * ```
+ */
+declare function toFieldIndexSpec(def: FieldIndexDefinition): IndexSpec;
+/**
+ * Convert a compound index definition to a normalized {@link IndexSpec}.
+ *
+ * Copies the `fields` map directly to `key` and maps builder options
+ * (`unique`, `sparse`, `name`, `partial`) to MongoDB driver equivalents.
+ *
+ * @param def - A compound index definition from the collection options.
+ * @returns A normalized index spec with key and options.
+ *
+ * @example
+ * ```ts
+ * const spec = toCompoundIndexSpec({
+ *   fields: { email: 1, role: -1 },
+ *   options: { unique: true, name: 'email_role_idx' },
+ * })
+ * // => { key: { email: 1, role: -1 }, options: { unique: true, name: 'email_role_idx' } }
+ * ```
+ */
+declare function toCompoundIndexSpec(def: CompoundIndexDefinition): IndexSpec;
+/**
+ * Produce a stable, deterministic string from an index key for comparison.
+ *
+ * Entries are sorted alphabetically by field name and formatted as
+ * `field:direction` pairs joined by commas. Two index keys that should be
+ * considered the same will always produce the same string.
+ *
+ * @param key - An index key mapping field names to direction.
+ * @returns A string like `'email:1,role:-1'`.
+ *
+ * @example
+ * ```ts
+ * serializeIndexKey({ email: 1, role: -1 })
+ * // => 'email:1,role:-1'
+ *
+ * serializeIndexKey({ name: 'text' })
+ * // => 'name:text'
+ * ```
+ */
+declare function serializeIndexKey(key: Record<string, 1 | -1 | 'text'>): string;
+
+/**
+ * Structural constraint for the handle argument of {@link syncIndexes}.
+ *
+ * Uses a structural type rather than `CollectionHandle<AnyCollection>` to avoid
+ * TypeScript variance issues with `exactOptionalPropertyTypes`. Any collection
+ * handle returned by `db.use()` satisfies this constraint.
+ */
+type SyncableHandle = {
+    readonly definition: {
+        readonly fieldIndexes: FieldIndexDefinition[];
+        readonly compoundIndexes: readonly CompoundIndexDefinition[];
+    };
+    readonly native: Collection<any>;
+};
+/**
+ * Extract the comparable options from a MongoDB index info object.
+ *
+ * Pulls only the keys listed in {@link COMPARABLE_OPTION_KEYS} from the raw
+ * index info returned by `listIndexes()`. Keys whose value is `undefined`
+ * are omitted so that JSON comparison works correctly.
+ *
+ * @param info - A raw MongoDB index info object.
+ * @returns A plain object with only the relevant option keys.
+ *
+ * @example
+ * ```ts
+ * const opts = extractComparableOptions({ v: 2, unique: true, key: { email: 1 } })
+ * // => { unique: true }
+ * ```
+ */
+declare function extractComparableOptions(info: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Generate the default MongoDB index name from a key spec.
+ *
+ * MongoDB names indexes by joining `field_direction` pairs with underscores.
+ * For example, `{ email: 1, role: -1 }` becomes `'email_1_role_-1'`.
+ *
+ * @param key - An index key mapping field names to direction.
+ * @returns The generated index name string.
+ *
+ * @example
+ * ```ts
+ * generateIndexName({ email: 1 })
+ * // => 'email_1'
+ *
+ * generateIndexName({ email: 1, role: -1 })
+ * // => 'email_1_role_-1'
+ * ```
+ */
+declare function generateIndexName(key: Record<string, 1 | -1 | 'text'>): string;
+/**
+ * Synchronize the indexes declared in a collection's schema with MongoDB.
+ *
+ * Compares the desired indexes (from field-level and compound index definitions)
+ * with the indexes that currently exist in MongoDB, then creates, drops, or
+ * reports differences depending on the options.
+ *
+ * **Algorithm:**
+ * 1. Build desired specs from field indexes and compound indexes.
+ * 2. Fetch existing indexes from MongoDB via `listIndexes()`.
+ * 3. For each desired spec, compare against existing:
+ *    - Missing → create (unless `dryRun`).
+ *    - Present with same options → skip.
+ *    - Present with different options → stale (or drop+recreate if `dropOrphaned`).
+ * 4. For each existing index not in desired set (excluding `_id_`):
+ *    - If `dropOrphaned` → drop (unless `dryRun`).
+ * 5. Return a summary of all actions taken.
+ *
+ * @param handle - A collection handle created by `db.use()`.
+ * @param options - Optional sync behavior (dryRun, dropOrphaned).
+ * @returns A summary of created, dropped, skipped, and stale indexes.
+ *
+ * @example
+ * ```ts
+ * import { syncIndexes } from '@zodmon/core'
+ *
+ * const users = db.use(Users)
+ * const result = await syncIndexes(users)
+ * console.log('Created:', result.created)
+ * console.log('Stale:', result.stale.map(s => s.name))
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Dry run — no changes made
+ * const diff = await syncIndexes(users, { dryRun: true })
+ * console.log('Would create:', diff.created)
+ * console.log('Would drop:', diff.dropped)
+ * ```
+ */
+declare function syncIndexes(handle: SyncableHandle, options?: SyncIndexesOptions): Promise<SyncIndexesResult>;
+
+/**
+ * Structural constraint for the definition argument of {@link checkUnindexedFields}.
+ *
+ * Uses a structural type rather than `CollectionDefinition<z.core.$ZodShape>` to avoid
+ * TypeScript variance issues with `exactOptionalPropertyTypes`. Any collection
+ * definition returned by `collection()` satisfies this constraint.
+ */
+type WarnableDefinition = {
+    readonly name: string;
+    readonly fieldIndexes: FieldIndexDefinition[];
+    readonly compoundIndexes: readonly CompoundIndexDefinition[];
+    readonly options: {
+        warnUnindexedQueries?: boolean;
+    };
+};
+/**
+ * Warn about unindexed fields used in a query filter.
+ *
+ * When `warnUnindexedQueries` is enabled on a collection definition, this
+ * function checks each top-level field in the filter against the collection's
+ * declared indexes. Fields that are not covered by any index produce a
+ * `console.warn` message to help identify queries that may cause full
+ * collection scans in development.
+ *
+ * **Covered fields:**
+ * - `_id` (always indexed by MongoDB)
+ * - Fields with `.index()`, `.unique()`, `.text()`, or `.expireAfter()` (field-level indexes)
+ * - The **first** field of each compound index (prefix matching)
+ *
+ * **Skipped keys:**
+ * - MongoDB operators: `$or`, `$and`, `$nor`, `$text`, `$where`, `$expr`, `$comment`
+ *
+ * This function is a no-op (zero overhead) when `warnUnindexedQueries` is not
+ * explicitly set to `true`.
+ *
+ * @param definition - The collection definition containing index metadata.
+ * @param filter - The query filter to check for unindexed fields.
+ *
+ * @example
+ * ```ts
+ * import { collection, checkUnindexedFields } from '@zodmon/core'
+ *
+ * const Users = collection('users', {
+ *   email: z.string().unique(),
+ *   name: z.string(),
+ * }, { warnUnindexedQueries: true })
+ *
+ * // No warning — email is indexed
+ * checkUnindexedFields(Users, { email: 'ada@example.com' })
+ *
+ * // Warns: "[zodmon] warn: query on 'users' uses unindexed field 'name'"
+ * checkUnindexedFields(Users, { name: 'Ada' })
+ * ```
+ */
+declare function checkUnindexedFields(definition: WarnableDefinition, filter: Record<string, unknown>): void;
+
 /**
  * Convenience namespace that groups all query operators under a single import.
  *
@@ -2038,4 +2462,4 @@ type UpdateFilterOf<TDef extends AnyCollection> = TypedUpdateFilter<InferDocumen
  */
 type SortOf<TDef extends AnyCollection> = TypedSort<InferDocument<TDef>>;
 
-export { $, $and, $eq, $exists, $gt, $gte, $in, $lt, $lte, $ne, $nin, $nor, $not, $or, $regex, type AddToSetEach, type AddToSetFields, type AnyCollection, type ArrayElement, type CollectionDefinition, CollectionHandle, type CollectionOptions, type ComparisonOperators, type CompoundIndexDefinition, type CurrentDateFields, type CursorPage, type CursorPaginateOptions, Database, type DotPathType, type DotPaths, type FieldIndexDefinition, type FilterOf, type FindOneAndDeleteOptions, type FindOneAndUpdateOptions, type FindOneOptions, type FindOptions, type HandleOf, type IncFields, IndexBuilder, type IndexMetadata, type IndexOptions, type InferDocument, type InferInsert, type OffsetPage, type OffsetPaginateOptions, type PopFields, type PullFields, type PushFields, type PushModifiers, type RefMarker, type RefMetadata, type RenameFields, type ResolvedShape, type SetFields, type SortOf, type TypedFilter, TypedFindCursor, type TypedSort, type TypedUpdateFilter, type UnsetFields, type UpdateFilterOf, type UpdateOptions, type ValidationMode, type ZodObjectId, ZodmonNotFoundError, ZodmonValidationError, collection, createClient, deleteMany, deleteOne, extractDbName, extractFieldIndexes, find, findOne, findOneAndDelete, findOneAndUpdate, findOneOrThrow, getIndexMetadata, getRefMetadata, index, insertMany, insertOne, isOid, objectId, oid, raw, updateMany, updateOne };
+export { $, $and, $eq, $exists, $gt, $gte, $in, $lt, $lte, $ne, $nin, $nor, $not, $or, $regex, type AddToSetEach, type AddToSetFields, type AnyCollection, type ArrayElement, type CollectionDefinition, CollectionHandle, type CollectionOptions, type ComparisonOperators, type CompoundIndexDefinition, type CurrentDateFields, type CursorPage, type CursorPaginateOptions, Database, type DotPathType, type DotPaths, type FieldIndexDefinition, type FilterOf, type FindOneAndDeleteOptions, type FindOneAndUpdateOptions, type FindOneOptions, type FindOptions, type HandleOf, type IncFields, IndexBuilder, type IndexMetadata, type IndexNames, type IndexOptions, type IndexSpec, type InferDocument, type InferInsert, type OffsetPage, type OffsetPaginateOptions, type PopFields, type PullFields, type PushFields, type PushModifiers, type RefMarker, type RefMetadata, type RenameFields, type ResolvedShape, type SetFields, type SortOf, type StaleIndex, type SyncIndexesOptions, type SyncIndexesResult, type TypedFilter, TypedFindCursor, type TypedSort, type TypedUpdateFilter, type UnsetFields, type UpdateFilterOf, type UpdateOptions, type ValidationMode, type ZodObjectId, ZodmonNotFoundError, ZodmonValidationError, checkUnindexedFields, collection, createClient, deleteMany, deleteOne, extractComparableOptions, extractDbName, extractFieldIndexes, find, findOne, findOneAndDelete, findOneAndUpdate, findOneOrThrow, generateIndexName, getIndexMetadata, getRefMetadata, index, insertMany, insertOne, isOid, objectId, oid, raw, serializeIndexKey, syncIndexes, toCompoundIndexSpec, toFieldIndexSpec, updateMany, updateOne };