@depup/mongoose 9.1.3-depup.0

package/types/indexes.d.ts

@@ -0,0 +1,97 @@
+declare module 'mongoose' {
+  import mongodb = require('mongodb');
+
+  /**
+   * Makes the indexes in MongoDB match the indexes defined in every model's
+   * schema. This function will drop any indexes that are not defined in
+   * the model's schema except the `_id` index, and build any indexes that
+   * are in your schema but not in MongoDB.
+   */
+  function syncIndexes(options?: SyncIndexesOptions): Promise<ConnectionSyncIndexesResult>;
+
+  interface IndexManager {
+    /* Deletes all indexes that aren't defined in this model's schema. Used by `syncIndexes()`. Returns list of dropped index names. */
+    cleanIndexes(options?: { toDrop?: string[], hideIndexes?: boolean }): Promise<string[]>;
+
+    /**
+     * Similar to `ensureIndexes()`, except for it uses the [`createIndex`](https://mongodb.github.io/node-mongodb-native/4.9/classes/Collection.html#createIndex)
+     * function.
+     */
+    createIndexes(options?: mongodb.CreateIndexesOptions): Promise<void>;
+
+    /**
+     * Does a dry-run of Model.syncIndexes(), meaning that
+     * the result of this function would be the result of
+     * Model.syncIndexes().
+     */
+    diffIndexes(options?: Record<string, unknown>): Promise<IndexesDiff>
+
+    /**
+     * Sends `createIndex` commands to mongo for each index declared in the schema.
+     * The `createIndex` commands are sent in series.
+     */
+    ensureIndexes(options?: mongodb.CreateIndexesOptions): Promise<void>;
+
+    /**
+     * Lists the indexes currently defined in MongoDB. This may or may not be
+     * the same as the indexes defined in your schema depending on whether you
+     * use the [`autoIndex` option](/docs/guide.html#autoIndex) and if you
+     * build indexes manually.
+     */
+    listIndexes(): Promise<Array<any>>;
+
+    /**
+     * Makes the indexes in MongoDB match the indexes defined in this model's
+     * schema. This function will drop any indexes that are not defined in
+     * the model's schema except the `_id` index, and build any indexes that
+     * are in your schema but not in MongoDB.
+     */
+    syncIndexes(options?: SyncIndexesOptions): Promise<Array<string>>;
+  }
+
+  interface IndexesDiff {
+    /** Indexes that would be created in mongodb. */
+    toCreate: Array<any>
+    /** Indexes that would be dropped in mongodb. */
+    toDrop: Array<any>
+  }
+
+  type IndexDirection = 1 | -1 | '2d' | '2dsphere' | 'geoHaystack' | 'hashed' | 'text' | 'ascending' | 'asc' | 'descending' | 'desc';
+  type IndexDefinition = Record<string, IndexDirection>;
+
+  interface SyncIndexesOptions extends mongodb.CreateIndexesOptions {
+    continueOnError?: boolean;
+    hideIndexes?: boolean;
+  }
+  type ConnectionSyncIndexesResult = Record<string, OneCollectionSyncIndexesResult>;
+  type OneCollectionSyncIndexesResult = Array<string> & mongodb.MongoServerError;
+
+  type IndexOptions = Omit<mongodb.CreateIndexesOptions, 'expires' | 'weights' | 'unique'> & {
+    /**
+     * `expires` utilizes the `ms` module from [vercel](https://github.com/vercel/ms) allowing us to use a friendlier syntax:
+     *
+     * @example
+     * ```js
+     * const schema = new Schema({ prop1: Date });
+     *
+     * // expire in 24 hours
+     * schema.index({ prop1: 1 }, { expires: 60*60*24 })
+     *
+     * // expire in 24 hours
+     * schema.index({ prop1: 1 }, { expires: '24h' })
+     *
+     * // expire in 1.5 hours
+     * schema.index({ prop1: 1 }, { expires: '1.5h' })
+     *
+     * // expire in 7 days
+     * schema.index({ prop1: 1 }, { expires: '7d' })
+     * ```
+     */
+    expires?: number | string;
+    weights?: Record<string, number>;
+
+    unique?: boolean | [true, string]
+  };
+
+  type SearchIndexDescription = mongodb.SearchIndexDescription;
+}

package/types/inferhydrateddoctype.d.ts

@@ -0,0 +1,115 @@
+import {
+  IsPathRequired,
+  IsSchemaTypeFromBuiltinClass,
+  RequiredPaths,
+  OptionalPaths,
+  PathEnumOrString
+} from './inferschematype';
+import { UUID } from 'mongodb';
+
+declare module 'mongoose' {
+  export type InferHydratedDocTypeFromSchema<TSchema extends Schema<any>> = ObtainSchemaGeneric<TSchema, 'THydratedDocumentType'>;
+
+  /**
+   * Given a schema definition, returns the hydrated document type from the schema definition.
+   */
+  export type InferHydratedDocType<
+    DocDefinition,
+    TSchemaOptions extends Record<any, any> = DefaultSchemaOptions
+  > = Require_id<ApplySchemaOptions<{
+    [
+    K in keyof (RequiredPaths<DocDefinition, TSchemaOptions['typeKey']> &
+    OptionalPaths<DocDefinition, TSchemaOptions['typeKey']>)
+    ]: IsPathRequired<DocDefinition[K], TSchemaOptions['typeKey']> extends true
+      ? ObtainHydratedDocumentPathType<DocDefinition[K], TSchemaOptions['typeKey']>
+      : ObtainHydratedDocumentPathType<DocDefinition[K], TSchemaOptions['typeKey']> | null;
+  }, TSchemaOptions>>;
+
+  /**
+   * @summary Obtains schema Path type.
+   * @description Obtains Path type by separating path type from other options and calling {@link ResolveHydratedPathType}
+   * @param {PathValueType} PathValueType Document definition path type.
+   * @param {TypeKey} TypeKey A generic refers to document definition.
+   */
+  type ObtainHydratedDocumentPathType<
+    PathValueType,
+    TypeKey extends string = DefaultTypeKey
+  > = ResolveHydratedPathType<
+    TypeKey extends keyof PathValueType
+      ? TypeKey extends keyof PathValueType[TypeKey]
+        ? PathValueType
+        : PathValueType[TypeKey]
+      : PathValueType,
+    TypeKey extends keyof PathValueType
+      ? TypeKey extends keyof PathValueType[TypeKey]
+        ? {}
+        : Omit<PathValueType, TypeKey>
+      : {},
+    TypeKey,
+    HydratedDocTypeHint<PathValueType>
+  >;
+
+  /**
+   * @summary Allows users to optionally choose their own type for a schema field for stronger typing.
+   */
+  type HydratedDocTypeHint<T> = T extends { __hydratedDocTypeHint: infer U } ? U: never;
+
+  /**
+   * Same as inferSchemaType, except:
+   *
+   * 1. Replace `Types.DocumentArray` and `Types.Array` with vanilla `Array`
+   * 2. Replace `ObtainDocumentPathType` with `ObtainHydratedDocumentPathType`
+   * 3. Replace `ResolvePathType` with `ResolveHydratedPathType`
+   *
+   * @summary Resolve path type by returning the corresponding type.
+   * @param {PathValueType} PathValueType Document definition path type.
+   * @param {Options} Options Document definition path options except path type.
+   * @param {TypeKey} TypeKey A generic of literal string type. Refers to the property used for path type definition.
+   * @returns Type
+   */
+  type ResolveHydratedPathType<PathValueType, Options extends SchemaTypeOptions<PathValueType> = {}, TypeKey extends string = DefaultSchemaOptions['typeKey'], TypeHint = never> =
+    IsNotNever<TypeHint> extends true ? TypeHint
+    : PathValueType extends Schema<any, any, any, any, any, any, any, any, infer THydratedDocumentType> ?
+      THydratedDocumentType :
+        PathValueType extends AnyArray<infer Item> ?
+          IfEquals<Item, never, any[], Item extends Schema<infer EmbeddedRawDocType, any, any, any, any, any, any, any, infer EmbeddedHydratedDocType extends AnyObject, infer TSchemaDefition> ?
+            IsItRecordAndNotAny<EmbeddedRawDocType> extends true ?
+              Types.DocumentArray<EmbeddedRawDocType, Types.Subdocument<EmbeddedHydratedDocType['_id'], unknown, EmbeddedHydratedDocType> & EmbeddedHydratedDocType> :
+              Types.DocumentArray<InferRawDocType<TSchemaDefition>, Types.Subdocument<InferHydratedDocType<TSchemaDefition>['_id'], unknown, InferHydratedDocType<TSchemaDefition>> & InferHydratedDocType<TSchemaDefition>> :
+            Item extends Record<TypeKey, any> ?
+              Item[TypeKey] extends Function | String ?
+                Types.Array<ObtainHydratedDocumentPathType<Item, TypeKey>> :
+                Types.DocumentArray<
+                  InferRawDocType<Item>,
+                  Types.Subdocument<InferHydratedDocType<Item>['_id'], unknown, InferHydratedDocType<Item>> & InferHydratedDocType<Item>
+                >:
+              IsSchemaTypeFromBuiltinClass<Item> extends true ?
+                Types.Array<ResolveHydratedPathType<Item, { enum: Options['enum'] }, TypeKey>> :
+                IsItRecordAndNotAny<Item> extends true ?
+                  Item extends Record<string, never> ?
+                    Types.Array<ObtainHydratedDocumentPathType<Item, TypeKey>> :
+                    Types.DocumentArray<
+                      InferRawDocType<Item>,
+                      Types.Subdocument<InferHydratedDocType<Item>['_id'], unknown, InferHydratedDocType<Item>> & InferHydratedDocType<Item>
+                    > :
+                  Types.Array<ObtainHydratedDocumentPathType<Item, TypeKey>>
+          >
+    : PathValueType extends StringSchemaDefinition ? PathEnumOrString<Options['enum']>
+    : IfEquals<PathValueType, String> extends true ? PathEnumOrString<Options['enum']>
+    : PathValueType extends NumberSchemaDefinition ? Options['enum'] extends ReadonlyArray<any> ? Options['enum'][number] : number
+    : PathValueType extends DateSchemaDefinition ? NativeDate
+    : PathValueType extends BufferSchemaDefinition ? Buffer
+    : PathValueType extends BooleanSchemaDefinition ? boolean
+    : PathValueType extends ObjectIdSchemaDefinition ? Types.ObjectId
+    : PathValueType extends Decimal128SchemaDefinition ? Types.Decimal128
+    : PathValueType extends BigintSchemaDefinition ? bigint
+    : PathValueType extends UuidSchemaDefinition ? UUID
+    : PathValueType extends DoubleSchemaDefinition ? Types.Double
+    : PathValueType extends typeof Schema.Types.Mixed ? any
+    : PathValueType extends MapSchemaDefinition ? Map<string, ObtainHydratedDocumentPathType<Options['of']>>
+    : IfEquals<PathValueType, ObjectConstructor> extends true ? any
+    : PathValueType extends typeof SchemaType ? PathValueType['prototype']
+    : PathValueType extends ArrayConstructor ? Types.Array<any>
+    : PathValueType extends Record<string, any> ? InferHydratedDocType<PathValueType, { typeKey: TypeKey }>
+    : unknown;
+}

package/types/inferrawdoctype.d.ts

@@ -0,0 +1,135 @@
+import {
+  IsSchemaTypeFromBuiltinClass,
+  PathEnumOrString,
+  OptionalPaths,
+  RequiredPaths,
+  IsPathRequired
+} from './inferschematype';
+import { Binary, UUID } from 'mongodb';
+
+declare module 'mongoose' {
+  export type InferRawDocTypeFromSchema<TSchema extends Schema<any>> = IsItRecordAndNotAny<ObtainSchemaGeneric<TSchema, 'EnforcedDocType'>> extends true
+    ? ObtainSchemaGeneric<TSchema, 'EnforcedDocType'>
+    : FlattenMaps<SubdocsToPOJOs<ObtainSchemaGeneric<TSchema, 'DocType'>>>;
+
+  export type InferRawDocTypeWithout_id<
+    SchemaDefinition,
+    TSchemaOptions extends Record<any, any> = DefaultSchemaOptions,
+    TTransformOptions = { bufferToBinary: false }
+  > = ApplySchemaOptions<{
+    [
+    K in keyof (RequiredPaths<SchemaDefinition, TSchemaOptions['typeKey']> &
+    OptionalPaths<SchemaDefinition, TSchemaOptions['typeKey']>)
+    ]: IsPathRequired<SchemaDefinition[K], TSchemaOptions['typeKey']> extends true
+      ? ObtainRawDocumentPathType<SchemaDefinition[K], TSchemaOptions['typeKey'], TTransformOptions>
+      : ObtainRawDocumentPathType<SchemaDefinition[K], TSchemaOptions['typeKey'], TTransformOptions> | null;
+  }, TSchemaOptions>;
+
+  export type InferRawDocType<
+    SchemaDefinition,
+    TSchemaOptions extends Record<any, any> = DefaultSchemaOptions,
+    TTransformOptions = { bufferToBinary: false }
+  > = Require_id<InferRawDocTypeWithout_id<SchemaDefinition, TSchemaOptions, TTransformOptions>>;
+
+  /**
+   * @summary Allows users to optionally choose their own type for a schema field for stronger typing.
+   * Make sure to check for `any` because `T extends { __rawDocTypeHint: infer U }` will infer `unknown` if T is `any`.
+   */
+  type RawDocTypeHint<T> = IsAny<T> extends true ? never
+    : T extends { __rawDocTypeHint: infer U } ? U: never;
+
+  /**
+   * @summary Obtains schema Path type.
+   * @description Obtains Path type by separating path type from other options and calling {@link ResolveRawPathType}
+   * @param {PathValueType} PathValueType Document definition path type.
+   * @param {TypeKey} TypeKey A generic refers to document definition.
+   */
+   type ObtainRawDocumentPathType<
+     PathValueType,
+     TypeKey extends string = DefaultTypeKey,
+     TTransformOptions = { bufferToBinary: false }
+   > = ResolveRawPathType<
+     TypeKey extends keyof PathValueType ?
+       TypeKey extends keyof PathValueType[TypeKey] ?
+         PathValueType
+       : PathValueType[TypeKey]
+     : PathValueType,
+     TypeKey extends keyof PathValueType ?
+       TypeKey extends keyof PathValueType[TypeKey] ?
+         {}
+       : Omit<PathValueType, TypeKey>
+     : {},
+     TypeKey,
+     TTransformOptions,
+     RawDocTypeHint<PathValueType>
+   >;
+
+  type neverOrAny = ' ~neverOrAny~';
+
+  /**
+   * Same as inferSchemaType, except:
+   *
+   * 1. Replace `Types.DocumentArray` and `Types.Array` with vanilla `Array`
+   * 2. Replace `ObtainDocumentPathType` with `ObtainRawDocumentPathType`
+   * 3. Replace `ResolvePathType` with `ResolveRawPathType`
+   *
+   * @summary Resolve path type by returning the corresponding type.
+   * @param {PathValueType} PathValueType Document definition path type.
+   * @param {Options} Options Document definition path options except path type.
+   * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
+   * @returns Number, "Number" or "number" will be resolved to number type.
+   */
+   type ResolveRawPathType<
+       PathValueType,
+       Options extends SchemaTypeOptions<PathValueType> = {},
+       TypeKey extends string = DefaultSchemaOptions['typeKey'],
+       TTransformOptions = { bufferToBinary: false },
+       TypeHint = never
+     > =
+       IsNotNever<TypeHint> extends true ? TypeHint
+       : [PathValueType] extends [neverOrAny] ? PathValueType
+       : PathValueType extends Schema<infer RawDocType, any, any, any, any, any, any, any, any, infer TSchemaDefinition> ? IsItRecordAndNotAny<RawDocType> extends true ? RawDocType : InferRawDocType<TSchemaDefinition, DefaultSchemaOptions, TTransformOptions>
+       : PathValueType extends ReadonlyArray<infer Item> ?
+         IfEquals<Item, never> extends true ? any[]
+         : Item extends Schema<infer RawDocType, any, any, any, any, any, any, any, any, infer TSchemaDefinition> ?
+           // If Item is a schema, infer its type.
+           Array<IsItRecordAndNotAny<RawDocType> extends true ? RawDocType : InferRawDocType<TSchemaDefinition, DefaultSchemaOptions, TTransformOptions>>
+         : TypeKey extends keyof Item ?
+           Item[TypeKey] extends Function | String ?
+             // If Item has a type key that's a string or a callable, it must be a scalar,
+             // so we can directly obtain its path type.
+             ObtainRawDocumentPathType<Item, TypeKey, TTransformOptions>[]
+           : // If the type key isn't callable, then this is an array of objects, in which case
+             // we need to call InferRawDocType to correctly infer its type.
+             Array<InferRawDocType<Item, DefaultSchemaOptions, TTransformOptions>>
+         : IsSchemaTypeFromBuiltinClass<Item> extends true ? ResolveRawPathType<Item, { enum: Options['enum'] }, TypeKey, TTransformOptions>[]
+         : IsItRecordAndNotAny<Item> extends true ?
+           Item extends Record<string, never> ?
+             ObtainRawDocumentPathType<Item, TypeKey, TTransformOptions>[]
+           : Array<InferRawDocType<Item, DefaultSchemaOptions, TTransformOptions>>
+         : ObtainRawDocumentPathType<Item, TypeKey, TTransformOptions>[]
+       : PathValueType extends StringSchemaDefinition ? PathEnumOrString<Options['enum']>
+       : IfEquals<PathValueType, String> extends true ? PathEnumOrString<Options['enum']>
+       : PathValueType extends NumberSchemaDefinition ?
+         Options['enum'] extends ReadonlyArray<any> ?
+           Options['enum'][number]
+         : number
+       : PathValueType extends DateSchemaDefinition ? NativeDate
+       : PathValueType extends BufferSchemaDefinition ? (TTransformOptions extends { bufferToBinary: true } ? Binary : Buffer)
+       : PathValueType extends BooleanSchemaDefinition ? boolean
+       : PathValueType extends ObjectIdSchemaDefinition ? Types.ObjectId
+       : PathValueType extends Decimal128SchemaDefinition ? Types.Decimal128
+       : PathValueType extends BigintSchemaDefinition ? bigint
+       : PathValueType extends UuidSchemaDefinition ? Types.UUID
+       : PathValueType extends MapSchemaDefinition ? Record<string, ObtainRawDocumentPathType<Options['of'], TypeKey, TTransformOptions>>
+       : PathValueType extends DoubleSchemaDefinition ? Types.Double
+       : PathValueType extends UnionSchemaDefinition ?
+         ResolveRawPathType<Options['of'] extends ReadonlyArray<infer Item> ? Item : never>
+       : PathValueType extends ArrayConstructor ? any[]
+       : PathValueType extends typeof Schema.Types.Mixed ? any
+       : IfEquals<PathValueType, ObjectConstructor> extends true ? any
+       : IfEquals<PathValueType, {}> extends true ? any
+       : PathValueType extends typeof SchemaType ? PathValueType['prototype']
+       : PathValueType extends Record<string, any> ? InferRawDocType<PathValueType>
+       : unknown;
+}

package/types/inferschematype.d.ts

@@ -0,0 +1,337 @@
+import {
+  AnyArray,
+  BooleanSchemaDefinition,
+  BigintSchemaDefinition,
+  BufferSchemaDefinition,
+  DateSchemaDefinition,
+  Decimal128SchemaDefinition,
+  DefaultSchemaOptions,
+  DefaultTypeKey,
+  DoubleSchemaDefinition,
+  IfEquals,
+  InferSchemaType,
+  IsItRecordAndNotAny,
+  MapSchemaDefinition,
+  NumberSchemaDefinition,
+  ObjectIdSchemaDefinition,
+  ObtainDocumentType,
+  Schema,
+  SchemaType,
+  SchemaTypeOptions,
+  StringSchemaDefinition,
+  Types,
+  UnionSchemaDefinition,
+  UuidSchemaDefinition
+} from 'mongoose';
+
+declare module 'mongoose' {
+  /**
+   * @summary Obtains document schema type.
+   * @description Obtains document schema type from document Definition OR returns enforced schema type if it's provided.
+   * @param {DocDefinition} DocDefinition A generic equals to the type of document definition "provided in as first parameter in Schema constructor".
+   * @param {EnforcedDocType} EnforcedDocType A generic type enforced by user "provided before schema constructor".
+   * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
+   */
+  type ObtainDocumentType<
+    DocDefinition,
+    EnforcedDocType = any,
+    TSchemaOptions extends Record<any, any> = DefaultSchemaOptions
+  > =
+    IsItRecordAndNotAny<EnforcedDocType> extends true ? EnforcedDocType
+    : {
+        [K in keyof (RequiredPaths<DocDefinition, TSchemaOptions['typeKey']> &
+          OptionalPaths<DocDefinition, TSchemaOptions['typeKey']>)]: IsPathRequired<
+          DocDefinition[K],
+          TSchemaOptions['typeKey']
+        > extends true ?
+          ObtainDocumentPathType<DocDefinition[K], TSchemaOptions['typeKey']>
+        : ObtainDocumentPathType<DocDefinition[K], TSchemaOptions['typeKey']> | null;
+      };
+
+  /**
+   * @summary Obtains document schema type from Schema instance.
+   * @param {Schema} TSchema `typeof` a schema instance.
+   * @example
+   * const userSchema = new Schema({userName:String});
+   * type UserType = InferSchemaType<typeof userSchema>;
+   * // result
+   * type UserType = {userName?: string}
+   */
+  export type InferSchemaType<TSchema> = IfAny<TSchema, any, ObtainSchemaGeneric<TSchema, 'DocType'>>;
+
+  export type DefaultIdVirtual = { id: string };
+  export type AddDefaultId<DocType, TVirtuals, TSchemaOptions> = (DocType extends { id: any } ? TVirtuals : TSchemaOptions extends { id: false } ? TVirtuals : TVirtuals & { id: string });
+
+  /**
+   * @summary Obtains schema Generic type by using generic alias.
+   * @param {TSchema} TSchema A generic of schema type instance.
+   * @param {alias} alias Targeted generic alias.
+   */
+  type ObtainSchemaGeneric<
+    TSchema,
+    alias extends
+      | 'EnforcedDocType'
+      | 'M'
+      | 'TInstanceMethods'
+      | 'TQueryHelpers'
+      | 'TVirtuals'
+      | 'TStaticMethods'
+      | 'TSchemaOptions'
+      | 'DocType'
+      | 'THydratedDocumentType'
+      | 'TSchemaDefinition'
+      | 'TLeanResultType'
+  > =
+    TSchema extends (
+      Schema<
+        infer EnforcedDocType,
+        infer M,
+        infer TInstanceMethods,
+        infer TQueryHelpers,
+        infer TVirtuals,
+        infer TStaticMethods,
+        infer TSchemaOptions,
+        infer DocType,
+        infer THydratedDocumentType,
+        infer TSchemaDefinition,
+        infer TLeanResultType
+      >
+    ) ?
+      {
+        EnforcedDocType: EnforcedDocType;
+        M: M;
+        TInstanceMethods: IfEquals<TInstanceMethods, {}, TSchemaOptions extends { methods: infer M } ? M : {}, TInstanceMethods>;
+        TQueryHelpers: IfEquals<TQueryHelpers, {}, TSchemaOptions extends { query: infer Q } ? Q : {}, TQueryHelpers>;
+        TVirtuals: AddDefaultId<DocType, IfEquals<TVirtuals, {}, TSchemaOptions extends { virtuals: infer V } ? V : {}, TVirtuals>, TSchemaOptions>;
+        TStaticMethods: IfEquals<TStaticMethods, {}, TSchemaOptions extends { statics: infer S } ? S : {}, TStaticMethods>;
+        TSchemaOptions: TSchemaOptions;
+        DocType: DocType;
+        THydratedDocumentType: THydratedDocumentType;
+        TSchemaDefinition: TSchemaDefinition;
+        TLeanResultType: TLeanResultType;
+      }[alias]
+    : unknown;
+
+  type ResolveSchemaOptions<T> = MergeType<DefaultSchemaOptions, T>;
+
+  type ApplySchemaOptions<T, O = DefaultSchemaOptions> = ResolveTimestamps<T, O>;
+
+  type DefaultTimestampProps = {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+  };
+
+  type ResolveTimestamps<T, O> =
+    O extends { timestamps?: false } ? T
+    : O extends { timestamps: infer TimestampOptions } ?
+      TimestampOptions extends true ? T & DefaultTimestampProps
+      : TimestampOptions extends SchemaTimestampsConfig ?
+        Show<
+          T & {
+            [K in keyof TimestampOptions & keyof DefaultTimestampProps as TimestampOptions[K] extends true ? K
+            : TimestampOptions[K] & string]: NativeDate;
+          }
+        >
+      : T
+    : T;
+}
+
+type RequiredPropertyDefinition =
+  | {
+      required: true | string | [true, string | undefined] | { isRequired: true };
+    }
+  | ArrayConstructor
+  | any[];
+
+/**
+ * @summary Checks if a document path is required or optional.
+ * @param {P} P Document path.
+ * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
+ */
+type IsPathRequired<P, TypeKey extends string = DefaultTypeKey> =
+  P extends RequiredPropertyDefinition ? true
+  : P extends { required: boolean } ?
+    P extends { required: false } ?
+      false
+    : true
+  : P extends { default: undefined | null | ((...args: any[]) => undefined) | ((...args: any[]) => null) } ? false
+  : P extends { default: any } ? true
+  : P extends Record<TypeKey, ArrayConstructor | any[]> ? true
+  : false;
+
+// Internal type used to efficiently check for never or any types
+// can be efficiently checked like:
+// `[T] extends [neverOrAny] ? T : ...`
+// to avoid edge cases
+type neverOrAny = ' ~neverOrAny~';
+
+/**
+ * @summary A Utility to obtain schema's required path keys.
+ * @param {T} T A generic refers to document definition.
+ * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
+ * @returns required paths keys of document definition.
+ */
+type RequiredPathKeys<T, TypeKey extends string = DefaultTypeKey> = Exclude<keyof T, OptionalPathKeys<T, TypeKey>>;
+
+/**
+ * @summary A Utility to obtain schema's required paths.
+ * @param {T} T A generic refers to document definition.
+ * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
+ * @returns a record contains required paths with the corresponding type.
+ */
+type RequiredPaths<T, TypeKey extends string = DefaultTypeKey> = Pick<
+  { -readonly [K in keyof T]: T[K] },
+  RequiredPathKeys<T, TypeKey>
+>;
+
+/**
+ * @summary A Utility to obtain schema's optional path keys.
+ * @param {T} T A generic refers to document definition.
+ * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
+ * @returns optional paths keys of document definition.
+ */
+type OptionalPathKeys<T, TypeKey extends string = DefaultTypeKey> = {
+  [K in keyof T]: IsPathRequired<T[K], TypeKey> extends true ? never : K;
+}[keyof T];
+
+/**
+ * @summary A Utility to obtain schema's optional paths.
+ * @param {T} T A generic refers to document definition.
+ * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
+ * @returns a record contains optional paths with the corresponding type.
+ */
+type OptionalPaths<T, TypeKey extends string = DefaultTypeKey> = Pick<
+  { -readonly [K in keyof T]?: T[K] },
+  OptionalPathKeys<T, TypeKey>
+>;
+
+/**
+ * @summary Allows users to optionally choose their own type for a schema field for stronger typing.
+ */
+type TypeHint<T> = T extends { __typehint: infer U } ? U : never;
+
+/**
+ * @summary Obtains schema Path type.
+ * @description Obtains Path type by separating path type from other options and calling {@link ResolvePathType}
+ * @param {PathValueType} PathValueType Document definition path type.
+ * @param {TypeKey} TypeKey A generic refers to document definition.
+ */
+type ObtainDocumentPathType<PathValueType, TypeKey extends string = DefaultTypeKey> = ResolvePathType<
+  TypeKey extends keyof PathValueType ?
+    TypeKey extends keyof PathValueType[TypeKey] ?
+      PathValueType
+    : PathValueType[TypeKey]
+  : PathValueType,
+  TypeKey extends keyof PathValueType ?
+    TypeKey extends keyof PathValueType[TypeKey] ?
+      {}
+    : Omit<PathValueType, TypeKey>
+  : {},
+  TypeKey,
+  TypeHint<PathValueType>
+>;
+
+/**
+ * @param {T} T A generic refers to string path enums.
+ * @returns Path enum values type as literal strings or string.
+ */
+type PathEnumOrString<T extends SchemaTypeOptions<string>['enum']> =
+  T extends ReadonlyArray<infer E> ? E
+  : T extends { values: any } ? PathEnumOrString<T['values']>
+  : T extends Record<string, infer V> ? V
+  : string;
+
+type UnionToType<T extends readonly any[]> = T[number] extends infer U
+  ? ResolvePathType<U>
+  : never;
+
+type IsSchemaTypeFromBuiltinClass<T> =
+  T extends typeof String ? true
+  : unknown extends Buffer ? false
+  : T extends typeof Number ? true
+  : T extends typeof Boolean ? true
+  : T extends typeof Buffer ? true
+  : T extends typeof Schema.Types.ObjectId ? true
+  : T extends typeof Schema.Types.UUID ? true
+  : T extends typeof Schema.Types.Decimal128 ? true
+  : T extends typeof Schema.Types.Int32 ? true
+  : T extends typeof Schema.Types.String ? true
+  : T extends typeof Schema.Types.Number ? true
+  : T extends typeof Schema.Types.Date ? true
+  : T extends typeof Schema.Types.Double ? true
+  : T extends typeof Schema.Types.Boolean ? true
+  : T extends Types.ObjectId ? true
+  : T extends Types.Decimal128 ? true
+  : T extends NativeDate ? true
+  : T extends typeof Schema.Types.Mixed ? true
+  : T extends Types.UUID ? true
+  : T extends Buffer ? true
+  : false;
+
+/**
+ * @summary Resolve path type by returning the corresponding type.
+ * @param {PathValueType} PathValueType Document definition path type.
+ * @param {Options} Options Document definition path options except path type.
+ * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
+ * @returns Number, "Number" or "number" will be resolved to number type.
+ */
+type ResolvePathType<
+  PathValueType,
+  Options extends SchemaTypeOptions<PathValueType> = {},
+  TypeKey extends string = DefaultSchemaOptions['typeKey'],
+  TypeHint = never
+> = [TypeHint] extends [never]
+  ? PathValueType extends Schema ? InferSchemaType<PathValueType>
+  : PathValueType extends AnyArray<infer Item> ?
+    [Item] extends [never]
+      ? any[]
+      : Item extends Schema ?
+        // If Item is a schema, infer its type.
+        Types.DocumentArray<InferSchemaType<Item>>
+      : Item extends Record<TypeKey, any> ?
+        Item[TypeKey] extends Function | String ?
+          // If Item has a type key that's a string or a callable, it must be a scalar,
+          // so we can directly obtain its path type.
+          ObtainDocumentPathType<Item, TypeKey>[]
+        : // If the type key isn't callable, then this is an array of objects, in which case
+          // we need to call ObtainDocumentType to correctly infer its type.
+          Types.DocumentArray<ObtainDocumentType<Item, any, { typeKey: TypeKey }>>
+      : IsSchemaTypeFromBuiltinClass<Item> extends true ? ResolvePathType<Item, { enum: Options['enum'] }, TypeKey>[]
+      : IsItRecordAndNotAny<Item> extends true ?
+        Item extends Record<string, never> ?
+          ObtainDocumentPathType<Item, TypeKey>[]
+        : Types.DocumentArray<ObtainDocumentType<Item, any, { typeKey: TypeKey }>>
+      : ObtainDocumentPathType<Item, TypeKey>[]
+  : PathValueType extends StringSchemaDefinition ? PathEnumOrString<Options['enum']>
+  : IfEquals<PathValueType, String> extends true ? PathEnumOrString<Options['enum']>
+  : PathValueType extends NumberSchemaDefinition ?
+    Options['enum'] extends ReadonlyArray<any> ?
+      Options['enum'][number]
+    : number
+  : PathValueType extends DateSchemaDefinition ? NativeDate
+  : PathValueType extends UuidSchemaDefinition ? Types.UUID
+  : PathValueType extends BufferSchemaDefinition ? Buffer
+  : PathValueType extends BooleanSchemaDefinition ? boolean
+  : PathValueType extends ObjectIdSchemaDefinition ? Types.ObjectId
+  : PathValueType extends Decimal128SchemaDefinition ? Types.Decimal128
+  : PathValueType extends BigintSchemaDefinition ? bigint
+  : PathValueType extends DoubleSchemaDefinition ? Types.Double
+  : PathValueType extends MapSchemaDefinition ? Map<string, ObtainDocumentPathType<Options['of']>>
+  : PathValueType extends UnionSchemaDefinition ?
+    Options['of'] extends AnyArray<infer U> ? ResolvePathType<U>
+    : never
+  : PathValueType extends ArrayConstructor ? any[]
+  : PathValueType extends typeof Schema.Types.Mixed ? any
+  : PathValueType extends ObjectConstructor ? any
+  : IfEquals<PathValueType, {}> extends true ? any
+  : PathValueType extends typeof SchemaType ? PathValueType['prototype']
+  : PathValueType extends Record<string, any> ?
+    ObtainDocumentType<
+      PathValueType,
+      any,
+      {
+        typeKey: TypeKey;
+      }
+    >
+  : unknown
+  : TypeHint;