@mongorm/orm 0.1.1-beta.1 → 0.1.1-beta.2

package/dist/index.d.mts

@@ -0,0 +1,414 @@
+import { Collection, Condition, Db as Db$1, DeleteResult, Document, FindCursor, IndexDescription, IndexDirection, MongoClientOptions, ObjectId, ObjectId as ObjectId$1, RootFilterOperators, WithId } from "mongodb";
+import { z } from "zod";
+//#region src/schema/inference.d.ts
+/** The raw parsed shape produced by a schema before persistence fields are added. */
+type InferShape<T> = T extends {
+  definition: infer Definition extends z.ZodType;
+} ? z.infer<Definition> : never;
+/** The input type accepted by a schema before Zod defaults are applied. */
+type InferInput<T> = T extends {
+  definition: infer Definition extends z.ZodType;
+} ? z.input<Definition> : never;
+/** The persisted document type inferred from a schema. */
+type Infer<T> = InferShape<T> & {
+  _id: ObjectId$1;
+};
+//#endregion
+//#region src/schema/contracts.d.ts
+/** A Zod object shape used as the source of truth for a model. */
+type SchemaShape = z.ZodRawShape;
+/** The runtime Zod object generated from a schema shape. */
+type SchemaDefinition<Shape extends SchemaShape> = z.ZodObject<Shape>;
+//#endregion
+//#region src/model/model.d.ts
+type CreateInput<Shape extends SchemaShape, Options extends SchemaOptions> = Omit<InferInput<Schema<Shape, {}, {}, Options>>, '_id'>;
+type UpdateInput<Shape extends SchemaShape, Options extends SchemaOptions> = Partial<Omit<InferInput<Schema<Shape, {}, {}, Options>>, '_id'>>;
+type ModelDocument$1<Shape extends SchemaShape, Relations extends SchemaRelationMap, Scopes extends ScopeDefinitions, Options extends SchemaOptions> = Infer<Schema<Shape, Relations, Scopes, Options>>;
+/** A MongoDB collection with CRUD operations derived from a schema. */
+export declare class Model<Shape extends SchemaShape, Relations extends SchemaRelationMap = {}, Scopes extends ScopeDefinitions = {}, Options extends SchemaOptions = {}> {
+  private readonly db;
+  readonly name: string;
+  private readonly schema;
+  readonly bulk: {
+    create: (inputs: readonly CreateInput<Shape, Options>[]) => Promise<ModelDocument$1<Shape, Relations, Scopes, Options>[]>;
+  };
+  readonly restore: SoftDeleteEnabled<Options> extends true ? (filter: ModelFilter<Shape>) => Promise<Infer<Schema<Shape, Relations, Scopes, Options>> | null> : never;
+  readonly purge: SoftDeleteEnabled<Options> extends true ? (filter: ModelFilter<Shape>) => Promise<DeleteResult> : never;
+  /** Create a model bound to a database collection and schema. */
+  constructor(db: Db, name: string, schema: Schema<Shape, Relations, Scopes, Options>);
+  private get collection();
+  private activeFilter;
+  /** Validate and insert one document, generating its ObjectId. */
+  create(input: CreateInput<Shape, Options>): Promise<ModelDocument$1<Shape, Relations, Scopes, Options>>;
+  private prepareDocument;
+  private bulkCreate;
+  /** Build a query for all documents matching a MongoDB filter. */
+  find(filter?: ModelFilter<Shape>): ModelQuery<Shape, VisibleDocument<Shape>, true, Relations, Scopes, 'none', SoftDeleteEnabled<Options>>;
+  /** Validate and apply a partial update to the first matching document. */
+  update(filter: ModelFilter<Shape>, patch: UpdateInput<Shape, Options>): Promise<Infer<Schema<Shape, Relations, Scopes, Options>> | null>;
+  /** Restore matching soft-deleted documents. */
+  private restoreDocument;
+  /** Delete every document matching a MongoDB filter. */
+  delete(filter: ModelFilter<Shape>): Promise<DeleteResult>;
+  /** Permanently delete matching documents, including soft-deleted documents. */
+  private purgeDocuments;
+}
+//#endregion
+//#region src/connection/database.d.ts
+type SchemaRegistry = Record<string, SchemaLike>;
+/** Configuration for a MongoDB connection. */
+interface DbOptions<Registry extends SchemaRegistry = SchemaRegistry> {
+  /** MongoDB connection string. */
+  uri: string;
+  /** Logical database name. */
+  database: string;
+  /** Optional native MongoDB client options. */
+  clientOptions?: MongoClientOptions;
+  /** Schemas registered as plural database model properties. */
+  schema?: Registry;
+}
+type ModelForSchema<SchemaType> = SchemaType extends Schema<infer Shape, infer Relations, infer Scopes, infer Options> ? Model<Shape, Relations, Scopes, Options> : never;
+type DatabaseModels<Registry extends SchemaRegistry> = { readonly [Name in keyof Registry]: ModelForSchema<Registry[Name]>; };
+type RegistryOfBuilder<Builder extends {
+  readonly __registry?: SchemaRegistry;
+}> = NonNullable<Builder['__registry']>;
+/** Owns a MongoDB client and creates schema-bound models. */
+export declare class Db<Registry extends SchemaRegistry = SchemaRegistry> {
+  private readonly options;
+  private readonly client;
+  private database;
+  private readonly schemaCollections;
+  /** Create a disconnected database handle. */
+  constructor(options: DbOptions<Registry>);
+  /** Connect to MongoDB and select the configured database. */
+  connect(): Promise<void>;
+  /** Close the MongoDB client and release its resources. */
+  disconnect(): Promise<void>;
+  /** Create a model bound to a MongoDB collection and schema. */
+  model<Shape extends SchemaShape, Relations extends SchemaRelationMap, Scopes extends ScopeDefinitions, Options extends SchemaOptions>(name: string, schema: Schema<Shape, Relations, Scopes, Options>): Model<Shape, Relations, Scopes, Options>;
+  private registerSchema;
+  /** Resolve a registered schema to its MongoDB collection. */
+  collectionFor(schema: SchemaLike): Collection<Document>;
+  /** Explicitly create all indexes declared by registered schemas. */
+  sync(): Promise<Record<string, string[]>>;
+  /** Return the selected database, failing if `connect()` was not called. */
+  get native(): Db$1;
+}
+/** Create a disconnected MongoDB database handle. */
+export declare function createDatabase<const Registry extends SchemaRegistry>(options: DbOptions<Registry> & {
+  schema: Registry;
+}): Db<Registry> & DatabaseModels<Registry>;
+export declare function createDatabase<const Builder extends {
+  readonly __registry?: SchemaRegistry;
+}>(options: Omit<DbOptions<RegistryOfBuilder<Builder>>, 'schema'> & {
+  schema: Builder;
+}): Db<RegistryOfBuilder<Builder>> & DatabaseModels<RegistryOfBuilder<Builder>>;
+export declare function createDatabase(options: DbOptions): Db;
+//#endregion
+//#region src/query/cursor.d.ts
+/** A lazy async iterable for one cursor-pagination page. */
+export declare class ModelCursor<Shape extends SchemaShape, Result extends object> implements AsyncIterable<Result> {
+  private readonly open;
+  private readonly pageSize;
+  private readonly transform?;
+  next: ObjectId$1 | null;
+  constructor(open: () => FindCursor<WithId<StoredDocument<Shape>>>, pageSize: number, transform?: ((documents: Result[]) => Promise<Result[]>) | undefined);
+  [Symbol.asyncIterator](): AsyncGenerator<Result>;
+}
+//#endregion
+//#region src/query/types.d.ts
+type StoredDocument<Shape extends SchemaShape> = Infer<Schema<Shape>> & Document;
+type ModelFilterForDocument<DocumentShape extends Document, FieldShape extends object = DocumentShape> = Partial<{ [Key in keyof FieldShape]: Condition<FieldShape[Key]>; }> & Partial<Pick<RootFilterOperators<DocumentShape>, '$comment' | '$expr' | '$jsonSchema' | '$text' | '$where'>> & {
+  $and?: ModelFilterForDocument<DocumentShape, FieldShape>[];
+  $nor?: ModelFilterForDocument<DocumentShape, FieldShape>[];
+  $or?: ModelFilterForDocument<DocumentShape, FieldShape>[];
+};
+type ModelFilter<Shape extends SchemaShape> = ModelFilterForDocument<StoredDocument<Shape>, Infer<Schema<Shape>>>;
+type SortDirection = 'asc' | 'desc';
+type ModelSort<Shape extends SchemaShape> = Partial<Record<Extract<keyof Infer<Schema<Shape>>, string>, SortDirection>>;
+type ModelDocument<Shape extends SchemaShape> = Infer<Schema<Shape>>;
+type HiddenKey<Shape extends SchemaShape> = { [Key in keyof Shape]: Shape[Key] extends {
+  readonly __hidden: true;
+} ? Key : never; }[keyof Shape];
+type HiddenDocumentKey<Shape extends SchemaShape> = Extract<HiddenKey<Shape>, keyof ModelDocument<Shape>> & string;
+type NestedDocumentKeys<Value, Prefix extends string = ''> = Value extends object ? Value extends ObjectId$1 | Date ? never : { [Key in Extract<keyof Value, string>]: NonNullable<Value[Key]> extends object ? `${Prefix}${Key}` | `${Prefix}${Key}.${NestedDocumentKeys<NonNullable<Value[Key]>>}` : `${Prefix}${Key}`; }[Extract<keyof Value, string>] : never;
+type NestedSelectableKey<Shape extends SchemaShape> = { [Key in Extract<keyof Shape, string>]: Key extends keyof ModelDocument<Shape> ? NonNullable<ModelDocument<Shape>[Key]> extends object ? `${Key}.${NestedDocumentKeys<NonNullable<ModelDocument<Shape>[Key]>>}` : never : never; }[Extract<keyof Shape, string>];
+type CursorMethod<Shape extends SchemaShape, Result extends object, Ready extends boolean> = Ready extends true ? (after?: ObjectId$1) => ModelCursor<Shape, Result> : undefined;
+type SelectableKey<Shape extends SchemaShape> = Exclude<Extract<keyof ModelDocument<Shape>, string>, '_id' | HiddenDocumentKey<Shape>> | NestedSelectableKey<Shape>;
+type PathSelection<Value, Path extends string> = Path extends `${infer Head}.${infer Tail}` ? Head extends keyof Value ? { [Key in Head]: PathSelection<NonNullable<Value[Key]>, Tail>; } : never : Path extends keyof Value ? Pick<Value, Path> : never;
+type UnionToIntersection<Value> = (Value extends unknown ? (input: Value) => void : never) extends ((input: infer Intersection) => void) ? Intersection : never;
+type Simplify<Value> = { [Key in keyof Value]: Value[Key]; };
+type VisibleDocument<Shape extends SchemaShape> = Omit<ModelDocument<Shape>, Extract<HiddenKey<Shape>, keyof ModelDocument<Shape>>>;
+type SelectedDocument<Shape extends SchemaShape, Key extends SelectableKey<Shape>> = [Key] extends [never] ? VisibleDocument<Shape> : Simplify<Pick<ModelDocument<Shape>, '_id'> & UnionToIntersection<PathSelection<ModelDocument<Shape>, Extract<Key, string>>>>;
+type RelationTarget<Relation> = Relation extends {
+  resolve: () => infer Target;
+} ? Target : never;
+type RelationDocument<Relation> = RelationTarget<Relation> extends Schema<infer TargetShape, any> ? Infer<Schema<TargetShape>> : never;
+type RelationMapOf$1<Relation> = RelationTarget<Relation> extends {
+  readonly relationMap: infer TargetRelations;
+} ? TargetRelations extends SchemaRelationMap ? TargetRelations : {} : {};
+type ScopeName<Scopes> = Extract<keyof Scopes, string>;
+type PopulationMode = 'none' | 'populate' | 'scope';
+type RelationSelect<Relation> = RelationTarget<Relation> extends Schema<infer TargetShape, any> ? Exclude<SelectableKey<TargetShape>, '_id'> : never;
+type PopulateSpec<Relations extends SchemaRelationMap> = { [Name in Extract<keyof Relations, string>]: {
+  ref: Name;
+  select?: readonly RelationSelect<Relations[Name]>[];
+  populate?: PopulateSpecs<RelationMapOf$1<Relations[Name]>>;
+}; }[Extract<keyof Relations, string>];
+type PopulateSpecs<Relations extends SchemaRelationMap> = readonly PopulateSpec<Relations>[];
+type PopulatedResult<Result extends object, Relations extends SchemaRelationMap, Specs extends PopulateSpecs<Relations>> = Omit<Result, Extract<Specs[number]['ref'], keyof Result>> & { [Spec in Specs[number] as Spec['ref']]: PopulatedRelation<Relations[Spec['ref']], Spec> | null; };
+type PopulatedRelation<Relation, Spec> = Spec extends {
+  populate: infer Nested extends PopulateSpecs<RelationMapOf$1<Relation>>;
+} ? RelationDocument<Relation> extends (infer PopulatedDocument extends object) ? PopulatedResult<PopulatedDocument, RelationMapOf$1<Relation>, Nested> : never : RelationDocument<Relation>;
+//#endregion
+//#region src/query/many-query.d.ts
+/** A typed, awaitable MongoDB find query. */
+export declare class ModelQuery<Shape extends SchemaShape, Result extends object = VisibleDocument<Shape>, CursorReady extends boolean = true, Relations extends SchemaRelationMap = {}, Scopes extends ScopeDefinitions = {}, Mode extends PopulationMode = 'none', SoftDelete extends boolean = false> implements PromiseLike<Result[]> {
+  private readonly collection;
+  private readonly filterSpec;
+  private readonly fields;
+  private readonly hiddenFields;
+  private readonly db;
+  private readonly relations;
+  private readonly scopes;
+  private readonly softdeleteEnabled;
+  readonly deleted: SoftDelete extends true ? (mode: 'only' | 'include') => this : never;
+  private sortSpec;
+  private skipCount;
+  private limitCount;
+  private selectedFields;
+  private shownFields;
+  private populateSpecs;
+  private populationMode;
+  private readonly softDelete;
+  private readonly population;
+  readonly cursor: CursorMethod<Shape, Result, CursorReady>;
+  constructor(collection: Collection<StoredDocument<Shape>>, filterSpec: ModelFilter<Shape>, fields: readonly string[], hiddenFields: readonly string[], db: Db, relations: Relations, scopes: Scopes, softdeleteEnabled: boolean);
+  /** Include both active and soft-deleted documents in this query. */
+  private deletedMode;
+  private effectiveFilter;
+  /** Sort results by one or more schema fields. */
+  sort(spec: ModelSort<Shape>): ModelQuery<Shape, Result, false, Relations, Scopes, Mode, SoftDelete>;
+  /** Skip a non-negative number of matching documents. */
+  skip(count: number): ModelQuery<Shape, Result, false, Relations, Scopes, Mode, SoftDelete>;
+  /** Limit the number of matching documents returned. */
+  limit(count: number): this;
+  /** Return only selected fields, while retaining MongoDB's default `_id`. */
+  select<Keys extends SelectableKey<Shape> = never>(fields?: readonly Keys[]): ModelQuery<Shape, SelectedDocument<Shape, Keys>, CursorReady, Relations, Scopes, Mode, SoftDelete>;
+  /** Include hidden fields in the query result. */
+  show<Keys extends HiddenDocumentKey<Shape>>(fields: readonly Keys[]): ModelQuery<Shape, Result & Pick<ModelDocument<Shape>, Keys>, CursorReady, Relations, Scopes, Mode, SoftDelete>;
+  /** Populate declared one-way relations, including nested relation arrays. */
+  populate<Specs extends PopulateSpecs<Relations>>(this: Mode extends 'scope' ? never : ModelQuery<Shape, Result, CursorReady, Relations, Scopes, Mode, SoftDelete>, specs: Specs): ModelQuery<Shape, PopulatedResult<Result, Relations, Specs>, CursorReady, Relations, Scopes, 'populate', SoftDelete>;
+  /** Apply a named population scope. */
+  with<Name extends ScopeName<Scopes>>(this: Mode extends 'populate' ? never : ModelQuery<Shape, Result, CursorReady, Relations, Scopes, Mode, SoftDelete>, name: Name): ModelQuery<Shape, PopulatedResult<Result, Relations, Scopes[Name] & PopulateSpecs<Relations>>, CursorReady, Relations, Scopes, 'scope', SoftDelete>;
+  /** Count matching documents, optionally using MongoDB's collection estimate. */
+  count(estimate?: boolean): Promise<number>;
+  /** Return one `_id`-ordered page and the cursor for the next page. */
+  private createCursor;
+  private execute;
+  first(): Promise<Result | null>;
+  private createQueryCursor;
+  then<TResult1 = Result[], TResult2 = never>(onfulfilled?: ((value: Result[]) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+}
+//#endregion
+//#region src/schema/schema.d.ts
+/** Built-in persistence behavior applied by a schema. */
+interface SchemaOptions {
+  readonly timestamps?: boolean;
+  readonly softdelete?: boolean;
+}
+type SchemaIndexFields<Shape extends SchemaShape> = Partial<Record<Extract<keyof Shape, string>, IndexDirection>>;
+type SchemaIndex<Shape extends SchemaShape> = {
+  readonly fields: SchemaIndexFields<Shape>;
+  readonly options?: Omit<IndexDescription, 'key'>;
+};
+type TimestampShape = {
+  createdAt: z.ZodDefault<z.ZodDate>;
+  updatedAt: z.ZodDefault<z.ZodDate>;
+};
+type SoftDeleteShape = {
+  deletedAt: z.ZodDefault<z.ZodNullable<z.ZodDate>>;
+};
+type ManagedShape<Options extends SchemaOptions> = (Options['timestamps'] extends true ? TimestampShape : {}) & (Options['softdelete'] extends true ? SoftDeleteShape : {});
+type ManagedField<Options extends SchemaOptions> = (Options['timestamps'] extends true ? 'createdAt' | 'updatedAt' : never) | (Options['softdelete'] extends true ? 'deletedAt' : never);
+type SoftDeleteEnabled<Options extends SchemaOptions> = Options['softdelete'] extends true ? true : false;
+export declare const hasSoftDelete: (options: SchemaOptions) => boolean;
+type ObjectIdFieldKeys<Shape extends SchemaShape> = { [Key in keyof InferShape<Schema<Shape>>]-?: NonNullable<InferShape<Schema<Shape>>[Key]> extends ObjectId$1 ? Key : never; }[keyof InferShape<Schema<Shape>>];
+type ScopeDefinitions = Record<string, readonly object[]>;
+/** A typed, runtime-validated schema definition. */
+export declare class Schema<Shape extends SchemaShape, Relations extends SchemaRelationMap = {}, Scopes extends ScopeDefinitions = {}, Options extends SchemaOptions = {}> {
+  /** The underlying Zod object for advanced validation use cases. */
+  readonly definition: SchemaDefinition<Shape>;
+  /** The lazily resolved relation metadata declared by this schema. */
+  readonly refs: RelationMap<Shape>;
+  /** One-way relation metadata declared for this schema. */
+  readonly relationMap: Relations;
+  /** Named population scopes declared for this schema. */
+  scopeMap: Scopes;
+  /** Field names excluded from default query results. */
+  readonly hiddenFields: readonly (keyof Shape & string)[];
+  /** Field names declared by this schema. */
+  readonly fields: readonly (keyof Shape & string)[];
+  /** Persistence behavior enabled for this schema. */
+  readonly optionsConfig: Options;
+  /** MongoDB indexes declared for this schema. */
+  indexDefinitions: readonly SchemaIndex<Shape>[];
+  /** Preserve schema options through registry type transformations. */
+  readonly __options: Options;
+  /** Construct a schema from a Zod object shape. */
+  constructor(shape: Shape, relations?: Relations, scopeMap?: Scopes, optionsConfig?: Options, indexDefinitions?: readonly SchemaIndex<Shape>[]);
+  /** Enable managed timestamps and/or soft deletion for this schema. */
+  options<const Enabled extends SchemaOptions>(options: Enabled): Schema<Shape & ManagedShape<Enabled>, Relations, Scopes, Enabled>;
+  /** Declare MongoDB indexes for explicit synchronization with the database. */
+  indexes<const Definitions extends readonly SchemaIndex<Shape>[]>(definitions: Definitions): this;
+  /** Add one or more one-way relations without requiring circular schema declarations. */
+  relations<const Definitions extends Partial<Record<Extract<ObjectIdFieldKeys<Shape>, string>, RelationInput>>>(definitions: Definitions & Record<Exclude<keyof Definitions, Extract<ObjectIdFieldKeys<Shape>, string>>, never>): Schema<Shape, Relations & { [Name in keyof Definitions]: SchemaRelation<RelationInputTarget<NonNullable<Definitions[Name]>>, Extract<Name, string>, NonNullable<Definitions[Name]> extends {
+    foreignField: infer Foreign extends string;
+  } ? Foreign : '_id'>; }, Scopes, Options>;
+  /** Declare named, reusable population scopes. */
+  scopes<const Definitions extends Record<string, PopulateSpecs<Relations>>>(definitions: Definitions): Schema<Shape, Relations, Definitions, Options>;
+  /** Parse unknown input and return the inferred document type. */
+  parse(input: unknown): InferShape<this>;
+  /** Parse a partial document for update operations. */
+  parsePartial(input: unknown): Partial<InferShape<this>>;
+  /** Parse unknown input without throwing on validation failure. */
+  safeParse(input: unknown): ReturnType<typeof this.definition.safeParse>;
+}
+//#endregion
+//#region src/relations/definitions.d.ts
+/** A schema-like target resolved lazily to support circular module imports. */
+type SchemaLike = Schema<SchemaShape, any, any, any>;
+/** Metadata attached to a forward relation field. */
+interface RefDefinition<Target extends SchemaLike = SchemaLike> {
+  /** Resolve the related schema after module initialization completes. */
+  resolve: () => Target;
+}
+/** Metadata for a one-way relation between two MongoDB schemas. */
+interface SchemaRelation<Target extends SchemaLike = SchemaLike, LocalField extends string = string, ForeignField extends string = string> {
+  readonly resolve: () => Target;
+  readonly localField: LocalField;
+  readonly foreignField: ForeignField;
+}
+/** Relation metadata attached to a schema. */
+type SchemaRelationMap = Record<string, SchemaRelation>;
+/** A relation target declaration accepted by Schema.relations(). */
+type RelationInput<Target extends SchemaLike = SchemaLike> = (() => Target) | {
+  target: () => Target;
+  foreignField?: string;
+};
+/** Extract a relation target from a relation declaration. */
+type RelationInputTarget<Input> = Input extends (() => infer Target) ? Target : Input extends {
+  target: () => infer Target;
+} ? Target : never;
+/** A string identifier field carrying a typed relation target. */
+type RefField<Target extends SchemaLike = SchemaLike> = z.ZodType<ObjectId$1> & {
+  readonly __ref?: RefDefinition<Target>;
+  optional(): OptionalRefField<Target>;
+  nullable(): NullableRefField<Target>;
+  nullish(): NullishRefField<Target>;
+};
+/** An optional relation field that retains its target metadata. */
+type OptionalRefField<Target extends SchemaLike = SchemaLike> = z.ZodOptional<RefField<Target>> & {
+  readonly __ref?: RefDefinition<Target>;
+};
+/** A nullable relation field that retains its target metadata. */
+type NullableRefField<Target extends SchemaLike = SchemaLike> = z.ZodNullable<RefField<Target>> & {
+  readonly __ref?: RefDefinition<Target>;
+};
+/** An optional and nullable relation field that retains its target metadata. */
+type NullishRefField<Target extends SchemaLike = SchemaLike> = z.ZodOptional<NullableRefField<Target>> & {
+  readonly __ref?: RefDefinition<Target>;
+};
+type RelationDefinition<Field> = Field extends {
+  readonly __ref?: infer Definition;
+} ? NonNullable<Definition> : Field extends z.ZodOptional<infer Inner> ? RelationDefinition<Inner> : Field extends z.ZodNullable<infer Inner> ? RelationDefinition<Inner> : never;
+/** The relation metadata inferred from a schema shape. */
+type RelationMap<Shape extends SchemaShape> = { [Key in keyof Shape as RelationDefinition<Shape[Key]> extends never ? never : Key]: RelationDefinition<Shape[Key]>; };
+//#endregion
+//#region src/relations/registry.d.ts
+type ObjectIdKeys<Shape extends SchemaShape> = { [Key in keyof InferShape<Schema<Shape>>]-?: NonNullable<InferShape<Schema<Shape>>[Key]> extends ObjectId$1 ? Key : never; }[keyof InferShape<Schema<Shape>>];
+type RelationDefinitions<Registry extends Record<string, SchemaLike>> = { [Name in keyof Registry]?: Registry[Name] extends Schema<infer Shape, any, any, any> ? Partial<Record<Extract<ObjectIdKeys<Shape>, string>, Extract<keyof Registry, string>>> : never; };
+type EnrichedSchema<Registry extends Record<string, SchemaLike>, AllDefinitions extends RelationDefinitions<Registry>, Name> = Name extends keyof Registry ? Registry[Name] extends Schema<infer Shape, infer Relations, infer Scopes, infer Options> ? Schema<Shape, Relations & RelationsFor<Registry, AllDefinitions, NonNullable<AllDefinitions[Name]>>, Scopes, Options> : never : never;
+type RelationsFor<Registry extends Record<string, SchemaLike>, AllDefinitions extends RelationDefinitions<Registry>, Definitions> = { [Field in keyof Definitions & string]: Definitions[Field] extends keyof Registry ? SchemaRelation<EnrichedSchema<Registry, AllDefinitions, Definitions[Field]>, Field, '_id'> : never; };
+type RegistryWithRelations<Registry extends Record<string, SchemaLike>, Definitions extends RelationDefinitions<Registry>> = { [Name in keyof Registry]: Registry[Name] extends Schema<infer Shape, infer Relations, infer Scopes, infer Options> ? Schema<Shape, Relations & RelationsFor<Registry, Definitions, NonNullable<Definitions[Name]>>, Scopes, Options> : Registry[Name]; };
+type RelationMapOf<Value> = Value extends Schema<any, infer Relations, any, any> ? Relations : {};
+type ScopeDefinitionsBySchema<Registry extends Record<string, SchemaLike>> = { [Name in keyof Registry]?: Record<string, PopulateSpecs<RelationMapOf<Registry[Name]>>>; };
+type RegistryWithScopes<Registry extends Record<string, SchemaLike>, Definitions extends ScopeDefinitionsBySchema<Registry>> = { [Name in keyof Registry]: Registry[Name] extends Schema<infer Shape, infer Relations, infer Scopes, infer Options> ? Schema<Shape, Relations, Scopes & (Definitions[Name] extends ScopeDefinitions ? Definitions[Name] : {}), Options> : Registry[Name]; };
+type SchemaRegistryBuilder<Registry extends Record<string, SchemaLike>> = Registry & {
+  readonly __registry?: Registry;
+  defineRelations<const Definitions extends RelationDefinitions<Registry>>(definitions: Definitions): SchemaRegistryBuilder<RegistryWithRelations<Registry, Definitions>>;
+  defineScopes<const Definitions extends ScopeDefinitionsBySchema<Registry>>(definitions: Definitions): SchemaRegistryBuilder<RegistryWithScopes<Registry, Definitions>>;
+};
+declare const createSchemaRegistry: <const Registry extends Record<string, SchemaLike>>(registry: Registry) => SchemaRegistryBuilder<Registry>;
+//#endregion
+//#region src/schema/scalars.d.ts
+declare module 'zod' {
+  interface ZodType {
+    hidden(): this & {
+      readonly __hidden: true;
+    };
+  }
+}
+/** A schema field that can be marked as hidden from default query results. */
+type HiddenCapable<T extends z.ZodType> = Omit<T, 'optional' | 'nullable' | 'nullish'> & HiddenMethods<T>;
+/** A schema field marked as hidden from default query results. */
+type HiddenSchema<T extends z.ZodType> = Omit<T, 'optional' | 'nullable' | 'nullish'> & HiddenMethods<T> & {
+  readonly __hidden: true;
+};
+type HiddenMethods<T extends z.ZodType> = {
+  hidden(): HiddenSchema<T>;
+  optional(): HiddenCapable<z.ZodOptional<T>>;
+  nullable(): HiddenCapable<z.ZodNullable<T>>;
+  nullish(): HiddenCapable<z.ZodOptional<z.ZodNullable<T>>>;
+};
+/** Create a MongoDB ObjectId schema. */
+declare const objectId: () => HiddenCapable<z.ZodInstanceOf<ObjectId$1>>;
+//#endregion
+//#region src/api.d.ts
+type ZodConstructorKey = { [Key in keyof typeof z]: Key extends string ? Key extends Lowercase<Key> ? (typeof z)[Key] extends ((...args: any[]) => any) ? Key : never : never : never; }[keyof typeof z];
+type ZodConstructors = Pick<typeof z, ZodConstructorKey>;
+/** The public schema-construction API. */
+type OrmApi = ZodConstructors & {
+  /** Define a typed object schema. */
+  schema<Shape extends SchemaShape>(shape: Shape): Schema<Shape>;
+  /** Build a registry of named schemas and their relation graph. */
+  defineSchemas<const Registry extends Record<string, SchemaLike>>(registry: Registry): ReturnType<typeof createSchemaRegistry<Registry>>;
+  /** Create a MongoDB ObjectId field. */
+  objectId: typeof objectId;
+  /** Create a string ID field linked to another schema. */
+  ref<Target extends SchemaLike>(resolve: () => Target): RefField<Target>;
+};
+export declare const orm: OrmApi;
+//#endregion
+//#region src/validation/errors.d.ts
+/** Stable machine-readable codes emitted by Mongorm errors. */
+export declare const ORM_ERROR_CODES: {
+  readonly DATABASE_NOT_CONNECTED: 'DATABASE_NOT_CONNECTED';
+  readonly INVALID_QUERY: 'INVALID_QUERY';
+  readonly CURSOR_QUERY_INVALID: 'CURSOR_QUERY_INVALID';
+  readonly ESTIMATED_COUNT_FILTER_UNSUPPORTED: 'ESTIMATED_COUNT_FILTER_UNSUPPORTED';
+};
+type OrmErrorCode = (typeof ORM_ERROR_CODES)[keyof typeof ORM_ERROR_CODES];
+/** Base error type emitted by the ORM. */
+export declare class OrmError extends Error {
+  readonly code: OrmErrorCode;
+  constructor(message: string, code: OrmErrorCode);
+}
+/** Raised when an operation requires a connected database. */
+export declare class DatabaseNotConnectedError extends OrmError {
+  constructor();
+}
+/** Raised when a query configuration is not supported. */
+export declare class InvalidQueryError extends OrmError {
+  constructor(message: string, code?: OrmErrorCode);
+}
+/** Raised when cursor pagination options are incompatible. */
+export declare class CursorQueryError extends InvalidQueryError {
+  constructor(message: string);
+}
+/** Raised when an estimated count is requested with a filter. */
+export declare class EstimatedCountError extends InvalidQueryError {
+  constructor();
+}
+//#endregion
+export { type DatabaseModels, type DbOptions, type HiddenDocumentKey, type Infer, type InferInput, type InferShape, type ManagedField, type ModelFilter, type ModelSort, ObjectId, type OrmApi, type OrmErrorCode, type PopulateSpec, type PopulateSpecs, type PopulatedResult, type RefDefinition, type RefField, type RelationDefinitions, type RelationMap, type SchemaDefinition, type SchemaIndex, type SchemaIndexFields, type SchemaLike, type SchemaOptions, type SchemaRegistry, type SchemaRegistryBuilder, type SchemaRelation, type SchemaRelationMap, type SchemaShape, type ScopeDefinitionsBySchema, type SelectableKey, type SelectedDocument, type SoftDeleteEnabled, type StoredDocument, type VisibleDocument };