miragejs-orm 0.1.0

package/lib/dist/index.d.ts

@@ -0,0 +1,3044 @@
+/**
+ * Type for allowed ID types
+ */
+type IdType = number | string;
+/**
+ * Type for ID generator function that takes current ID and returns next ID
+ * @template T - The type of ID
+ * @param currentId - The current ID
+ * @returns The next ID
+ */
+type IdGenerator<T> = (currentId: T) => T;
+/**
+ * Configuration options for the IdentityManager
+ * @template T - The type of ID
+ * @param initialCounter - The initial counter value
+ * @param initialUsedIds - A set of initial used IDs
+ * @param idGenerator - Custom function to generate the next ID
+ */
+interface IdentityManagerConfig<T = string> {
+    initialCounter: T;
+    initialUsedIds?: T[];
+    idGenerator?: IdGenerator<T>;
+}
+
+/**
+ * Manages unique identifiers for database records.
+ * Handles different types of IDs, ensuring uniqueness and proper sequencing.
+ * @template T - The type of ID to manage (defaults to string)
+ * @param options - Configuration options for the identity manager.
+ * @param options.initialCounter - The initial counter value.
+ * @param options.initialUsedIds - A set of initial used IDs.
+ * @param options.idGenerator - Custom function to generate the next ID.
+ * @example
+ * const identityManager = new IdentityManager();
+ * identityManager.get(); // => "1"
+ * identityManager.set("1");
+ * identityManager.get(); // => "2"
+ * identityManager.fetch(); // => "2"
+ * identityManager.get(); // => "3"
+ * identityManager.reset(); // => "1"
+ */
+declare class IdentityManager<T extends IdType = string> {
+    private _counter;
+    private _idGenerator;
+    private _initialCounter;
+    private _usedIds;
+    constructor(options: IdentityManagerConfig<T>);
+    /**
+     * Gets the next ID without incrementing the counter.
+     * @returns The next ID.
+     */
+    get(): T;
+    /**
+     * Gets the next ID and increments the counter.
+     * @returns The next ID.
+     */
+    fetch(): T;
+    /**
+     * Marks an ID as used and updates the counter if necessary.
+     * @param id - The ID to mark as used.
+     */
+    set(id: T): void;
+    /**
+     * Increments the counter.
+     */
+    inc(): void;
+    /**
+     * Resets the counter to its initial value and clears used IDs.
+     */
+    reset(): void;
+    /**
+     * Gets the default generator for the ID type.
+     * @returns The default generator function.
+     */
+    private getDefaultGenerator;
+}
+/**
+ * String-based identity manager with sensible defaults.
+ * @example
+ * const identityManager = new StringIdentityManager();
+ * identityManager.fetch(); // => "1"
+ * identityManager.fetch(); // => "2"
+ */
+declare class StringIdentityManager extends IdentityManager<string> {
+    constructor(options?: Partial<IdentityManagerConfig<string>>);
+}
+/**
+ * Number-based identity manager with sensible defaults.
+ * @example
+ * const identityManager = new NumberIdentityManager();
+ * identityManager.fetch(); // => 1
+ * identityManager.fetch(); // => 2
+ */
+declare class NumberIdentityManager extends IdentityManager<number> {
+    constructor(options?: Partial<IdentityManagerConfig<number>>);
+}
+
+/**
+ * Base record type with an ID field
+ * @template TId - The type of the ID field
+ */
+type DbRecord<TId = IdType> = {
+    id: TId;
+};
+/**
+ * Type for input data when creating or updating a record
+ * @template TRecord - The type of the record's attributes
+ */
+type DbRecordInput<TRecord extends DbRecord> = Partial<TRecord>;
+/**
+ * Type for new record with optional id
+ * @template TRecord - The type of the record's attributes
+ */
+type NewDbRecord<TRecord extends DbRecord> = Omit<TRecord, 'id'> & {
+    id?: TRecord['id'] | null;
+};
+/**
+ * Type for database collections
+ */
+type DbCollections = Record<string, DbCollection<any>>;
+/**
+ * Infers the collection type from data records
+ * @template TData - The type of data records
+ */
+type DbCollectionFromStaticData<TData> = TData extends Array<infer TRecord> ? TRecord extends DbRecord ? DbCollection<TRecord> : DbCollection<DbRecord> : DbCollection<DbRecord>;
+/**
+ * Infers collections map from data object
+ * @template TData - The type of data object
+ */
+type DbCollectionsFromStaticData<TData> = {
+    [K in keyof TData]: DbCollectionFromStaticData<TData[K]>;
+};
+/**
+ * Gets the data of a collection
+ * @template T - The type of the collection
+ */
+type DbCollectionData<T> = T extends DbCollection<infer TAttrs> ? TAttrs[] : never;
+/**
+ * Configuration for creating a database collection
+ * @template TRecord - The type of the record's attributes
+ */
+interface DbCollectionConfig<TRecord extends DbRecord> {
+    identityManager?: IdentityManager<TRecord['id']>;
+    initialData?: TRecord[];
+}
+/**
+ * Type for a database's data
+ * @template TCollections - The type of collections in the database
+ */
+type DbData<TCollections extends Record<string, DbCollection<any>>> = {
+    [K in keyof TCollections]: DbCollectionData<TCollections[K]>;
+};
+/**
+ * Configuration for creating a DB instance
+ * @template TCollections - The type of collections in the database
+ */
+type DbConfig<TCollections extends Record<string, DbCollection<any>>> = {
+    initialData?: DbData<TCollections>;
+};
+/**
+ * Primitive types that support comparison operations
+ */
+type Primitive = string | number | boolean | Date;
+/**
+ * Order direction for sorting
+ */
+type OrderDirection = 'asc' | 'desc';
+/**
+ * Defines ordering for query results
+ * Can be an object mapping fields to directions, or an array of [field, direction] tuples
+ * @template TRecord - The record type
+ */
+type OrderBy<TRecord> = Partial<Record<keyof TRecord, OrderDirection>> | Array<readonly [keyof TRecord, OrderDirection]>;
+/**
+ * Equality and membership operations
+ * @template T - The field type
+ */
+type EqualityOps<T> = {
+    /** Equals */
+    eq?: T;
+    /** Not equals */
+    ne?: T;
+    /** In array */
+    in?: T[];
+    /** Not in array */
+    nin?: T[];
+    /** Is null or undefined */
+    isNull?: boolean;
+};
+/**
+ * Range comparison operations for primitive types
+ * @template T - The primitive field type
+ */
+type RangeOps<T extends Primitive> = {
+    /** Less than */
+    lt?: T;
+    /** Less than or equal */
+    lte?: T;
+    /** Greater than */
+    gt?: T;
+    /** Greater than or equal */
+    gte?: T;
+    /** Between two values (inclusive) */
+    between?: readonly [T, T];
+};
+/**
+ * String-specific operations
+ */
+type StringOps = {
+    /** SQL-like pattern matching with % wildcards */
+    like?: string;
+    /** Case-insensitive like */
+    ilike?: string;
+    /** Starts with prefix */
+    startsWith?: string;
+    /** Ends with suffix */
+    endsWith?: string;
+    /** Contains substring */
+    contains?: string;
+};
+/**
+ * Array-specific operations
+ * @template E - The array element type
+ */
+type ArrayOps<E> = {
+    /** Array contains element(s) */
+    contains?: E | E[];
+    /** Array length operations */
+    length?: RangeOps<number>;
+};
+/**
+ * All available field operations based on field type
+ * @template T - The field type
+ */
+type FieldOps<T> = EqualityOps<T> & (T extends string ? StringOps : {}) & (T extends Primitive ? RangeOps<T> : {}) & (T extends readonly (infer E)[] ? ArrayOps<E> : {});
+/**
+ * Leaf-level where clause for field matching
+ * Fields can be matched by direct value or by field operations
+ * @template TRecord - The record type
+ */
+type WhereLeaf<TRecord> = {
+    [K in keyof TRecord]?: TRecord[K] | FieldOps<TRecord[K]>;
+};
+/**
+ * Complete where clause with logical operators
+ * @template TRecord - The record type
+ */
+type Where<TRecord> = WhereLeaf<TRecord> & {
+    /** Logical AND - all conditions must match */
+    AND?: Where<TRecord>[];
+    /** Logical OR - at least one condition must match */
+    OR?: Where<TRecord>[];
+    /** Logical NOT - condition must not match */
+    NOT?: Where<TRecord>;
+};
+/**
+ * Helper functions for use in where callback predicates
+ * These are comparison utilities - users access record values and pass them to helpers
+ * @template TRecord - The record type
+ */
+type WhereHelperFns<TRecord> = {
+    /** Logical AND - all conditions must be true */
+    and: (...conditions: boolean[]) => boolean;
+    /** Logical OR - at least one condition must be true */
+    or: (...conditions: boolean[]) => boolean;
+    /** Logical NOT - inverts the condition */
+    not: (condition: boolean) => boolean;
+    /** Check equality */
+    eq: (value: any, compareWith: any) => boolean;
+    /** Check inequality */
+    ne: (value: any, compareWith: any) => boolean;
+    /** Greater than */
+    gt: (value: any, compareWith: any) => boolean;
+    /** Greater than or equal */
+    gte: (value: any, compareWith: any) => boolean;
+    /** Less than */
+    lt: (value: any, compareWith: any) => boolean;
+    /** Less than or equal */
+    lte: (value: any, compareWith: any) => boolean;
+    /** Between two values (inclusive) */
+    between: (value: any, min: any, max: any) => boolean;
+    /** SQL-like pattern matching */
+    like: (value: string, pattern: string) => boolean;
+    /** Case-insensitive like */
+    ilike: (value: string, pattern: string) => boolean;
+    /** Starts with string */
+    startsWith: (value: string, prefix: string) => boolean;
+    /** Ends with string */
+    endsWith: (value: string, suffix: string) => boolean;
+    /** Contains substring */
+    containsText: (value: string, substring: string) => boolean;
+    /** In array */
+    inArray: (value: any, values: any[]) => boolean;
+    /** Not in array */
+    notInArray: (value: any, values: any[]) => boolean;
+    /** Is null or undefined */
+    isNull: (value: any) => boolean;
+    /** Is not null and not undefined */
+    isNotNull: (value: any) => boolean;
+};
+/**
+ * Query options for finding records
+ * @template TRecord - The record type
+ */
+interface QueryOptions<TRecord> {
+    /** Filter criteria - object DSL or callback function */
+    where?: Where<TRecord> | ((record: TRecord, helpers: WhereHelperFns<TRecord>) => boolean);
+    /** Sorting specification */
+    orderBy?: OrderBy<TRecord>;
+    /** Number of records to skip (offset pagination) */
+    offset?: number;
+    /** Maximum number of records to return */
+    limit?: number;
+    /** Cursor for keyset pagination (must align with orderBy fields) */
+    cursor?: Partial<TRecord>;
+}
+
+/**
+ * A collection of records in a database. Think of it as a table in a relational database.
+ * @param config - Configuration for the collection.
+ * @param config.name - The name of the collection.
+ * @param config.identityManager - The identity manager for the collection.
+ * @param config.initialData - Initial data for the collection.
+ * @example
+ * const users = new DbCollection({ name: 'users' });
+ * users.insert({ name: 'John' }); // => { id: "1", name: 'John' }
+ */
+declare class DbCollection<TRecord extends DbRecord = DbRecord> {
+    name: string;
+    identityManager: IdentityManager<TRecord['id']>;
+    private _records;
+    private _queryManager;
+    constructor(name: string, config?: DbCollectionConfig<TRecord>);
+    /**
+     * The next ID for the collection.
+     * @returns The next ID for the collection.
+     */
+    get nextId(): TRecord['id'];
+    /**
+     * Returns the number of records in the collection.
+     * @returns The number of records in the collection.
+     */
+    get size(): number;
+    /**
+     * Checks if the collection is empty.
+     * @returns `true` if the collection is empty, `false` otherwise.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Returns all records in the collection
+     * @returns An array of all records in the collection.
+     */
+    all(): TRecord[];
+    /**
+     * Gets a record by its index position in the collection.
+     * @param index - The index of the record to get.
+     * @returns The record at the specified index, or `undefined` if out of bounds.
+     */
+    at(index: number): TRecord | undefined;
+    /**
+     * Returns the first record in the collection.
+     * @returns The first record in the collection, or `undefined` if the collection is empty.
+     */
+    first(): TRecord | undefined;
+    /**
+     * Returns the last record in the collection.
+     * @returns The last record in the collection, or `undefined` if the collection is empty.
+     */
+    last(): TRecord | undefined;
+    /**
+     * Checks if a record exists in the collection.
+     * @param id - The ID of the record to check.
+     * @returns `true` if the record exists, `false` otherwise.
+     */
+    has(id: TRecord['id']): boolean;
+    /**
+     * Finds the first record that matches the given ID, predicate object, or query options.
+     * @param input - ID, predicate object, or query options
+     * @returns The first record that matches, or `null` if not found.
+     * @example
+     * ```typescript
+     * // By ID
+     * collection.find('user-1');
+     *
+     * // By predicate object (simple equality)
+     * collection.find({ email: 'user@example.com' });
+     *
+     * // By query options (advanced filtering, sorting)
+     * collection.find({
+     *   where: { email: { ilike: '%@example.com' } },
+     *   orderBy: { createdAt: 'desc' },
+     * });
+     * ```
+     */
+    find(input: TRecord['id'] | DbRecordInput<TRecord> | QueryOptions<TRecord>): TRecord | null;
+    /**
+     * Finds multiple records by IDs, predicate object, or query options.
+     * @param input - Array of IDs, predicate object, or query options
+     * @returns An array of records that match
+     * @example
+     * ```typescript
+     * // By IDs
+     * collection.findMany(['user-1', 'user-2']);
+     *
+     * // By predicate object (simple equality)
+     * collection.findMany({ active: true });
+     *
+     * // By query options (advanced filtering, sorting, pagination)
+     * collection.findMany({
+     *   where: { age: { gte: 18 }, status: { in: ['active', 'pending'] } },
+     *   orderBy: { createdAt: 'desc' },
+     *   limit: 10,
+     * });
+     * ```
+     */
+    findMany(input: TRecord['id'][] | DbRecordInput<TRecord> | QueryOptions<TRecord>): TRecord[];
+    /**
+     * Count records matching a where clause.
+     * @param where - Optional where clause to filter records
+     * @returns Number of matching records
+     * @example
+     * ```typescript
+     * collection.count({ status: 'active' });
+     * collection.count({ age: { gte: 18, lte: 65 } });
+     * ```
+     */
+    count(where?: Where<TRecord>): number;
+    /**
+     * Check if any records match a where clause.
+     * @param where - Optional where clause to filter records
+     * @returns True if at least one record matches
+     * @example
+     * ```typescript
+     * collection.exists({ email: 'user@example.com' });
+     * collection.exists({ status: { in: ['active', 'pending'] } });
+     * ```
+     */
+    exists(where?: Where<TRecord>): boolean;
+    /**
+     * Inserts a new record into the collection.
+     * @param data - The record data to insert.
+     * @returns The inserted record.
+     */
+    insert(data: NewDbRecord<TRecord>): TRecord;
+    /**
+     * Inserts multiple records into the collection.
+     * @param data - An array of record data to insert.
+     * @returns An array of the inserted records.
+     */
+    insertMany(data: NewDbRecord<TRecord>[]): TRecord[];
+    /**
+     * Updates a single record by ID.
+     * @param id - The record ID to update.
+     * @param patch - The data to update the record with.
+     * @returns The updated record, or `null` if the record was not found.
+     */
+    update(id: TRecord['id'], patch: TRecord | DbRecordInput<TRecord>): TRecord | null;
+    /**
+     * Updates multiple records by IDs, predicate object, or query options.
+     * @param input - Array of IDs, predicate object, or query options to find records.
+     * @param patch - The data to update the records with.
+     * @returns Array of updated records.
+     */
+    updateMany(input: TRecord['id'][] | DbRecordInput<TRecord> | QueryOptions<TRecord>, patch: TRecord | DbRecordInput<TRecord>): TRecord[];
+    /**
+     * Deletes a record from the collection by its ID.
+     * @param id - The ID of the record to delete.
+     * @returns `true` if the record was deleted, `false` if it was not found.
+     */
+    delete(id: TRecord['id']): boolean;
+    /**
+     * Deletes multiple records by IDs, predicate object, or query options.
+     * @param input - Array of IDs, predicate object, or query options to find records.
+     * @returns The number of records that were deleted.
+     */
+    deleteMany(input: TRecord['id'][] | DbRecordInput<TRecord> | QueryOptions<TRecord>): number;
+    /**
+     * Removes all records from the collection.
+     */
+    clear(): void;
+    /**
+     * Prepares a record for insertion by generating an ID if it doesn't exist.
+     * @param data - The record to prepare.
+     * @returns The prepared record.
+     */
+    private _prepareRecord;
+}
+
+/**
+ * A database for storing and managing collections of records.
+ * @template TCollections - The type of collections in the database
+ * @example
+ * const db = DB.create({
+ *   users: [{ id: "1", name: 'John' }],
+ *   posts: [{ id: "1", title: 'Hello' }]
+ * });
+ * db.users.records;
+ */
+declare class DB<TCollections extends DbCollections> {
+    private _collections;
+    constructor(config?: DbConfig<TCollections>);
+    /**
+     * Checks if a collection exists.
+     * @param name - The name of the collection to check.
+     * @returns `true` if the collection exists, `false` otherwise.
+     */
+    hasCollection(name: keyof TCollections): boolean;
+    /**
+     * Creates a new collection with the given name and initial data.
+     * @param name - The name of the collection to create.
+     * @param config - The configuration for the collection.
+     * @param config.initialData - The initial data to populate the collection with.
+     * @param config.identityManager - The identity manager for the collection.
+     * @returns The DB instance.
+     */
+    createCollection<TAttrs extends DbRecord>(name: keyof TCollections, config?: Omit<DbCollectionConfig<TAttrs>, 'name'>): DbInstance<TCollections & {
+        [K in keyof TCollections]: DbCollection<TAttrs>;
+    }>;
+    /**
+     * Retrieves a collection by its name.
+     * @template T - The collection key
+     * @param name - The name of the collection to retrieve.
+     * @returns The collection with the specified name.
+     * @throws {Error} If the collection does not exist.
+     */
+    getCollection<T extends keyof TCollections>(name: T): TCollections[T];
+    /**
+     * Retrieves the identity manager for a given collection name.
+     * @param collectionName - The name of the collection to get the identity manager for.
+     * @returns The identity manager for the given collection name.
+     * @throws {Error} If the collection does not exist.
+     */
+    identityManagerFor(collectionName: keyof TCollections): IdentityManager<IdType>;
+    /**
+     * Loads collections data from a record into the database.
+     * @template TData - The type of data to load
+     * @param data - Record of collection names and their initial data
+     * @returns The DB instance with collection accessors for the loaded data.
+     */
+    loadData<TData extends Record<string, DbRecord[]>>(data: TData): DbInstance<TCollections & DbCollectionsFromStaticData<TData>>;
+    /**
+     * Empties the data from all collections in the database.
+     */
+    emptyData(): void;
+    /**
+     * Dumps the data from all collections in the database.
+     * @returns A record of collection names and their data.
+     */
+    dump(): DbData<TCollections>;
+    private initCollectionAccessors;
+}
+/**
+ * Type for a DB instance with collection accessors
+ * @template TCollections - The type of collections in the database
+ */
+type DbInstance<TCollections extends Record<string, DbCollection<any>>> = DB<TCollections> & {
+    [K in keyof TCollections]: TCollections[K];
+};
+
+/**
+ * Logger class for outputting structured log messages.
+ *
+ * Provides debug, info, warn, and error logging methods with automatic level filtering.
+ * Used internally by the ORM to log database operations, seed/fixture loading, and errors.
+ * @example
+ * ```typescript
+ * const logger = new Logger({
+ *   enabled: true,
+ *   level: 'debug',
+ *   prefix: '[MyApp]'
+ * });
+ *
+ * logger.debug('Operation started', { userId: '123' });
+ * logger.info('Loaded 10 records');
+ * logger.warn('Missing optional field', { field: 'email' });
+ * logger.error('Validation failed', { errors: [...] });
+ * ```
+ */
+declare class Logger {
+    private _config;
+    /**
+     * Creates a new Logger instance with the specified configuration.
+     * @param config - Logger configuration including enabled state, log level, and optional prefix
+     * @example
+     * ```typescript
+     * const logger = new Logger({
+     *   enabled: true,
+     *   level: 'debug',
+     *   prefix: '[Mirage]'
+     * });
+     * ```
+     */
+    constructor(config: LoggerConfig);
+    /**
+     * Logs a debug message with optional context.
+     *
+     * Debug logs are the most verbose and show low-level operational details.
+     * Use for troubleshooting, understanding flow, and performance analysis.
+     *
+     * Only outputs if logger is enabled and level is set to 'debug'.
+     * @param message - The debug message to log
+     * @param context - Optional context object with additional information
+     * @example
+     * ```typescript
+     * logger.debug('Query executed', { collection: 'users', query: { name: 'John' } });
+     * // Output: [Mirage] DEBUG: Query executed { collection: 'users', query: { name: 'John' } }
+     * ```
+     */
+    debug(message: string, context?: Record<string, unknown>): void;
+    /**
+     * Logs an info message with optional context.
+     *
+     * Info logs show normal operations and important events.
+     * Use for high-level actions, successful operations, and summaries.
+     *
+     * Only outputs if logger is enabled and level is 'debug' or 'info'.
+     * @param message - The info message to log
+     * @param context - Optional context object with additional information
+     * @example
+     * ```typescript
+     * logger.info('Fixtures loaded', { collection: 'users', count: 50 });
+     * // Output: [Mirage] INFO: Fixtures loaded { collection: 'users', count: 50 }
+     * ```
+     */
+    info(message: string, context?: Record<string, unknown>): void;
+    /**
+     * Logs a warning message with optional context.
+     *
+     * Warning logs indicate something unexpected but not breaking.
+     * Use for deprecated features, unusual patterns, and potential issues.
+     *
+     * Only outputs if logger is enabled and level is 'debug', 'info', or 'warn'.
+     * @param message - The warning message to log
+     * @param context - Optional context object with additional information
+     * @example
+     * ```typescript
+     * logger.warn('Foreign key mismatch', { postId: '1', authorId: '999' });
+     * // Output: [Mirage] WARN: Foreign key mismatch { postId: '1', authorId: '999' }
+     * ```
+     */
+    warn(message: string, context?: Record<string, unknown>): void;
+    /**
+     * Logs an error message with optional context.
+     *
+     * Error logs indicate something failed or broke.
+     * Use for operations that couldn't complete and validation failures.
+     *
+     * Only outputs if logger is enabled and level is not 'silent'.
+     * @param message - The error message to log
+     * @param context - Optional context object with additional information
+     * @example
+     * ```typescript
+     * logger.error('Validation failed', { field: 'email', reason: 'required' });
+     * // Output: [Mirage] ERROR: Validation failed { field: 'email', reason: 'required' }
+     * ```
+     */
+    error(message: string, context?: Record<string, unknown>): void;
+    /**
+     * Internal method to handle actual logging with level filtering.
+     *
+     * Checks if logging is enabled and if the message level meets the configured threshold.
+     * Routes messages to appropriate console methods based on severity.
+     * @param level - The log level of the message
+     * @param message - The message to log
+     * @param context - Optional context object
+     * @private
+     */
+    private _log;
+}
+/**
+ * Log level type defining the severity of log messages.
+ *
+ * Log levels follow a hierarchy where setting a level shows that level and everything above it:
+ * - `silent`: No logging
+ * - `error`: Only errors
+ * - `warn`: Warnings and errors
+ * - `info`: Info, warnings, and errors
+ * - `debug`: All messages (most verbose)
+ * @example
+ * ```typescript
+ * // Debug level - see everything
+ * schema().logging({ enabled: true, level: 'debug' })
+ *
+ * // Info level - only important operations
+ * schema().logging({ enabled: true, level: 'info' })
+ *
+ * // Error level - only failures
+ * schema().logging({ enabled: true, level: 'error' })
+ * ```
+ */
+type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
+/**
+ * Logger configuration options.
+ */
+interface LoggerConfig {
+    /**
+     * Whether logging is enabled. When false, no logs are output regardless of level.
+     * @default false
+     */
+    enabled: boolean;
+    /**
+     * The minimum log level to output. Messages below this level are filtered out.
+     * @default 'info'
+     */
+    level: LogLevel;
+    /**
+     * Custom prefix for log messages. Useful for distinguishing ORM logs from other output.
+     * @default '[Mirage]'
+     */
+    prefix?: string;
+}
+
+/**
+ * A collection of models with array-like interface
+ * @template TTemplate - The model template (most important for users)
+ * @template TSchema - The schema collections type for enhanced type inference
+ * @template TSerializer - The serializer type
+ */
+declare class ModelCollection<TTemplate extends ModelTemplate = ModelTemplate, TSchema extends SchemaCollections = SchemaCollections, TSerializer = undefined> {
+    private readonly _template;
+    readonly collectionName: string;
+    models: Array<ModelInstance<TTemplate, TSchema, TSerializer>>;
+    protected _serializer?: TSerializer;
+    constructor(template: TTemplate, models?: Array<ModelInstance<TTemplate, TSchema, TSerializer>>, serializer?: TSerializer);
+    /**
+     * Get the length of the collection
+     * @returns The number of models in the collection
+     */
+    get length(): number;
+    /**
+     * Check if the collection is empty
+     * @returns True if the collection is empty, false otherwise
+     */
+    get isEmpty(): boolean;
+    /**
+     * Get a model by index
+     * @param index - The index of the model to get
+     * @returns The model at the given index or undefined
+     */
+    at(index: number): ModelInstance<TTemplate, TSchema, TSerializer> | undefined;
+    /**
+     * Get the first model in the collection
+     * @returns The first model or null if the collection is empty
+     */
+    first(): ModelInstance<TTemplate, TSchema, TSerializer> | null;
+    /**
+     * Get the last model in the collection
+     * @returns The last model or null if the collection is empty
+     */
+    last(): ModelInstance<TTemplate, TSchema, TSerializer> | null;
+    /**
+     * Execute a function for each model in the collection
+     * @param cb - The function to execute for each model
+     */
+    forEach(cb: (model: ModelInstance<TTemplate, TSchema, TSerializer>, index: number, collection: this) => void): void;
+    /**
+     * Create a new array with the results of calling a function for each model
+     * @param cb - The function to call for each model
+     * @returns A new array with the results
+     */
+    map(cb: (model: ModelInstance<TTemplate, TSchema, TSerializer>, index: number, collection: this) => ModelInstance<TTemplate, TSchema, TSerializer>): ModelCollection<TTemplate, TSchema, TSerializer>;
+    /**
+     * Create a new collection with models that pass a test
+     * @param cb - The test function
+     * @returns A new ModelCollection with the filtered models
+     */
+    filter(cb: (model: ModelInstance<TTemplate, TSchema, TSerializer>, index: number, collection: this) => boolean): ModelCollection<TTemplate, TSchema, TSerializer>;
+    /**
+     * Find the first model that satisfies a test
+     * @param cb - The test function
+     * @returns The first model that passes the test, or undefined
+     */
+    find(cb: (model: ModelInstance<TTemplate, TSchema, TSerializer>, index: number, collection: this) => boolean): ModelInstance<TTemplate, TSchema, TSerializer> | undefined;
+    /**
+     * Check if at least one model satisfies a test
+     * @param cb - The test function
+     * @returns True if at least one model passes the test
+     */
+    some(cb: (model: ModelInstance<TTemplate, TSchema, TSerializer>, index: number, collection: this) => boolean): boolean;
+    /**
+     * Check if all models satisfy a test
+     * @param cb - The test function
+     * @returns True if all models pass the test
+     */
+    every(cb: (model: ModelInstance<TTemplate, TSchema, TSerializer>, index: number, collection: this) => boolean): boolean;
+    /**
+     * Concatenate this collection with other collections or arrays
+     * @param others - Other collections or arrays to concatenate
+     * @returns A new ModelCollection with all models
+     */
+    concat(...others: (ModelCollection<TTemplate, TSchema, TSerializer> | ModelInstance<TTemplate, TSchema, TSerializer>[])[]): ModelCollection<TTemplate, TSchema, TSerializer>;
+    /**
+     * Check if the collection includes a specific model
+     * @param model - The model to check for
+     * @returns True if the model is in the collection
+     */
+    includes(model: ModelInstance<TTemplate, TSchema, TSerializer>): boolean;
+    /**
+     * Find the index of a model in the collection
+     * @param model - The model to find
+     * @returns The index of the model, or -1 if not found
+     */
+    indexOf(model: ModelInstance<TTemplate, TSchema, TSerializer>): number;
+    /**
+     * Sort the models in the collection
+     * @param compareFn - The comparison function
+     * @returns A new sorted ModelCollection
+     */
+    sort(compareFn?: (a: ModelInstance<TTemplate, TSchema, TSerializer>, b: ModelInstance<TTemplate, TSchema, TSerializer>) => number): ModelCollection<TTemplate, TSchema, TSerializer>;
+    /**
+     * Reverse the order of models in the collection
+     * @returns A new reversed ModelCollection
+     */
+    reverse(): ModelCollection<TTemplate, TSchema, TSerializer>;
+    /**
+     * Add a model to the end of the collection (alias for push)
+     * @param model - The model to add
+     */
+    add(model: ModelInstance<TTemplate, TSchema, TSerializer>): void;
+    /**
+     * Remove a model from the collection
+     * @param model - The model to remove
+     * @returns True if the model was removed, false if not found
+     */
+    remove(model: ModelInstance<TTemplate, TSchema, TSerializer>): boolean;
+    /**
+     * Save all models in the collection
+     * @returns The collection instance for chaining
+     */
+    save(): this;
+    /**
+     * Destroy all models in the collection
+     * @returns The collection instance for chaining
+     */
+    destroy(): this;
+    /**
+     * Reload all models in the collection from the database
+     * @returns The collection instance for chaining
+     */
+    reload(): this;
+    /**
+     * Update all models in the collection with the given attributes
+     * @param attrs - The attributes to update
+     * @returns The collection instance for chaining
+     */
+    update(attrs: ModelUpdateAttrs<TTemplate, TSchema>): this;
+    /**
+     * Convert the collection to a plain array
+     * @returns An array of the models
+     */
+    toArray(): ModelInstance<TTemplate, TSchema, TSerializer>[];
+    /**
+     * Get a string representation of the collection
+     * @returns A string representation showing the collection name and count
+     */
+    toString(): string;
+    /**
+     * Convert the collection to JSON
+     * Uses serializer if configured, otherwise returns array of raw attributes
+     * @returns A serialized representation of the collection
+     */
+    toJSON(): TSerializer extends {
+        serializeCollection(collection: any): infer TSerializedCollection;
+    } ? TSerializedCollection : ModelAttrs<TTemplate, TSchema>[];
+    /**
+     * Make the collection iterable
+     * @returns An iterator for the models
+     */
+    [Symbol.iterator](): Iterator<ModelInstance<TTemplate, TSchema, TSerializer>>;
+}
+
+/**
+ * Structural serializer options (schema-level or collection-level)
+ * Controls how the response is formatted/structured
+ */
+interface StructuralSerializerOptions {
+    /**
+     * Whether to wrap the serialized data in a root key
+     * - false: no wrapping (default)
+     * - true: wrap with modelName/collectionName
+     * - string: wrap with custom key name
+     */
+    root?: boolean | string;
+    /**
+     * Whether to embed related models in the serialized output
+     * - false: exclude relationships (default)
+     * - true: include embedded relationships
+     */
+    embed?: boolean;
+}
+/**
+ * Data selection serializer options (collection-level only)
+ * Controls what data to include in serialization
+ * @template TTemplate - The model template
+ */
+interface DataSerializerOptions<TTemplate extends ModelTemplate> {
+    /**
+     * Specific attributes to include in serialization
+     * If not provided, all attributes are included
+     * Note: This is model-specific and not available at schema level
+     */
+    attrs?: (keyof InferModelAttrs<TTemplate>)[];
+    /**
+     * Relationship names to include in serialization
+     * Note: This is model-specific and not available at schema level
+     */
+    include?: string[];
+}
+/**
+ * Complete serializer options (collection-level)
+ * Combines structural and data selection options
+ * @template TTemplate - The model template
+ */
+interface SerializerOptions<TTemplate extends ModelTemplate> extends StructuralSerializerOptions, DataSerializerOptions<TTemplate> {
+}
+
+/**
+ * Serializer class that handles model serialization with custom JSON types
+ * @template TTemplate - The model template
+ * @template TSerializedModel - The serialized model type (for single model)
+ * @template TSerializedCollection - The serialized collection type (for array of models)
+ * @template TOptions - The serializer options type
+ * @example
+ * ```typescript
+ * interface UserJSON {
+ *   id: string;
+ *   name: string;
+ * }
+ *
+ * interface UsersJSON {
+ *   users: UserJSON[];
+ * }
+ *
+ * const serializer = new Serializer<UserTemplate, UserJSON, UsersJSON>(
+ *   userTemplate,
+ *   {
+ *     attrs: ['id', 'name'],
+ *     root: 'user'
+ *   }
+ * );
+ * ```
+ */
+declare class Serializer<TTemplate extends ModelTemplate, TSerializedModel = InferModelAttrs<TTemplate>, TSerializedCollection = TSerializedModel[], TOptions extends SerializerOptions<TTemplate> = SerializerOptions<TTemplate>> {
+    protected _template: TTemplate;
+    protected _modelName: string;
+    protected _collectionName: string;
+    protected _attrs: TOptions['attrs'];
+    protected _root: TOptions['root'];
+    protected _embed: TOptions['embed'];
+    protected _include: TOptions['include'];
+    constructor(template: TTemplate, options?: TOptions);
+    /**
+     * Get the model name
+     * @returns The model name
+     */
+    get modelName(): string;
+    /**
+     * Get the collection name
+     * @returns The collection name
+     */
+    get collectionName(): string;
+    /**
+     * Serialize raw data from a model without structural wrapping
+     * This method extracts and returns the data (attributes + relationships)
+     * without applying any root wrapping. Used for embedding relationships.
+     * @param model - The model instance to serialize
+     * @returns The serialized model data without root wrapping
+     */
+    serializeData<TSchema extends SchemaCollections>(model: ModelInstance<TTemplate, TSchema>): Record<string, any>;
+    /**
+     * Serialize a single model instance with structural formatting
+     * Applies root wrapping and side-loading if configured
+     * @param model - The model instance to serialize
+     * @returns The serialized model with structural formatting applied
+     */
+    serialize<TSchema extends SchemaCollections>(model: ModelInstance<TTemplate, TSchema>): TSerializedModel;
+    /**
+     * Serialize raw data from a collection without structural wrapping
+     * Returns an array of serialized model data without root wrapping
+     * @param collection - The model collection to serialize
+     * @returns Array of serialized model data
+     */
+    serializeCollectionData<TSchema extends SchemaCollections>(collection: ModelCollection<TTemplate, TSchema>): Record<string, any>[];
+    /**
+     * Serialize a model collection with structural formatting
+     * Applies root wrapping and side-loading if configured
+     * @param collection - The model collection to serialize
+     * @returns The serialized collection with structural formatting applied
+     */
+    serializeCollection<TSchema extends SchemaCollections>(collection: ModelCollection<TTemplate, TSchema>): TSerializedCollection;
+    /**
+     * Get the attributes to include in serialization
+     * Can be overridden in subclasses for custom serialization logic
+     * @param model - The model instance
+     * @returns Object with attributes
+     */
+    protected _getAttributes<TSchema extends SchemaCollections>(model: ModelInstance<TTemplate, TSchema>): Record<string, any>;
+    /**
+     * Get relationships to include in serialization
+     * Returns embedded relationships, side-loaded relationships, and foreign keys
+     * @param model - The model instance
+     * @returns Object with embedded, sideLoaded, and foreignKeys
+     */
+    protected _getRelationships<TSchema extends SchemaCollections>(model: ModelInstance<TTemplate, TSchema>): {
+        embedded: Record<string, any>;
+        sideLoaded: Record<string, any>;
+        foreignKeys: string[];
+    };
+}
+
+/**
+ * Seed function that accepts a schema instance
+ * @template TSchema - The schema collections type
+ */
+type SeedFunction<TSchema extends SchemaCollections = SchemaCollections> = (schema: SchemaInstance<TSchema>) => void | Promise<void>;
+/**
+ * Named seed scenarios - object with named seed methods
+ * @template TSchema - The schema collections type
+ */
+type SeedScenarios<TSchema extends SchemaCollections = SchemaCollections> = Record<string, SeedFunction<TSchema>>;
+/**
+ * Seeds configuration - can be a function or object with named scenarios
+ * @template TSchema - The schema collections type
+ */
+type Seeds<TSchema extends SchemaCollections = SchemaCollections> = SeedFunction<TSchema> | SeedScenarios<TSchema>;
+/**
+ * Strategy for loading fixtures
+ * - 'auto': Load fixtures automatically during schema setup
+ * - 'manual': Load fixtures manually by calling loadFixtures()
+ */
+type FixtureLoadStrategy = 'auto' | 'manual';
+/**
+ * A single fixture attributes object - matches the model attributes with optional foreign keys
+ * @template TTemplate - The model template
+ * @template TRelationships - The model relationships
+ */
+type FixtureAttrs<TTemplate extends ModelTemplate, TRelationships extends ModelRelationships = {}> = ModelAttrs<TTemplate> & (Record<string, never> extends TRelationships ? {} : Partial<ModelForeignKeys<TRelationships>>);
+/**
+ * Fixture configuration for a collection
+ * @template TTemplate - The model template
+ * @template TRelationships - The model relationships
+ */
+interface FixtureConfig<TTemplate extends ModelTemplate, TRelationships extends ModelRelationships = {}> {
+    /**
+     * Array of fixture attributes to load
+     */
+    records: FixtureAttrs<TTemplate, TRelationships>[];
+    /**
+     * When to load the fixtures (default: 'manual')
+     */
+    strategy?: FixtureLoadStrategy;
+}
+/**
+ * Global schema configuration
+ * @template TIdentityManager - The identity manager type
+ * @template TGlobalConfig - The global serializer configuration type
+ */
+interface SchemaConfig<TIdentityManager extends IdentityManager = StringIdentityManager, TGlobalConfig extends StructuralSerializerOptions | undefined = undefined> {
+    identityManager?: TIdentityManager;
+    globalSerializerConfig?: TGlobalConfig;
+    logging?: LoggerConfig;
+}
+/**
+ * Type for collection config
+ * @template TTemplate - The model template
+ * @template TRelationships - The model relationships
+ * @template TFactory - The factory type
+ * @template TSerializer - The serializer instance type
+ * @template TSchema - The schema collections type for seeds typing
+ */
+interface CollectionConfig<TTemplate extends ModelTemplate, TRelationships extends ModelRelationships = {}, TFactory extends Factory<TTemplate, any, any> | undefined = undefined, TSerializer = undefined, TSchema extends SchemaCollections = SchemaCollections> {
+    model: TTemplate;
+    factory?: TFactory;
+    relationships?: TRelationships;
+    identityManager?: IdentityManager<ModelId<TTemplate>>;
+    /**
+     * Serializer configuration object (attrs, root, embed, include)
+     * Used when collection().serializer({...config}) is called
+     */
+    serializerConfig?: SerializerOptions<TTemplate>;
+    /**
+     * Serializer instance (custom serializer class)
+     * Used when collection().serializer(instance) is called
+     */
+    serializerInstance?: TSerializer;
+    /**
+     * Seeds configuration - can be a function or object with named scenarios
+     * Used when collection().seeds(...) is called
+     */
+    seeds?: Seeds<TSchema>;
+    /**
+     * Fixtures configuration - static data to load into the collection
+     * Used when collection().fixtures(...) is called
+     */
+    fixtures?: FixtureConfig<TTemplate, TRelationships>;
+}
+/**
+ * Type for schema collections - provides both string-based property access and symbol-based relationship resolution
+ * @template TCollections - The string-keyed schema collections config
+ */
+type SchemaCollections = Record<string, CollectionConfig<any, any, any, any, any>>;
+/**
+ * Type for schema collections - provides string-based property access
+ * @template TCollections - The string-keyed schema collections config
+ */
+type SchemaCollectionAccessors<TCollections extends SchemaCollections> = {
+    [K in keyof TCollections]: TCollections[K] extends CollectionConfig<infer TTemplate, infer TRelationships, infer TFactory, infer TSerializer, any> ? Collection<TCollections, TTemplate, TRelationships, TFactory, TSerializer> : never;
+};
+/**
+ * Maps schema collection configs to database collections with inferred foreign keys
+ * This ensures that database records include foreign key fields based on defined relationships
+ */
+type SchemaDbCollections<TCollections extends SchemaCollections> = {
+    [K in keyof TCollections]: TCollections[K] extends CollectionConfig<infer TTemplate, infer TRelationships, any, any, any> ? DbCollection<ModelAttrs<TTemplate> & (TRelationships extends ModelRelationships ? ModelForeignKeys<TRelationships> : {})> : never;
+};
+/**
+ * Type for collection create/factory attributes - all attributes are optional
+ * Used for passing attributes to create() methods where factory provides defaults
+ * @template TTemplate - The model template
+ * @template TSchema - The schema collections type
+ * @template TRelationships - The model relationships
+ */
+type CollectionCreateAttrs<TTemplate extends ModelTemplate, TSchema extends SchemaCollections = SchemaCollections, TRelationships extends ModelRelationships = RelationshipsByTemplate<TTemplate, TSchema>> = Partial<ModelAttrs<TTemplate, TSchema>> & (Record<string, never> extends TRelationships ? {} : Partial<RelatedModelAttrs<TSchema, TRelationships>>);
+/**
+ * Simplified Collection instance type helper that only requires the template parameter.
+ * Useful for typing collection references without verbose generic parameters.
+ * @template TTemplate - The model template (required)
+ * @template TRelationships - The model relationships (optional, defaults to {})
+ * @template TFactory - The factory type (optional, defaults to undefined)
+ * @template TSerializer - The serializer type (optional, defaults to undefined)
+ * @example
+ * ```typescript
+ * import { CollectionInstance } from '@miragejs/orm';
+ *
+ * // Simple usage
+ * const usersCollection: CollectionInstance<typeof userModel> = schema.users;
+ *
+ * // With relationships
+ * const usersCollection: CollectionInstance<
+ *   typeof userModel,
+ *   { posts: HasMany<typeof postModel> }
+ * > = schema.users;
+ * ```
+ */
+type CollectionInstance<TTemplate extends ModelTemplate, TRelationships extends ModelRelationships = {}, TFactory extends Factory<TTemplate, SchemaCollections, ModelTraits<SchemaCollections, TTemplate>> | undefined = undefined, TSerializer = undefined> = Collection<SchemaCollections, TTemplate, TRelationships, TFactory, TSerializer>;
+
+/**
+ * Collection for managing models of a specific type
+ * @template TSchema - The schema collections type for enhanced type inference
+ * @template TTemplate - The model template type (most important for users)
+ * @template TRelationships - The raw relationships configuration for this collection (inferred from config)
+ * @template TFactory - The factory type (inferred from config)
+ * @template TSerializer - The serializer type (inferred from config)
+ */
+declare class Collection<TSchema extends SchemaCollections = SchemaCollections, TTemplate extends ModelTemplate = ModelTemplate, TRelationships extends ModelRelationships = {}, TFactory extends Factory<TTemplate, TSchema, ModelTraits<TSchema, TTemplate>> | undefined = undefined, TSerializer = undefined> extends BaseCollection<TSchema, TTemplate, TRelationships, TFactory, TSerializer> {
+    /**
+     * Creates a new model instance (not persisted in the database).
+     * @param attrs - The attributes to create the model with. All required attributes must be provided.
+     * @returns The new model instance.
+     */
+    new(attrs: ModelCreateAttrs<TTemplate, TSchema>): NewModelInstance<TTemplate, TSchema, TSerializer>;
+    /**
+     * Create a new model for the collection.
+     * @param traitsAndDefaults - The traits or default values to use for the model.
+     * @returns The new model instance.
+     */
+    create(...traitsAndDefaults: (FactoryTraitNames<TFactory> | CollectionCreateAttrs<TTemplate, TSchema>)[]): ModelInstance<TTemplate, TSchema, TSerializer>;
+    /**
+     * Create a list of models for the collection.
+     * @param count - The number of models to create.
+     * @param traitsAndDefaults - The traits or default values to use for the models.
+     * @returns A list of model instances.
+     */
+    createList(count: number, ...traitsAndDefaults: (FactoryTraitNames<TFactory> | CollectionCreateAttrs<TTemplate, TSchema>)[]): ModelCollection<TTemplate, TSchema, TSerializer>;
+    /**
+     * Finds the first model matching the query or creates a new one.
+     * @param query - The query to find the model by.
+     * @param traitsAndDefaults - The traits or default values to use when creating a new model.
+     * @returns The model instance.
+     */
+    findOrCreateBy(query: DbRecordInput<ModelAttrs<TTemplate, TSchema>>, ...traitsAndDefaults: (FactoryTraitNames<TFactory> | CollectionCreateAttrs<TTemplate, TSchema>)[]): ModelInstance<TTemplate, TSchema, TSerializer>;
+    /**
+     * Finds or creates a specific number of models matching the query.
+     * @param count - The number of models to find or create.
+     * @param query - The query to find the models by (object or predicate function).
+     * @param traitsAndDefaults - The traits or default values to use when creating new models.
+     * @returns A collection of models.
+     */
+    findManyOrCreateBy(count: number, query: DbRecordInput<ModelAttrs<TTemplate, TSchema>> | ((model: ModelInstance<TTemplate, TSchema, TSerializer>) => boolean), ...traitsAndDefaults: (FactoryTraitNames<TFactory> | CollectionCreateAttrs<TTemplate, TSchema>)[]): ModelCollection<TTemplate, TSchema, TSerializer>;
+    /**
+     * Load seeds for this collection.
+     * If scenarioId is not provided, all seeds will be loaded (or 'default' if seeds is a function).
+     * If scenarioId is provided, only that specific seed scenario will be loaded.
+     * @param scenarioId - Optional scenario ID to load a specific seed
+     * @throws {MirageError} If the specified scenarioId does not exist
+     * @example
+     * ```typescript
+     * // Load all seeds
+     * collection.loadSeeds();
+     *
+     * // Load specific scenario
+     * collection.loadSeeds('userForm');
+     * ```
+     */
+    loadSeeds(scenarioId?: string): Promise<void>;
+    /**
+     * Load fixtures for this collection.
+     * Fixtures are static data records that will be inserted into the collection.
+     * This method will insert all fixture records into the database.
+     * @example
+     * ```typescript
+     * // Load all fixtures
+     * await collection.loadFixtures();
+     * ```
+     */
+    loadFixtures(): Promise<void>;
+}
+
+/**
+ * Schema class that manages database and collections
+ * @template TCollections - The type map of collection names to their configurations
+ * @template TConfig - The schema configuration type with identity manager and global serializer config
+ */
+declare class Schema<TCollections extends SchemaCollections, TConfig extends SchemaConfig<any, any> = SchemaConfig<StringIdentityManager, undefined>> {
+    readonly db: DbInstance<SchemaDbCollections<TCollections>>;
+    readonly identityManager: TConfig extends SchemaConfig<infer TIdentityManager, any> ? TIdentityManager : StringIdentityManager;
+    readonly logger?: Logger;
+    private _collections;
+    private _globalSerializerConfig?;
+    constructor(collections: TCollections, config?: TConfig);
+    /**
+     * Get a schema collection by collection name
+     * @param collectionName - The name of the collection
+     * @returns The schema collection for the collection with proper typing
+     */
+    getCollection<K extends keyof TCollections>(collectionName: K): TCollections[K] extends CollectionConfig<infer TTemplate, infer TRelationships, infer TFactory, infer TSerializer, any> ? Collection<TCollections, TTemplate, TRelationships, TFactory, TSerializer> : never;
+    /**
+     * Load all seeds for all collections in the schema.
+     * This will run all seed scenarios for each collection.
+     * To load specific scenarios, use collection.loadSeeds(scenarioId) on individual collections.
+     * @example
+     * ```typescript
+     * // Load all seeds for all collections
+     * await schema.loadSeeds();
+     *
+     * // Or load specific scenario for a single collection
+     * await schema.users.loadSeeds('development');
+     * ```
+     */
+    loadSeeds(): Promise<void>;
+    /**
+     * Load all fixtures for all collections in the schema.
+     * This will insert all fixture records into each collection's database.
+     * @example
+     * ```typescript
+     * // Load all fixtures for all collections
+     * await schema.loadFixtures();
+     * ```
+     */
+    loadFixtures(): Promise<void>;
+    /**
+     * Register collections from the configuration
+     * @param collections - Collection configurations to register
+     */
+    private _registerCollections;
+    /**
+     * Validate that all inverse relationships are correctly defined
+     * This checks that explicit inverse relationships exist and point back correctly
+     * @param collections - The schema collections to validate
+     * @private
+     */
+    private _validateInverseRelationships;
+    /**
+     * Merge global serializer config with collection-specific config
+     * Collection config values override global config values
+     * @param _template - The model template (used for type inference only)
+     * @param collectionConfig - Collection-specific serializer config
+     * @returns Merged serializer config or undefined if both are undefined
+     */
+    private _mergeConfigs;
+}
+/**
+ * Type for a complete schema instance with collections
+ * Provides both string-based property access and symbol-based relationship resolution
+ */
+type SchemaInstance<TCollections extends SchemaCollections, TConfig extends SchemaConfig<any, any> = SchemaConfig<StringIdentityManager, undefined>> = Schema<TCollections, TConfig> & SchemaCollectionAccessors<TCollections>;
+
+/**
+ * Base collection class with query functionality.
+ * @template TSchema - The schema collections type for enhanced type inference
+ * @template TTemplate - The model template type (most important for users)
+ * @template TRelationships - The raw relationships configuration for this collection (inferred from config)
+ * @template TFactory - The factory type (inferred from config)
+ * @template TSerializer - The serializer type (inferred from config)
+ */
+declare abstract class BaseCollection<TSchema extends SchemaCollections = SchemaCollections, TTemplate extends ModelTemplate = ModelTemplate, TRelationships extends ModelRelationships = {}, TFactory extends Factory<TTemplate, TSchema, ModelTraits<TSchema, TTemplate>> | undefined = undefined, TSerializer = undefined> {
+    readonly modelName: string;
+    readonly collectionName: string;
+    protected readonly Model: ModelClass<TTemplate, TSchema, TSerializer>;
+    protected readonly _template: TTemplate;
+    protected readonly _schema: SchemaInstance<TSchema>;
+    protected readonly _dbCollection: DbCollection<ModelAttrs<TTemplate, TSchema>>;
+    protected readonly _identityManager: IdentityManager<ModelAttrs<TTemplate, TSchema>['id']>;
+    protected readonly _logger?: Logger;
+    protected readonly _factory?: TFactory;
+    protected readonly _relationships?: TRelationships;
+    protected readonly _serializer?: TSerializer;
+    protected readonly _seeds?: Seeds<TSchema>;
+    protected readonly _fixtures?: FixtureConfig<TTemplate, TRelationships>;
+    constructor(schema: SchemaInstance<TSchema>, config: {
+        factory?: TFactory;
+        identityManager?: IdentityManager<ModelId<TTemplate>>;
+        model: TTemplate;
+        relationships?: TRelationships;
+        serializer?: TSerializer;
+        seeds?: Seeds<TSchema>;
+        fixtures?: FixtureConfig<TTemplate, TRelationships>;
+    });
+    /**
+     * Get the collection relationships.
+     * @returns The collection relationships configuration.
+     */
+    get relationships(): TRelationships | undefined;
+    /**
+     * Get the serializer for the collection.
+     * @returns The collection serializer instance.
+     */
+    get serializer(): TSerializer | undefined;
+    /**
+     * Get a model by index.
+     * @param index - The index of the model to get.
+     * @returns The model instance or undefined if not found.
+     */
+    at(index: number): ModelInstance<TTemplate, TSchema, TSerializer> | undefined;
+    /**
+     * Returns all model instances in the collection.
+     * @returns All model instances in the collection.
+     */
+    all(): ModelCollection<TTemplate, TSchema, TSerializer>;
+    /**
+     * Returns the first model in the collection.
+     * @returns The first model in the collection or null if the collection is empty.
+     */
+    first(): ModelInstance<TTemplate, TSchema, TSerializer> | null;
+    /**
+     * Returns the last model in the collection.
+     * @returns The last model in the collection or null if the collection is empty.
+     */
+    last(): ModelInstance<TTemplate, TSchema, TSerializer> | null;
+    /**
+     * Finds a model by ID, predicate object, or query options.
+     * @param input - The ID, predicate object, or query options to find by.
+     * @returns The model instance or null if not found.
+     * @example
+     * ```typescript
+     * // Find by ID
+     * collection.find('1');
+     *
+     * // Find by predicate object
+     * collection.find({ email: 'user@example.com' });
+     *
+     * // Find with query options
+     * collection.find({ where: { age: { gte: 18 } }, orderBy: { name: 'asc' } });
+     * ```
+     */
+    find(input: ModelAttrs<TTemplate, TSchema>['id'] | DbRecordInput<ModelAttrs<TTemplate, TSchema>> | QueryOptions<ModelAttrs<TTemplate, TSchema>>): ModelInstance<TTemplate, TSchema, TSerializer> | null;
+    /**
+     * Finds multiple models by IDs, predicate object, or query options.
+     * @param input - The array of IDs, predicate object, or query options to find by.
+     * @returns A collection of matching model instances.
+     * @example
+     * ```typescript
+     * // Find by IDs
+     * collection.findMany(['1', '2', '3']);
+     *
+     * // Find by predicate object
+     * collection.findMany({ status: 'active' });
+     *
+     * // Find with query options
+     * collection.findMany({
+     *   where: { age: { gte: 18 } },
+     *   orderBy: { name: 'asc' },
+     *   limit: 10
+     * });
+     *
+     * // Find with callback where clause
+     * collection.findMany({
+     *   where: (model) => model.age >= 18 && model.status === 'active'
+     * });
+     * ```
+     */
+    findMany(input: ModelAttrs<TTemplate, TSchema>['id'][] | DbRecordInput<ModelAttrs<TTemplate, TSchema>> | QueryOptions<ModelAttrs<TTemplate, TSchema>>): ModelCollection<TTemplate, TSchema, TSerializer>;
+    /**
+     * Deletes a model from the collection.
+     * @param id - The id of the model to delete.
+     */
+    delete(id: ModelAttrs<TTemplate, TSchema>['id']): void;
+    /**
+     * Deletes multiple models by IDs, predicate object, or query options.
+     * @param input - The array of IDs, predicate object, or query options to delete by.
+     * @returns The number of records that were deleted.
+     * @example
+     * ```typescript
+     * // Delete by IDs
+     * collection.deleteMany(['1', '2', '3']);
+     *
+     * // Delete by predicate object
+     * collection.deleteMany({ status: 'inactive' });
+     *
+     * // Delete with query options
+     * collection.deleteMany({
+     *   where: { age: { lt: 18 } },
+     *   limit: 10
+     * });
+     * ```
+     */
+    deleteMany(input: ModelAttrs<TTemplate, TSchema>['id'][] | DbRecordInput<ModelAttrs<TTemplate, TSchema>> | QueryOptions<ModelAttrs<TTemplate, TSchema>>): number;
+    /**
+     * Converts QueryOptions with a callback where clause to work with models instead of raw records.
+     * @param options - The query options with a callback where clause
+     * @returns Query options with converted where clause
+     */
+    private _convertQueryOptionsCallback;
+    /**
+     * Helper to create a model instance from a database record.
+     * @param record - The database record to create the model from (must have ID).
+     * @returns The model instance.
+     */
+    protected _createModelFromRecord(record: ModelAttrs<TTemplate, TSchema>): ModelInstance<TTemplate, TSchema, TSerializer>;
+    /**
+     * Initialize and create the database collection if needed
+     * @param identityManager - The identity manager to use for the collection
+     * @returns The database collection instance
+     * @private
+     */
+    private _initializeDbCollection;
+}
+
+/**
+ * A fluent builder for creating schema collection configurations.
+ *
+ * The CollectionBuilder provides a type-safe way to construct CollectionConfig instances
+ * with configurable model template, factory, relationships, serializer, and identity manager. It follows
+ * the builder pattern, allowing method chaining to progressively configure the collection.
+ * @template TTemplate - The model template type
+ * @template TRelationships - The model relationships configuration
+ * @template TFactory - The factory type
+ * @template TIdentityManager - The identity manager type
+ * @example
+ * ```typescript
+ * const userCollection = collection(UserModel)
+ *   .relationships({
+ *     posts: associations.hasMany(PostModel),
+ *   })
+ *   .factory(userFactory)
+ *   .identityManager(userIdentityManager)
+ *   .create();
+ * ```
+ */
+declare class CollectionBuilder<TTemplate extends ModelTemplate = ModelTemplate, TSchema extends SchemaCollections = SchemaCollections, TRelationships extends ModelRelationships = {}, TFactory extends Factory<TTemplate, TSchema, ModelTraits<TSchema, TTemplate>> | undefined = undefined, TIdentityManager extends IdentityManager = StringIdentityManager, TSerializer = undefined> {
+    private _template?;
+    private _factory?;
+    private _relationships?;
+    private _identityManager?;
+    private _serializerConfig?;
+    private _serializerInstance?;
+    private _seeds?;
+    private _fixtures?;
+    /**
+     * Creates a new CollectionBuilder instance.
+     * @private
+     */
+    constructor();
+    /**
+     * Sets the model template for this collection.
+     *
+     * The template defines the model type, and collection name
+     * for this collection configuration.
+     * @template T - The model template type
+     * @param template - The model template instance
+     * @returns A new CollectionBuilder instance with the specified template
+     * @example
+     * ```typescript
+     * const builder = collection.model(userTemplate);
+     * ```
+     */
+    model<T extends ModelTemplate>(template: T): CollectionBuilder<T, TSchema, TRelationships, TFactory extends undefined ? undefined : Factory<T, TSchema, ModelTraits<TSchema, T>>, TIdentityManager, TSerializer>;
+    /**
+     * Sets the factory for creating model instances.
+     *
+     * The factory provides default attributes and traits for creating new model instances
+     * in this collection.
+     * @template F - The factory type
+     * @param factory - The factory instance
+     * @returns A new CollectionBuilder instance with the specified factory
+     * @example
+     * ```typescript
+     * const builder = collection(UserModel).factory(userFactory);
+     * ```
+     */
+    factory<F extends Factory<any, any, any>>(factory: F): CollectionBuilder<TTemplate, TSchema, TRelationships, F, TIdentityManager, TSerializer>;
+    /**
+     * Sets the relationships configuration for this collection.
+     *
+     * Relationships define how this model relates to other models in the schema,
+     * including belongsTo and hasMany associations.
+     * @template R - The relationships type
+     * @param relationships - The relationships configuration object
+     * @returns A new CollectionBuilder instance with the specified relationships
+     * @example
+     * ```typescript
+     * const builder = collection(UserModel)
+     *   .relationships({
+     *     posts: associations.hasMany(PostModel),
+     *     profile: associations.belongsTo(profileTemplate),
+     *   });
+     * ```
+     */
+    relationships<R extends ModelRelationships>(relationships: R): CollectionBuilder<TTemplate, TSchema, R, TFactory, TIdentityManager, TSerializer>;
+    /**
+     * Sets the serializer configuration or instance for this collection.
+     *
+     * Accepts either a configuration object (attrs, root, embed, include) or a custom
+     * serializer instance. The config will be merged with global schema config if present.
+     * @param configOrSerializer - The serializer configuration object or instance
+     * @returns A new CollectionBuilder instance with the specified serializer
+     * @example
+     * ```typescript
+     * // With config
+     * const builder = collection()
+     *   .model(UserModel)
+     *   .serializer({ attrs: ['id', 'name'], root: true });
+     *
+     * // With custom serializer instance
+     * const builder = collection()
+     *   .model(UserModel)
+     *   .serializer(new CustomUserSerializer(userModel));
+     * ```
+     */
+    serializer(configOrSerializer: SerializerOptions<TTemplate> | any): CollectionBuilder<TTemplate, TSchema, TRelationships, TFactory, TIdentityManager, any>;
+    /**
+     * Sets the identity manager for this collection.
+     *
+     * The identity manager handles ID generation and management for model instances
+     * in this collection. If not specified, the schema's global identity manager will be used.
+     * @template I - The identity manager type
+     * @param identityManager - The identity manager instance
+     * @returns A new CollectionBuilder instance with the specified identity manager
+     * @example
+     * ```typescript
+     * const builder = collection
+     *   .model(UserModel)
+     *   .identityManager(new StringIdentityManager());
+     * ```
+     */
+    identityManager<I extends IdentityManager<any>>(identityManager: I): CollectionBuilder<TTemplate, TSchema, TRelationships, TFactory, I, TSerializer>;
+    /**
+     * Sets the seeds configuration for this collection.
+     *
+     * Seeds can be either a function or an object with named seed scenarios.
+     * The function/methods receive the schema instance as a parameter.
+     * @param seeds - A seed function or object with named seed scenarios
+     * @returns A new CollectionBuilder instance with the specified seeds
+     * @example
+     * ```typescript
+     * // With function
+     * const builder = collection()
+     *   .model(UserModel)
+     *   .seeds((schema) => {
+     *     schema.users.create({ name: 'John' });
+     *   });
+     *
+     * // With named scenarios
+     * const builder = collection()
+     *   .model(UserModel)
+     *   .seeds({
+     *     userForm: (schema) => {
+     *       schema.users.create({ name: 'John' });
+     *     },
+     *     userPosts: (schema) => {
+     *       const user = schema.users.create({ name: 'John' });
+     *       schema.posts.create({ title: 'Post 1', authorId: user.id });
+     *     },
+     *   });
+     * ```
+     */
+    seeds(seeds: Seeds<TSchema>): CollectionBuilder<TTemplate, TSchema, TRelationships, TFactory, TIdentityManager, TSerializer>;
+    /**
+     * Sets the fixtures configuration for this collection.
+     *
+     * Fixtures are static data records that can be loaded into the collection.
+     * @param records - Array of fixture records to load
+     * @param options - Configuration options for loading fixtures
+     * @param options.strategy - The strategy to use for loading fixtures (default: 'manual')
+     * @returns A new CollectionBuilder instance with the specified fixtures
+     * @example
+     * ```typescript
+     * // Manual loading (default)
+     * const builder = collection()
+     *   .model(UserModel)
+     *   .fixtures([
+     *     { id: '1', name: 'John', email: 'john@example.com' },
+     *     { id: '2', name: 'Jane', email: 'jane@example.com' },
+     *   ]);
+     *
+     * // Auto-load fixtures during schema setup
+     * const builder = collection()
+     *   .model(UserModel)
+     *   .fixtures(
+     *     [
+     *       { id: '1', name: 'John', email: 'john@example.com' },
+     *       { id: '2', name: 'Jane', email: 'jane@example.com' },
+     *     ],
+     *     { strategy: 'auto' }
+     *   );
+     * ```
+     */
+    fixtures(records: FixtureAttrs<TTemplate, TRelationships>[], options?: {
+        strategy?: FixtureLoadStrategy;
+    }): CollectionBuilder<TTemplate, TSchema, TRelationships, TFactory, TIdentityManager, TSerializer>;
+    /**
+     * Creates the final schema collection configuration.
+     * @returns The schema collection configuration
+     */
+    create(): CollectionConfig<TTemplate, TRelationships, TFactory, TSerializer, TSchema>;
+}
+/**
+ * Creates a new CollectionBuilder instance for building collection configurations.
+ * @template TSchema - The schema collections type (optional)
+ * @returns A new CollectionBuilder instance ready for model specification
+ * @example
+ * ```typescript
+ * // Schema-typed collection
+ * const userCollection = collection<TestSchema>()
+ *   .model(UserModel)
+ *   .factory(userFactory)
+ *   .create();
+ *
+ * // Schema-less collection
+ * const userCollection = collection()
+ *   .model(UserModel)
+ *   .create();
+ * ```
+ */
+declare function collection<TSchema extends SchemaCollections = SchemaCollections>(): CollectionBuilder<ModelTemplate, TSchema, {}, undefined, StringIdentityManager, undefined>;
+
+/**
+ * A fluent builder for creating schema instances.
+ *
+ * The SchemaBuilder provides a type-safe way to construct Schema instances with
+ * configurable collections, identity manager, and global serializer. It follows the builder
+ * pattern, allowing method chaining to progressively configure the schema.
+ * @template TCollections - The schema collections configuration type
+ * @template TIdentityManager - The global identity manager type
+ * @template TGlobalConfig - The global serializer configuration type
+ * @example
+ * ```typescript
+ * const appSchema = schema()
+ *   .collections({
+ *     users: userCollection,
+ *     posts: postCollection,
+ *   })
+ *   .serializer({ root: true })
+ *   .identityManager(appIdentityManager)
+ *   .setup();
+ * ```
+ */
+declare class SchemaBuilder<TCollections extends SchemaCollections = SchemaCollections, TIdentityManager extends IdentityManager<any> = StringIdentityManager, TGlobalConfig extends StructuralSerializerOptions | undefined = undefined> {
+    private _collections?;
+    private _identityManager?;
+    private _globalSerializerConfig?;
+    private _loggingConfig?;
+    /**
+     * Creates a new SchemaBuilder instance.
+     * @private
+     */
+    constructor();
+    /**
+     * Sets the collections configuration for this schema.
+     *
+     * Collections define the models, factories, relationships, and other configuration
+     * for each collection in the schema. Each collection is keyed by its collection name.
+     * @template C - The collections configuration type
+     * @param collections - The collections configuration object
+     * @returns A new SchemaBuilder instance with the specified collections
+     * @example
+     * ```typescript
+     * const builder = schema().collections({
+     *   users: userCollection,
+     *   posts: postCollection,
+     *   comments: commentCollection,
+     * });
+     * ```
+     */
+    collections<C extends SchemaCollections>(collections: C): SchemaBuilder<C, TIdentityManager, TGlobalConfig>;
+    /**
+     * Sets the global identity manager for this schema.
+     *
+     * The identity manager handles ID generation and management for model instances
+     * across all collections in the schema. Individual collections can override this
+     * with their own identity managers.
+     * @template I - The identity manager type
+     * @param identityManager - The identity manager instance
+     * @returns A new SchemaBuilder instance with the specified identity manager
+     * @example
+     * ```typescript
+     * const builder = schema()
+     *   .collections({ users: userCollection })
+     *   .identityManager(new StringIdentityManager());
+     * ```
+     */
+    identityManager<I extends IdentityManager<any>>(identityManager: I): SchemaBuilder<TCollections, I, TGlobalConfig>;
+    /**
+     * Sets the global serializer configuration for this schema.
+     *
+     * The global serializer config defines structural serialization options (root, embed)
+     * that apply to all collections by default. Individual collections can override
+     * these settings or provide model-specific configuration (attrs, include).
+     * @template TConfig - The global serializer configuration type
+     * @param config - The global serializer configuration (only root and embed)
+     * @returns A new SchemaBuilder instance with the specified global serializer config
+     * @example
+     * ```typescript
+     * const builder = schema()
+     *   .serializer({ root: true, embed: false })
+     *   .collections({ users: userCollection });
+     * ```
+     */
+    serializer<TConfig extends StructuralSerializerOptions>(config: TConfig): SchemaBuilder<TCollections, TIdentityManager, TConfig>;
+    /**
+     * Sets the logging configuration for this schema.
+     *
+     * The logging config enables debug output for database operations, validations,
+     * and other schema behavior. This is useful for debugging test setup and understanding
+     * how the ORM is behaving.
+     * @param config - The logging configuration (enabled, level, prefix)
+     * @returns A new SchemaBuilder instance with the specified logging config
+     * @example
+     * ```typescript
+     * const builder = schema()
+     *   .logging({ enabled: true, level: 'debug' })
+     *   .collections({ users: userCollection });
+     * ```
+     */
+    logging(config: LoggerConfig): SchemaBuilder<TCollections, TIdentityManager, TGlobalConfig>;
+    /**
+     * Sets up the final Schema instance with all configured options.
+     *
+     * This method produces the complete schema instance that can be used throughout
+     * your application. Collections must be set before calling setup().
+     * @returns The configured Schema instance with collection accessors
+     * @throws Error if no collections have been configured
+     * @example
+     * ```typescript
+     * const appSchema = schema()
+     *   .collections({
+     *     users: userCollection,
+     *     posts: postCollection,
+     *   })
+     *   .serializer({ root: true })
+     *   .identityManager(appIdentityManager)
+     *   .setup();
+     *
+     * // Use the schema
+     * const userCollection = appSchema.getCollection('users');
+     * const user = appSchema.users.create({ name: 'John' });
+     * ```
+     */
+    setup(): SchemaInstance<TCollections, SchemaConfig<TIdentityManager, TGlobalConfig>>;
+}
+/**
+ * Creates a new SchemaBuilder instance for building schema configurations.
+ *
+ * This is the main entry point for creating schemas in the builder-based API.
+ * The returned SchemaBuilder can be configured with collections and identity manager
+ * before setting up the final schema instance.
+ * @returns A new SchemaBuilder instance ready for configuration
+ * @example
+ * ```typescript
+ * // Basic schema creation
+ * const appSchema = schema()
+ *   .collections({
+ *     users: userCollection,
+ *   })
+ *   .setup();
+ *
+ * // Full schema configuration
+ * const appSchema = schema()
+ *   .collections({
+ *     users: userCollection,
+ *     posts: postCollection,
+ *   })
+ *   .identityManager(new StringIdentityManager())
+ *   .setup();
+ * ```
+ * @see {@link SchemaBuilder} for available configuration methods
+ */
+declare function schema(): SchemaBuilder;
+
+type FactoryAfterCreateHook<TSchema extends SchemaCollections = SchemaCollections, TTemplate extends ModelTemplate = ModelTemplate> = (model: ModelInstance<TTemplate, TSchema>, schema: SchemaInstance<TSchema>) => void;
+type TraitDefinition<TSchema extends SchemaCollections = SchemaCollections, TTemplate extends ModelTemplate = ModelTemplate> = Partial<FactoryAttrs<TTemplate>> & Partial<FactoryAssociations<TTemplate, TSchema>> & {
+    afterCreate?: FactoryAfterCreateHook<TSchema, TTemplate>;
+};
+type ModelTraits<TSchema extends SchemaCollections = SchemaCollections, TTemplate extends ModelTemplate = ModelTemplate> = Record<string, TraitDefinition<TSchema, TTemplate>>;
+type TraitName<TTraits> = TTraits extends Record<string, any> ? Extract<keyof TTraits, string> : never;
+type FactoryAttrs<TTemplate extends ModelTemplate> = {
+    [K in keyof ModelOnlyAttrs<TTemplate>]?: ModelOnlyAttrs<TTemplate>[K] | ((this: ModelOnlyAttrs<TTemplate>, modelId: NonNullable<ModelAttrs<TTemplate>['id']>) => InferModelAttrs<TTemplate>[K]);
+};
+type FactoryTraitNames<TFactory> = TFactory extends {
+    traits: infer TTraits;
+} ? TTraits extends Record<string, any> ? Extract<keyof TTraits, string> : never : never;
+
+/**
+ * Factory that builds model attributes with optional schema support.
+ * @template TTemplate - The model template (inferred from constructor)
+ * @template TSchema - The schema collections type (never = sch)
+ * @template TTraits - The factory traits (inferred from constructor)
+ */
+declare class Factory<TTemplate extends ModelTemplate = ModelTemplate, TSchema extends SchemaCollections = SchemaCollections, TTraits extends ModelTraits<TSchema, TTemplate> = {}> {
+    readonly attributes: FactoryAttrs<TTemplate>;
+    readonly traits: TTraits;
+    readonly associations?: FactoryAssociations<TTemplate, TSchema>;
+    readonly afterCreate?: FactoryAfterCreateHook<TSchema, TTemplate>;
+    private readonly _template;
+    private readonly _associationsManager;
+    constructor(template: TTemplate, attributes: FactoryAttrs<TTemplate>, traits?: TTraits, associations?: FactoryAssociations<TTemplate, TSchema>, afterCreate?: FactoryAfterCreateHook<TSchema, TTemplate>);
+    /**
+     * Get the model template
+     * @returns The model template
+     */
+    get template(): TTemplate;
+    /**
+     * Build a model with the given model ID and trait names or default values.
+     * @param modelId - The ID of the model to build.
+     * @param traitsAndDefaults - The names of the traits to apply or default values for attributes.
+     * @returns The built model.
+     */
+    build(modelId: ModelId<TTemplate>, ...traitsAndDefaults: (TraitName<TTraits> | PartialModelAttrs<TTemplate, TSchema>)[]): ModelAttrs<TTemplate, TSchema>;
+    /**
+     * Process associations and return relationship values
+     * This runs with schema context and creates/links related models
+     * @param schema - The schema instance
+     * @param skipKeys - Optional list of relationship keys to skip (e.g., if user provided them)
+     * @param traitsAndDefaults - Optional trait names to include trait associations
+     * @returns A record of relationship values
+     */
+    processAssociations(schema: SchemaInstance<TSchema>, skipKeys?: string[], traitsAndDefaults?: (TraitName<TTraits> | PartialModelAttrs<TTemplate, TSchema>)[]): Record<string, ModelInstance<any, TSchema> | ModelCollection<any, TSchema>>;
+    /**
+     * Process the afterCreate hook and the trait hooks.
+     * This method is intended to be called internally by schema collections.
+     * @param schema - The schema instance.
+     * @param model - The model to process.
+     * @param traitsAndDefaults - The traits and defaults that were applied.
+     * @returns The processed model.
+     */
+    processAfterCreateHooks(schema: SchemaInstance<TSchema>, model: ModelInstance<TTemplate, TSchema>, ...traitsAndDefaults: (TraitName<TTraits> | PartialModelAttrs<TTemplate, TSchema>)[]): ModelInstance<TTemplate, TSchema>;
+    private _processAttributes;
+    private _buildWithTraits;
+    /**
+     * Check if a value is an association object
+     * @param value - The value to check
+     * @returns True if the value is an association
+     */
+    private _isAssociation;
+    /**
+     * Extract associations from traits
+     * @param traitsAndDefaults - The trait names to extract associations from
+     * @returns The merged associations from all traits
+     */
+    private _getTraitAssociations;
+    private _mergeAttributes;
+    private _sortAttrs;
+}
+
+/**
+ * Builder class for creating factories with fluent API
+ * @template TTemplate - The model template
+ * @template TSchema - The schema collections type
+ * @template TTraits - The traits type
+ */
+declare class FactoryBuilder<TTemplate extends ModelTemplate = ModelTemplate, TSchema extends SchemaCollections = SchemaCollections, TTraits extends ModelTraits<TSchema, TTemplate> = {}> {
+    protected _template?: TTemplate;
+    protected _attributes: FactoryAttrs<TTemplate>;
+    protected _traits: TTraits;
+    protected _associations?: FactoryAssociations<TTemplate, TSchema>;
+    protected _afterCreate?: FactoryAfterCreateHook<TSchema, TTemplate>;
+    constructor();
+    /**
+     * Set the model template for the factory
+     * @template T - The model template type
+     * @param template - The model template
+     * @returns A new builder instance with the specified template
+     */
+    model<T extends ModelTemplate>(template: T): FactoryBuilder<T, TSchema, {}>;
+    /**
+     * Set the attributes for the factory
+     * @param attributes - The factory attributes
+     * @returns The builder instance for chaining
+     */
+    attrs(attributes: FactoryAttrs<TTemplate>): this;
+    /**
+     * Add traits to the factory
+     * @param traits - The traits to add
+     * @returns A new builder instance with the added traits
+     */
+    traits<T extends ModelTraits<TSchema, TTemplate>>(traits: T): FactoryBuilder<TTemplate, TSchema, TTraits & T>;
+    /**
+     * Set the afterCreate hook
+     * @param hook - The afterCreate hook function
+     * @returns The builder instance for chaining
+     */
+    afterCreate(hook: FactoryAfterCreateHook<TSchema, TTemplate>): this;
+    /**
+     * Set factory associations for automatic relationship creation
+     * @param associations - The associations configuration
+     * @returns The builder instance for chaining
+     */
+    associations(associations: FactoryAssociations<TTemplate, TSchema>): this;
+    /**
+     * Create a factory builder by extending an existing factory
+     * @param originalFactory - The factory to extend
+     * @returns A new factory builder based on the existing factory
+     */
+    extend<TTemplate extends ModelTemplate = ModelTemplate, TSchema extends SchemaCollections = SchemaCollections, TTraits extends ModelTraits<TSchema, TTemplate> = {}>(originalFactory: Factory<TTemplate, TSchema, TTraits>): FactoryBuilder<TTemplate, TSchema, TTraits>;
+    /**
+     * Build the final factory instance
+     * @returns The factory instance
+     */
+    create(): Factory<TTemplate, TSchema, TTraits>;
+}
+/**
+ * Create a factory builder with optional schema type
+ * @template TSchema - The schema collections type (optional)
+ * @returns Factory builder instance ready for model specification
+ */
+declare function factory<TSchema extends SchemaCollections>(): FactoryBuilder<ModelTemplate, TSchema, {}>;
+
+/**
+ * Extract the collection config for a model from the schema
+ * @template TSchema - The schema collections type
+ * @template TModel - The model template
+ * @internal
+ */
+type CollectionConfigFor<TSchema extends SchemaCollections, TModel extends ModelTemplate> = TSchema[InferCollectionName<TModel>];
+/**
+ * Extract the factory from a model's collection in the schema
+ * @template TSchema - The schema collections type
+ * @template TModel - The model template
+ * @internal
+ */
+type FactoryFor<TSchema extends SchemaCollections, TModel extends ModelTemplate> = CollectionConfigFor<TSchema, TModel> extends CollectionConfig<any, any, infer TFactory, any, any> ? TFactory : undefined;
+/**
+ * Extract valid trait names for a model from the schema
+ * @template TSchema - The schema collections type
+ * @template TModel - The model template
+ * @internal
+ */
+type TraitNamesFor<TSchema extends SchemaCollections, TModel extends ModelTemplate> = FactoryTraitNames<FactoryFor<TSchema, TModel>>;
+/**
+ * BelongsTo relationship - this model contains a foreign key to another model
+ * Example: Post belongsTo User (Post has authorId pointing to User.id)
+ * @template TTarget - The target model template this relationship points to
+ * @template TForeign - The foreign key field name (defaults to "{targetModelName}Id")
+ */
+type BelongsTo<TTarget extends ModelTemplate, TForeign extends string = `${InferModelName<TTarget>}Id`> = {
+    foreignKey: TForeign;
+    targetModel: TTarget;
+    type: 'belongsTo';
+    /**
+     * The name of the inverse relationship on the target model.
+     * - `undefined`: Auto-detect inverse relationship (default behavior)
+     * - `string`: Explicit inverse relationship name
+     * - `null`: No inverse relationship (disable synchronization)
+     */
+    inverse?: string | null;
+};
+/**
+ * HasMany relationship - this model can have multiple related models
+ * Example: User hasMany Posts (User has postIds array containing Post.id values)
+ * @template TTarget - The target model template this relationship points to
+ * @template TForeign - The foreign key array field name (defaults to "{targetModelName}Ids")
+ */
+type HasMany<TTarget extends ModelTemplate, TForeign extends string = `${InferModelName<TTarget>}Ids`> = {
+    foreignKey: TForeign;
+    targetModel: TTarget;
+    type: 'hasMany';
+    /**
+     * The name of the inverse relationship on the target model.
+     * - `undefined`: Auto-detect inverse relationship (default behavior)
+     * - `string`: Explicit inverse relationship name
+     * - `null`: No inverse relationship (disable synchronization)
+     */
+    inverse?: string | null;
+};
+/**
+ * All relationship types
+ */
+type Relationships = BelongsTo<any, any> | HasMany<any, any>;
+/**
+ * The type of factory association
+ */
+type AssociationType = 'create' | 'createMany' | 'link' | 'linkMany';
+/**
+ * Predicate function for filtering models in link/linkMany associations
+ * @template TModel - The model type to filter
+ */
+type AssociationQueryPredicate<TModel> = (model: TModel) => boolean;
+/**
+ * Query for finding models - can be an attributes object or a predicate function
+ * @template TModel - The model type to query
+ */
+type AssociationQuery<TModel = any> = Partial<TModel> | AssociationQueryPredicate<TModel>;
+/**
+ * Runtime storage for traits and defaults passed to factory associations.
+ * Type validation happens at the factory level through typed builder functions.
+ */
+type AssociationTraitsAndDefaults = Array<string | Record<string, any>>;
+/**
+ * Type-safe traits and defaults for a specific model in a schema.
+ * Validates trait names against the model's factory and ensures defaults match model attributes.
+ * @template TSchema - The schema collections type
+ * @template TModel - The model template
+ */
+type TypedAssociationTraitsAndDefaults<TSchema extends SchemaCollections, TModel extends ModelTemplate> = Array<TraitNamesFor<TSchema, TModel> | Partial<InferModelAttrs<TModel>>>;
+/**
+ * Base interface for all factory associations
+ * @template TModel - The model template to associate
+ */
+interface BaseAssociation<TModel extends ModelTemplate = ModelTemplate> {
+    /** The type of association */
+    type: AssociationType;
+    /** The model template to create or link */
+    model: TModel;
+    /** Optional relationship name - can be inferred from the key in FactoryAssociations */
+    relationshipName?: string;
+    /** Traits and defaults to apply when creating the associated model */
+    traitsAndDefaults?: AssociationTraitsAndDefaults;
+}
+/**
+ * Association that always creates one new related model
+ * @template TModel - The model template to create
+ */
+interface CreateAssociation<TModel extends ModelTemplate = ModelTemplate> extends BaseAssociation<TModel> {
+    type: 'create';
+}
+/**
+ * Association that always creates N new related models
+ * @template TModel - The model template to create
+ */
+interface CreateManyAssociation<TModel extends ModelTemplate = ModelTemplate> extends BaseAssociation<TModel> {
+    type: 'createMany';
+    /** Number of models to create */
+    count: number;
+}
+/**
+ * Association that tries to find an existing model, or creates one if not found
+ * @template TModel - The model template to link or create
+ */
+interface LinkAssociation<TModel extends ModelTemplate = ModelTemplate> extends BaseAssociation<TModel> {
+    type: 'link';
+    /** Optional query to find existing models */
+    query?: AssociationQuery;
+}
+/**
+ * Association that tries to find N existing models, or creates more if needed
+ * @template TModel - The model template to link or create
+ */
+interface LinkManyAssociation<TModel extends ModelTemplate = ModelTemplate> extends BaseAssociation<TModel> {
+    type: 'linkMany';
+    /** Number of models to link */
+    count: number;
+    /** Optional query to find existing models */
+    query?: AssociationQuery;
+}
+/**
+ * Union of all factory association types
+ * @template TModel - The model template
+ */
+type Association<TModel extends ModelTemplate = ModelTemplate> = CreateAssociation<TModel> | CreateManyAssociation<TModel> | LinkAssociation<TModel> | LinkManyAssociation<TModel>;
+/**
+ * Extract the target model template from a relationship
+ * @template TRelationship - The relationship type (BelongsTo or HasMany)
+ * @internal
+ */
+type RelationshipTargetTemplate<TRelationship> = TRelationship extends {
+    targetModel: infer TTarget;
+} ? TTarget extends ModelTemplate ? TTarget : never : never;
+/**
+ * Map of relationship names to factory associations for a model.
+ * Keys are constrained to actual relationship names defined for the model.
+ * Values must be associations for the correct target model of each relationship.
+ * @template TTemplate - The model template
+ * @template TSchema - The schema collections type
+ * @example
+ * ```typescript
+ * // Post has relationships: { author: BelongsTo<UserModel>, comments: HasMany<CommentModel> }
+ * const associations: FactoryAssociations<typeof postModel, AppSchema> = {
+ *   author: associations.create(userModel),      // ✓ Valid: author relationship exists
+ *   comments: associations.createMany(commentModel, 3), // ✓ Valid: comments relationship exists
+ *   tags: associations.link(tagModel)            // ✗ Error: no 'tags' relationship
+ * }
+ * ```
+ */
+type FactoryAssociations<TTemplate extends ModelTemplate, TSchema extends SchemaCollections = SchemaCollections> = RelationshipsByTemplate<TTemplate, TSchema> extends ModelRelationships ? {
+    [K in keyof RelationshipsByTemplate<TTemplate, TSchema>]?: Association<RelationshipTargetTemplate<RelationshipsByTemplate<TTemplate, TSchema>[K]>>;
+} : {};
+
+/**
+ * Define a belongs-to relationship.
+ * @param targetModel - The template of the model that is being related to.
+ * @param opts - The options for the relationship.
+ * @param opts.foreignKey - The foreign key of the relationship.
+ * @param opts.inverse - The name of the inverse relationship on the target model, or null to disable.
+ * @returns The relationship definition object.
+ * @example
+ * ```typescript
+ * // Auto-detect inverse
+ * author: belongsTo(userModel)
+ *
+ * // Explicit inverse
+ * author: belongsTo(userModel, { inverse: 'authoredPosts' })
+ *
+ * // No inverse (no synchronization)
+ * reviewer: belongsTo(userModel, { inverse: null })
+ * ```
+ */
+declare function belongsTo<TTarget extends ModelTemplate, const TOpts extends {
+    foreignKey?: string;
+    inverse?: string | null;
+} | undefined = undefined>(targetModel: TTarget, opts?: TOpts): BelongsTo<TTarget, TOpts extends {
+    foreignKey: infer F extends string;
+} ? F : `${InferModelName<TTarget>}Id`>;
+
+/**
+ * Always create one new related model and link it (with schema type for trait validation)
+ * @template TSchema - The schema collections type
+ * @template TModel - The model template (inferred from model parameter)
+ * @param model - Model template to create
+ * @param traitsAndDefaults - Traits and/or defaults to apply (variadic) - trait names are validated against schema
+ * @returns The create association
+ */
+declare function create<TSchema extends SchemaCollections, TModel extends ModelTemplate>(model: TModel, ...traitsAndDefaults: TypedAssociationTraitsAndDefaults<TSchema, TModel>): CreateAssociation<TModel>;
+/**
+ * Always create one new related model and link it (without schema type - traits not validated)
+ * @template TModel - The model template (inferred from model parameter)
+ * @param model - Model template to create
+ * @param traitsAndDefaults - Traits and/or defaults to apply (variadic) - trait names are strings
+ * @returns The create association
+ */
+declare function create<TModel extends ModelTemplate>(model: TModel, ...traitsAndDefaults: AssociationTraitsAndDefaults): CreateAssociation<TModel>;
+
+/**
+ * Always create N new related models and link them (with schema type for trait validation)
+ * @template TSchema - The schema collections type
+ * @template TModel - The model template (inferred from model parameter)
+ * @param model - Model template to create
+ * @param count - Number of models to create
+ * @param traitsAndDefaults - Traits and/or defaults to apply (variadic) - trait names are validated against schema
+ * @returns The create many association
+ */
+declare function createMany<TSchema extends SchemaCollections, TModel extends ModelTemplate>(model: TModel, count: number, ...traitsAndDefaults: TypedAssociationTraitsAndDefaults<TSchema, TModel>): CreateManyAssociation<TModel>;
+/**
+ * Always create N new related models and link them (without schema type - traits not validated)
+ * @template TModel - The model template (inferred from model parameter)
+ * @param model - Model template to create
+ * @param count - Number of models to create
+ * @param traitsAndDefaults - Traits and/or defaults to apply (variadic) - trait names are strings
+ * @returns The create many association
+ */
+declare function createMany<TModel extends ModelTemplate>(model: TModel, count: number, ...traitsAndDefaults: AssociationTraitsAndDefaults): CreateManyAssociation<TModel>;
+
+/**
+ * Define a has-many relationship.
+ * @param targetModel - The template of the model that is being related to.
+ * @param opts - The options for the relationship.
+ * @param opts.foreignKey - The foreign key of the relationship.
+ * @param opts.inverse - The name of the inverse relationship on the target model, or null to disable.
+ * @returns The relationship definition object.
+ * @example
+ * ```typescript
+ * // Auto-detect inverse
+ * posts: hasMany(postModel)
+ *
+ * // Explicit inverse
+ * authoredPosts: hasMany(postModel, { inverse: 'author' })
+ *
+ * // No inverse (no synchronization)
+ * archivedPosts: hasMany(postModel, { inverse: null })
+ * ```
+ */
+declare function hasMany<TTarget extends ModelTemplate, const TOpts extends {
+    foreignKey?: string;
+    inverse?: string | null;
+} | undefined = undefined>(targetModel: TTarget, opts?: TOpts): HasMany<TTarget, TOpts extends {
+    foreignKey: infer F extends string;
+} ? F : `${InferModelName<TTarget>}Ids`>;
+
+/**
+ * Try to find existing model, else create one (with schema type for trait validation)
+ * @template TSchema - The schema collections type
+ * @template TModel - The model template (inferred from model parameter)
+ * @param model - Model template to use
+ * @param query - Optional query to filter models (attributes object or predicate function)
+ * @param traitsAndDefaults - Traits and/or defaults to apply when creating (variadic) - trait names are validated against schema
+ * @returns The link association
+ */
+declare function link<TSchema extends SchemaCollections, TModel extends ModelTemplate>(model: TModel, query?: AssociationQuery<InferModelAttrs<TModel>>, ...traitsAndDefaults: TypedAssociationTraitsAndDefaults<TSchema, TModel>): LinkAssociation<TModel>;
+/**
+ * Try to find existing model, else create one (without schema type - traits not validated)
+ * @template TModel - The model template (inferred from model parameter)
+ * @param model - Model template to use
+ * @param query - Optional query to filter models (attributes object or predicate function)
+ * @param traitsAndDefaults - Traits and/or defaults to apply when creating (variadic) - trait names are strings
+ * @returns The link association
+ */
+declare function link<TModel extends ModelTemplate>(model: TModel, query?: AssociationQuery<InferModelAttrs<TModel>>, ...traitsAndDefaults: AssociationTraitsAndDefaults): LinkAssociation<TModel>;
+
+/**
+ * Try to find N existing models, else create more as needed (with schema type for trait validation)
+ * @template TSchema - The schema collections type
+ * @template TModel - The model template (inferred from model parameter)
+ * @param model - Model template to use
+ * @param count - Number of models needed
+ * @param query - Optional query to filter models (attributes object or predicate function)
+ * @param traitsAndDefaults - Traits and/or defaults to apply when creating (variadic) - trait names are validated against schema
+ * @returns The link many association
+ */
+declare function linkMany<TSchema extends SchemaCollections, TModel extends ModelTemplate>(model: TModel, count: number, query?: AssociationQuery<InferModelAttrs<TModel>>, ...traitsAndDefaults: TypedAssociationTraitsAndDefaults<TSchema, TModel>): LinkManyAssociation<TModel>;
+/**
+ * Try to find N existing models, else create more as needed (without schema type - traits not validated)
+ * @template TModel - The model template (inferred from model parameter)
+ * @param model - Model template to use
+ * @param count - Number of models needed
+ * @param query - Optional query to filter models (attributes object or predicate function)
+ * @param traitsAndDefaults - Traits and/or defaults to apply when creating (variadic) - trait names are strings
+ * @returns The link many association
+ */
+declare function linkMany<TModel extends ModelTemplate>(model: TModel, count: number, query?: AssociationQuery<InferModelAttrs<TModel>>, ...traitsAndDefaults: AssociationTraitsAndDefaults): LinkManyAssociation<TModel>;
+
+/**
+ * Associations object with all helper functions:
+ * - belongsTo, hasMany: for model relationship definitions
+ * - create, createMany, link, linkMany: for factory associations
+ */
+declare const associations: {
+    readonly belongsTo: typeof belongsTo;
+    readonly hasMany: typeof hasMany;
+    readonly create: typeof create;
+    readonly createMany: typeof createMany;
+    readonly link: typeof link;
+    readonly linkMany: typeof linkMany;
+};
+
+/**
+ * ModelRelationshipsManager - Handles all relationship operations
+ * Separated from core model logic for better maintainability
+ * @template TTemplate - The model template
+ * @template TSchema - The schema collections type
+ * @template TRelationships - The relationships configuration
+ */
+declare class RelationshipsManager<TTemplate extends ModelTemplate, TSchema extends SchemaCollections, TRelationships extends ModelRelationships = RelationshipsByTemplate<TTemplate, TSchema>> {
+    isApplyingPendingUpdates: boolean;
+    private _model;
+    private _pendingRelationshipOperations;
+    private _relationshipDefs?;
+    private _inverseMap;
+    private _schema;
+    constructor(model: Model<TTemplate, TSchema>, schema: SchemaInstance<TSchema>, relationships?: TRelationships);
+    /**
+     * Getter for the relationship definitions
+     * @returns The relationship definitions
+     */
+    get relationshipDefs(): RelationshipDefs<TRelationships> | undefined;
+    /**
+     * Getter for the schema
+     * @returns The schema
+     */
+    get schema(): SchemaInstance<TSchema>;
+    /**
+     * Set pending relationship updates by analyzing changes
+     * Handles both model instances and raw foreign key values
+     * Should be called BEFORE updating model attributes so we can access old FKs
+     * @param relationshipUpdates - Raw relationship values from attrs (can be models or FK values)
+     */
+    setPendingRelationshipUpdates(relationshipUpdates: Partial<RelatedModelAttrs<TSchema, TRelationships>>): void;
+    /**
+     * Apply inverse relationship updates for pending operations
+     * Should be called AFTER saving the model (when FK changes are in the database)
+     * Note: FK updates are already applied to the model by _processAttrs or link/unlink methods
+     */
+    applyPendingInverseUpdates(): void;
+    /**
+     * Link this model to another model via a relationship
+     * Returns foreign key updates without mutating model state
+     * @param relationshipName - The name of the relationship
+     * @param targetModel - The model to link to (or null to unlink)
+     * @returns FK updates to apply and inverse relationship updates
+     */
+    link<K extends RelationshipNames<TRelationships>>(relationshipName: K, targetModel: RelationshipTargetModel<TSchema, TRelationships, K>): RelationshipUpdateResult;
+    /**
+     * Unlink this model from another model via a relationship
+     * Returns foreign key updates without mutating model state
+     * @param relationshipName - The name of the relationship
+     * @param targetModel - The specific model to unlink (optional for hasMany, unlinks all if not provided)
+     * @returns FK updates to apply
+     */
+    unlink<K extends RelationshipNames<TRelationships>>(relationshipName: K, targetModel?: RelationshipTargetModel<TSchema, TRelationships, K>): RelationshipUpdateResult;
+    /**
+     * Get related model(s) for a relationship with proper typing
+     * @param relationshipName - The relationship name
+     * @returns The related model(s) or null/empty collection
+     */
+    related<K extends RelationshipNames<TRelationships>>(relationshipName: K): RelationshipTargetModel<TSchema, TRelationships, K> | null;
+    /**
+     * Get a relationship definition by name
+     * @param relationshipName - The relationship name
+     * @returns The relationship definition or undefined
+     */
+    private _getRelationshipDef;
+    /**
+     * Get model attributes with proper typing
+     * @returns Model attributes
+     */
+    private _getModelAttrs;
+    /**
+     * Get foreign key value from model attrs
+     * @param foreignKey - The foreign key to retrieve
+     * @returns The foreign key value
+     */
+    private _getForeignKeyValue;
+    /**
+     * Extract a single ID from foreign key value (for belongsTo relationships)
+     * @param foreignKeyValue - The foreign key value
+     * @returns A single ID or null
+     */
+    private _extractSingleId;
+    /**
+     * Extract array of IDs from foreign key value
+     * @param foreignKeyValue - The foreign key value
+     * @returns Array of IDs
+     */
+    private _extractIdsArray;
+    /**
+     * Parse relationships configuration into internal relationship definitions
+     * This includes finding inverse relationships for bidirectional updates
+     * @param relationships - The relationships configuration from schema
+     * @returns Parsed relationship definitions with inverse information
+     */
+    private _parseRelationshipDefs;
+    /**
+     * Update the inverse relationship on the target model
+     * @param relationshipName - The name of the relationship being updated
+     * @param targetModel - The target model to update
+     * @param action - Whether to 'link' or 'unlink'
+     */
+    private _updateInverseRelationship;
+    /**
+     * Extract foreign key value from a relationship value (model/array/collection)
+     * @param relationship - The relationship configuration
+     * @param value - The relationship value
+     * @returns The extracted foreign key value
+     */
+    private _extractForeignKeyFromValue;
+    /**
+     * Check if foreign key has a meaningful value
+     * @param fk - The foreign key value to check
+     * @returns True if the foreign key has a value
+     */
+    private _hasForeignKeyValue;
+    /**
+     * Check if foreign key has changed
+     * @param currentFk - The current foreign key value
+     * @param newFk - The new foreign key value
+     * @returns True if the foreign keys are different
+     */
+    private _hasForeignKeyChanged;
+    /**
+     * Compare two arrays for equality
+     * @param arr1 - First array
+     * @param arr2 - Second array
+     * @returns True if arrays are equal
+     */
+    private _arraysEqual;
+}
+
+/**
+ * Model class for managing model instances with relationships
+ * @template TTemplate - The model template (most important for users)
+ * @template TSchema - The schema collections type for enhanced type inference
+ * @template TSerializer - The serializer type
+ */
+declare class Model<TTemplate extends ModelTemplate = ModelTemplate, TSchema extends SchemaCollections = SchemaCollections, TSerializer = undefined> extends BaseModel<ModelAttrs<TTemplate, TSchema>, TSerializer> {
+    readonly relationships?: RelationshipsByTemplate<TTemplate, TSchema>;
+    protected _relationshipsManager?: RelationshipsManager<TTemplate, TSchema>;
+    constructor(template: TTemplate, config: ModelConfig<TTemplate, TSchema, RelationshipsByTemplate<TTemplate, TSchema>, TSerializer>);
+    /**
+     * Define a model class with attribute accessors
+     * @template TTemplate - The model template (most important for users)
+     * @template TSchema - The schema collections type for enhanced type inference
+     * @template TSerializer - The serializer type
+     * @param template - The model template to define
+     * @returns A model class that can be instantiated with 'new'
+     */
+    static define<TTemplate extends ModelTemplate, TSchema extends SchemaCollections = SchemaCollections, TSerializer = undefined>(template: TTemplate): ModelClass<TTemplate, TSchema, TSerializer>;
+    /**
+     * Save the model to the database and apply pending relationship updates
+     * @returns The model with saved instance type
+     */
+    save(): this & ModelInstance<TTemplate, TSchema, TSerializer>;
+    /**
+     * Update the model attributes and save the model
+     * @param attrs - The attributes to update
+     * @returns The model with saved instance type
+     */
+    update(attrs: ModelUpdateAttrs<TTemplate, TSchema>): this & ModelInstance<TTemplate, TSchema, TSerializer>;
+    /**
+     * Reload the model from the database
+     * @returns The model with saved instance type
+     */
+    reload(): this & ModelInstance<TTemplate, TSchema, TSerializer>;
+    /**
+     * Destroy the model from the database
+     * @returns The model with new instance type
+     */
+    destroy(): this & NewModelInstance<TTemplate, TSchema, TSerializer>;
+    /**
+     * Link this model to another model via a relationship
+     * @param relationshipName - The name of the relationship
+     * @param targetModel - The model to link to (or null to unlink)
+     * @returns This model instance for chaining
+     */
+    link<K extends RelationshipNames<RelationshipsByTemplate<TTemplate, TSchema>>>(relationshipName: K, targetModel: RelationshipTargetModel<TSchema, RelationshipsByTemplate<TTemplate, TSchema>, K>): this & ModelInstance<TTemplate, TSchema, TSerializer>;
+    /**
+     * Unlink this model from another model via a relationship
+     * @param relationshipName - The name of the relationship
+     * @param targetModel - The specific model to unlink (optional for hasMany, unlinks all if not provided)
+     * @returns This model instance for chaining
+     */
+    unlink<K extends RelationshipNames<RelationshipsByTemplate<TTemplate, TSchema>>>(relationshipName: K, targetModel?: RelationshipTargetModel<TSchema, RelationshipsByTemplate<TTemplate, TSchema>, K>): this & ModelInstance<TTemplate, TSchema, TSerializer>;
+    /**
+     * Get related model(s) for a relationship with proper typing
+     * @param relationshipName - The relationship name
+     * @returns The related model(s) or null/empty collection
+     */
+    related<K extends RelationshipNames<RelationshipsByTemplate<TTemplate, TSchema>>>(relationshipName: K): RelationshipTargetModel<TSchema, RelationshipsByTemplate<TTemplate, TSchema>, K> | null;
+    /**
+     * Extract foreign key value from a relationship value
+     * @param relationship - The relationship configuration
+     * @param value - The value to extract the foreign key from
+     * @returns The foreign key value
+     */
+    private static _extractForeignKey;
+    /**
+     * Separate attributes into model attributes and relationship updates
+     * Extracts foreign keys from relationship model instances and initializes default values
+     * @param attrs - The attributes to separate
+     * @param relationships - The relationships configuration
+     * @returns Object containing:
+     *   - regularAttrs: Regular attributes (may include explicit FK values)
+     *   - relationshipValues: Relationship values
+     *   - foreignKeys: Foreign keys (extracted from relationship models or defaults)
+     */
+    private static _separateAttrs;
+    /**
+     * Process constructor/update attributes before model initialization
+     * Separates relationship model instances from regular attributes and extracts foreign keys
+     * @param attrs - The attributes to process (can include both regular attrs and relationship instances)
+     * @param relationships - The relationships configuration (optional)
+     * @returns Object containing:
+     *   - modelAttrs: Regular attributes and foreign keys ready for the database
+     *   - relationshipUpdates: Relationship model instances to be linked after save
+     * @example
+     * // Input: { title: 'Post', author: authorModelInstance }
+     * // Output: {
+     * //   modelAttrs: { title: 'Post', authorId: '1' },
+     * //   relationshipUpdates: { author: authorModelInstance }
+     * // }
+     */
+    static _processAttrs<TTemplate extends ModelTemplate, TSchema extends SchemaCollections, TRelationships extends ModelRelationships = RelationshipsByTemplate<TTemplate, TSchema>>(attrs: ModelCreateAttrs<TTemplate, TSchema, TRelationships> | ModelUpdateAttrs<TTemplate, TSchema, TRelationships> | Partial<ModelCreateAttrs<TTemplate, TSchema, TRelationships>> | Record<string, unknown>, relationships?: TRelationships): {
+        modelAttrs: NewModelAttrs<ModelAttrs<TTemplate, TSchema>> | Partial<ModelAttrs<TTemplate, TSchema>>;
+        relationshipUpdates: Partial<RelatedModelAttrs<TSchema, TRelationships>>;
+    };
+    /**
+     * Initialize attribute accessors for all attributes except id
+     */
+    private _initAttributeAccessors;
+    /**
+     * Initialize foreign key attributes if they don't exist
+     */
+    private _initForeignKeys;
+    /**
+     * Initialize relationship accessors for all relationships
+     */
+    private _initRelationshipAccessors;
+}
+
+/**
+ * Model template interface with hidden type properties
+ *
+ * This interface uses only 2 generics for clean type signatures,
+ * while storing additional type metadata in hidden properties (__attrs, __json).
+ * These hidden properties exist only in TypeScript's type system with zero runtime cost.
+ *
+ * Note: __attrs and __json are NOT defined in the base interface to avoid type pollution
+ * when creating intersections. They are added via intersection types in ModelBuilder.create()
+ * @template TModelName - The string literal type for the model name
+ * @template TCollectionName - The string literal type for the collection name
+ */
+interface ModelTemplate<TModelName extends string = string, TCollectionName extends string = string> {
+    readonly key: symbol;
+    readonly modelName: TModelName;
+    readonly collectionName: TCollectionName;
+}
+/**
+ * Infer model attributes from template
+ * Uses conditional type to properly extract __attrs from intersection types
+ * @template T - The model template
+ */
+type InferModelAttrs<T> = T extends {
+    __attrs: infer TAttrs extends {
+        id: any;
+    };
+} ? TAttrs : never;
+/**
+ * Infer model ID type from template
+ * @template T - The model template
+ */
+type ModelId<T> = InferModelAttrs<T>['id'];
+/**
+ * Infer model name from template
+ * @template T - The model template
+ */
+type InferModelName<T> = T extends ModelTemplate<infer Name, any> ? Name : never;
+/**
+ * Infer collection name from template
+ * @template T - The model template
+ */
+type InferCollectionName<T> = T extends ModelTemplate<any, infer Name> ? Name : never;
+/**
+ * Infer serialized model type from template
+ * Uses conditional type to properly extract from intersection types
+ * @template T - The model template
+ */
+type InferSerializedModel<T> = T extends {
+    __json: {
+        model: infer M;
+    };
+} ? M : InferModelAttrs<T>;
+/**
+ * Infer serialized collection type from template
+ * Uses conditional type to properly extract from intersection types
+ * @template T - The model template
+ */
+type InferSerializedCollection<T> = T extends {
+    __json: {
+        collection: infer C;
+    };
+} ? C : InferModelAttrs<T>[];
+/**
+ * Model relationships configuration object
+ * @example { posts: HasMany<PostTemplate>, author: BelongsTo<UserTemplate, 'authorId'> }
+ */
+type ModelRelationships = Record<string, Relationships>;
+/**
+ * Type for foreign key values - either a single ID or array of IDs
+ */
+type ForeignKeyValue = string | number | string[] | number[] | null | undefined;
+/**
+ * Result of a relationship operation (link/unlink)
+ * Contains foreign key updates for the current model
+ */
+interface RelationshipUpdateResult {
+    /** Foreign key updates to apply to the current model */
+    foreignKeyUpdates: Record<string, ForeignKeyValue>;
+}
+/**
+ * Internal relationship definition with inverse relationship information
+ * Used internally by Model to track bidirectional relationships
+ * @template TRelationship - The specific relationship type
+ */
+interface RelationshipDef<TRelationship extends Relationships = Relationships> {
+    /** The original relationship configuration */
+    relationship: TRelationship;
+    /** The inverse relationship information, if it exists */
+    inverse?: {
+        /** The foreign key used by the inverse relationship */
+        foreignKey: string;
+        /** The name of the inverse relationship in the target model */
+        relationshipName: string;
+        /** The target model template that has the inverse relationship */
+        targetModel: ModelTemplate;
+        /** The type of the inverse relationship */
+        type: 'belongsTo' | 'hasMany';
+    };
+}
+/**
+ * Relationship definitions for internal use by Model class
+ * Maps relationship names to their definitions including inverse information
+ * Preserves specific relationship types from the input relationships configuration
+ * @template TRelationships - The model relationships configuration
+ * @example
+ * // Input: { posts: HasMany<PostTemplate>, author: BelongsTo<UserTemplate> }
+ * // Output: {
+ * //   posts: RelationshipDef<HasMany<PostTemplate>>,
+ * //   author: RelationshipDef<BelongsTo<UserTemplate>>
+ * // }
+ */
+type RelationshipDefs<TRelationships extends ModelRelationships = ModelRelationships> = {
+    [K in keyof TRelationships]: RelationshipDef<TRelationships[K]>;
+};
+/**
+ * Extract relationship names from relationships type
+ * @template TRelationships - The relationships type
+ */
+type RelationshipNames<TRelationships extends ModelRelationships> = keyof TRelationships;
+/**
+ * Extract the target model instance type for a specific relationship
+ * @template TSchema - The schema collections type
+ * @template TRelationships - The relationships type
+ * @template K - The relationship name
+ */
+type RelationshipTargetModel<TSchema extends SchemaCollections, TRelationships extends ModelRelationships, K extends keyof TRelationships = keyof TRelationships> = TRelationships[K] extends BelongsTo<infer TTarget, any> ? ModelInstance<TTarget, TSchema> | null : TRelationships[K] extends HasMany<infer TTarget, any> ? ModelCollection<TTarget, TSchema> | ModelInstance<TTarget, TSchema>[] | null : never;
+/**
+ * Type for collection by template model
+ * @template TSchema - The schema collections
+ * @template TTemplate - The model template
+ */
+type CollectionByTemplate<TSchema extends SchemaCollections, TTemplate extends ModelTemplate> = {
+    [K in keyof TSchema]: TSchema[K] extends CollectionConfig<infer TModel, any, any, any, any> ? TModel extends TTemplate ? K : never : never;
+}[keyof TSchema];
+/**
+ * Type for relationships by template model
+ * @template TSchema - The schema collections
+ * @template TTemplate - The model template
+ */
+type RelationshipsByTemplate<TTemplate extends ModelTemplate, TSchema extends SchemaCollections> = TSchema[CollectionByTemplate<TSchema, TTemplate>] extends CollectionConfig<any, infer TRelationships, any, any, any> ? TRelationships extends ModelRelationships ? TRelationships : {} : {};
+/**
+ * Extract foreign key properties for BelongsTo relationships
+ * @template TRelationships - The relationships configuration object
+ */
+type BelongsToForeignKeys<TRelationships extends ModelRelationships> = UnionToIntersection<{
+    [K in keyof TRelationships]: TRelationships[K] extends BelongsTo<infer TTarget, infer TForeign> ? {
+        [FK in NonNullable<TForeign>]: ModelId<TTarget> | null;
+    } : never;
+}[keyof TRelationships]>;
+/**
+ * Extract foreign key properties for HasMany relationships
+ * @template TRelationships - The relationships configuration object
+ */
+type HasManyForeignKeys<TRelationships extends ModelRelationships> = UnionToIntersection<{
+    [K in keyof TRelationships]: TRelationships[K] extends HasMany<infer TTarget, infer TForeign> ? {
+        [FK in NonNullable<TForeign>]: ModelId<TTarget>[];
+    } : never;
+}[keyof TRelationships]>;
+/**
+ * Infer foreign key properties from relationships configuration
+ * Creates properties like: authorId: string | null, postIds: string[]
+ * @template TRelationships - The relationships configuration object
+ */
+type ModelForeignKeys<TRelationships extends ModelRelationships> = TRelationships extends never ? {} : BelongsToForeignKeys<TRelationships> & HasManyForeignKeys<TRelationships>;
+/**
+ * Type for related model
+ * @template TSchema - The schema collections
+ * @template TRelationship - The relationship
+ */
+type RelatedModel<TSchema extends SchemaCollections, TRelationship extends Relationships> = TRelationship extends BelongsTo<infer TTarget, any> ? ModelInstance<TTarget, TSchema> | null : TRelationship extends HasMany<infer TTarget, any> ? ModelCollection<TTarget, TSchema> : never;
+type RelatedModelAttrs<TSchema extends SchemaCollections, TRelationships extends ModelRelationships> = TRelationships extends ModelRelationships ? {
+    [K in keyof TRelationships]: TRelationships[K] extends BelongsTo<infer TTarget, any> ? ModelInstance<TTarget, TSchema> | null : TRelationships[K] extends HasMany<infer TTarget, any> ? ModelCollection<TTarget, TSchema> | ModelInstance<TTarget, TSchema>[] : never;
+} : {};
+type ForeignKeyAttrs<TRelationships extends ModelRelationships> = Partial<ModelForeignKeys<TRelationships>>;
+/**
+ * Infer relationship accessor properties that can be updated
+ * @template TSchema - The schema collections
+ * @template TRelationships - The relationships configuration
+ */
+type ModelRelationshipAccessors<TSchema extends SchemaCollections, TRelationships extends ModelRelationships> = keyof TRelationships extends never ? {} : {
+    [K in keyof TRelationships]: RelatedModel<TSchema, TRelationships[K]>;
+};
+/**
+ * Type for base model attributes (allowing null id for unsaved models)
+ * @template TTemplate - The model template
+ */
+type NewModelAttrs<TAttrs extends {
+    id: any;
+}> = TAttrs | (Omit<TAttrs, 'id'> & {
+    id?: TAttrs['id'] | null;
+});
+/**
+ * Type for new base model instance with nullable ID
+ * @template TAttrs - The model attributes type
+ * @template TSerializer - The serializer type
+ */
+type NewBaseModelInstance<TAttrs extends {
+    id: any;
+}, TSerializer = undefined> = BaseModel<TAttrs, TSerializer> & {
+    attrs: NewModelAttrs<TAttrs>;
+    id: TAttrs['id'] | null;
+};
+/**
+ * Type for base model instance with required ID
+ * @template TAttrs - The model attributes type
+ * @template TSerializer - The serializer type
+ */
+type BaseModelInstance<TAttrs extends {
+    id: any;
+}, TSerializer = undefined> = BaseModel<TAttrs, TSerializer> & {
+    attrs: TAttrs;
+    id: TAttrs['id'];
+};
+/**
+ * Type for model attribute getters/setters
+ * @template TTemplate - The model template
+ */
+type ModelAttrAccessors<TTemplate extends ModelTemplate> = {
+    [K in keyof Omit<InferModelAttrs<TTemplate>, 'id'>]: InferModelAttrs<TTemplate>[K];
+};
+/**
+ * Type for model only attributes without ID
+ */
+type ModelOnlyAttrs<TTemplate extends ModelTemplate> = Omit<InferModelAttrs<TTemplate>, 'id'>;
+/**
+ * Type for model attributes that includes regular attributes, foreign keys, and relationship model instances
+ * Only relationship-related properties are optional
+ * @template TTemplate - The model template
+ * @template TSchema - The schema collections type
+ */
+type ModelAttrs<TTemplate extends ModelTemplate, TSchema extends SchemaCollections = SchemaCollections, TRelationships extends ModelRelationships = RelationshipsByTemplate<TTemplate, TSchema>> = Omit<InferModelAttrs<TTemplate>, 'id'> & ModelForeignKeys<TRelationships> & {
+    id: ModelId<TTemplate>;
+};
+/**
+ * Type for partial model attributes
+ * @template TTemplate - The model template
+ * @template TSchema - The schema collections type
+ */
+type PartialModelAttrs<TTemplate extends ModelTemplate, TSchema extends SchemaCollections = SchemaCollections> = Partial<ModelAttrs<TTemplate, TSchema>>;
+/**
+ * Type for constructor attributes that includes regular attributes and relationship model instances
+ * @template TTemplate - The model template
+ * @template TSchema - The schema collections type
+ */
+type ModelCreateAttrs<TTemplate extends ModelTemplate, TSchema extends SchemaCollections = SchemaCollections, TRelationships extends ModelRelationships = RelationshipsByTemplate<TTemplate, TSchema>> = Omit<InferModelAttrs<TTemplate>, 'id'> & {
+    id?: ModelId<TTemplate> | null;
+} & (Record<string, never> extends TRelationships ? {} : ForeignKeyAttrs<TRelationships> & Partial<RelatedModelAttrs<TSchema, TRelationships>>);
+/**
+ * Type for update method that includes attributes, foreign keys, and relationship model instances
+ * All properties are optional for updates
+ * @template TTemplate - The model template
+ * @template TSchema - The schema collections type
+ */
+type ModelUpdateAttrs<TTemplate extends ModelTemplate, TSchema extends SchemaCollections = SchemaCollections, TRelationships extends ModelRelationships = RelationshipsByTemplate<TTemplate, TSchema>> = Partial<ModelAttrs<TTemplate, TSchema, TRelationships>> & (Record<string, never> extends TRelationships ? {} : Partial<RelatedModelAttrs<TSchema, TRelationships>>);
+/**
+ * Configuration for creating a schema-aware model
+ * @template TTemplate - The model template
+ * @template TSchema - The schema collections type
+ * @template TRelationships - The model relationships
+ * @template TSerializer - The serializer type
+ */
+type ModelConfig<TTemplate extends ModelTemplate, TSchema extends SchemaCollections = SchemaCollections, TRelationships extends ModelRelationships = RelationshipsByTemplate<TTemplate, TSchema>, TSerializer = undefined> = {
+    attrs: ModelCreateAttrs<TTemplate, TSchema, TRelationships>;
+    schema: SchemaInstance<TSchema>;
+    serializer?: TSerializer extends undefined ? any : TSerializer;
+} & (Record<string, never> extends TRelationships ? {
+    relationships?: undefined;
+} : {
+    relationships: TRelationships;
+});
+/**
+ * Type for model class with attribute accessors (direct Model constructor)
+ * @template TTemplate - The model template (most important for users)
+ * @template TSchema - The schema collections type for enhanced type inference
+ * @template TSerializer - The serializer type
+ */
+type ModelClass<TTemplate extends ModelTemplate, TSchema extends SchemaCollections = SchemaCollections, TSerializer = undefined> = {
+    new (config: ModelConfig<TTemplate, TSchema, RelationshipsByTemplate<TTemplate, TSchema>, TSerializer>): NewModelInstance<TTemplate, TSchema, TSerializer>;
+};
+/**
+ * Type for new model instance with accessors for the attributes (nullable id)
+ * @template TTemplate - The model template (most important for users)
+ * @template TSchema - The schema collections type for enhanced type inference
+ * @template TSerializer - The serializer type
+ */
+type NewModelInstance<TTemplate extends ModelTemplate, TSchema extends SchemaCollections = SchemaCollections, TSerializer = undefined> = Model<TTemplate, TSchema, TSerializer> & {
+    attrs: ModelAttrs<TTemplate, TSchema>;
+    id: ModelAttrs<TTemplate, TSchema>['id'] | null;
+} & ModelAttrAccessors<TTemplate> & ModelForeignKeys<RelationshipsByTemplate<TTemplate, TSchema>> & ModelRelationshipAccessors<TSchema, RelationshipsByTemplate<TTemplate, TSchema>>;
+/**
+ * Type for model instance with accessors for the attributes (required ID)
+ * @template TTemplate - The model template (most important for users)
+ * @template TSchema - The schema collections type for enhanced type inference
+ * @template TSerializer - The serializer type
+ */
+type ModelInstance<TTemplate extends ModelTemplate, TSchema extends SchemaCollections = SchemaCollections, TSerializer = undefined> = Model<TTemplate, TSchema, TSerializer> & {
+    attrs: ModelAttrs<TTemplate, TSchema>;
+    id: ModelAttrs<TTemplate, TSchema>['id'];
+} & ModelAttrAccessors<TTemplate> & ModelForeignKeys<RelationshipsByTemplate<TTemplate, TSchema>> & ModelRelationshipAccessors<TSchema, RelationshipsByTemplate<TTemplate, TSchema>>;
+/**
+ * Model status type
+ */
+type ModelStatus = 'new' | 'saved';
+
+/**
+ * BaseModel class for managing basic model operations without schema dependencies
+ * Handles basic CRUD operations, db updates, attribute management, and status tracking
+ * @template TAttrs - The model attributes type (e.g., { id: string, name: string })
+ * @template TSerializer - The serializer type for custom JSON serialization
+ */
+declare class BaseModel<TAttrs extends {
+    id: any;
+}, TSerializer = undefined> {
+    readonly modelName: string;
+    readonly collectionName: string;
+    protected _attrs: NewModelAttrs<TAttrs>;
+    protected _dbCollection: DbCollection<TAttrs>;
+    protected _serializer?: TSerializer;
+    protected _status: ModelStatus;
+    constructor(modelName: string, collectionName: string, attrs: NewModelAttrs<TAttrs>, dbCollection?: DbCollection<TAttrs>, serializer?: TSerializer);
+    /**
+     * Getter for the protected id attribute
+     * @returns The id of the model
+     */
+    get id(): TAttrs['id'] | null;
+    /**
+     * Getter for the model attributes
+     * @returns A copy of the model attributes
+     */
+    get attrs(): NewModelAttrs<TAttrs>;
+    /**
+     * Save the model to the database
+     * @returns The model with saved instance type
+     */
+    save(): this & BaseModelInstance<TAttrs, TSerializer>;
+    /**
+     * Update the model attributes and save the model
+     * @param attrs - The attributes to update
+     * @returns The model instance for chaining
+     */
+    update(attrs: Partial<TAttrs>): this & BaseModelInstance<TAttrs, TSerializer>;
+    /**
+     * Reload the model from the database
+     * @returns The model with saved instance type
+     */
+    reload(): this & BaseModelInstance<TAttrs, TSerializer>;
+    /**
+     * Destroy the model from the database
+     * @returns The model with new instance type
+     */
+    destroy(): this & NewBaseModelInstance<TAttrs, TSerializer>;
+    /**
+     * Check if the model is new
+     * @returns True if the model is new, false otherwise
+     */
+    isNew(): boolean;
+    /**
+     * Check if the model is saved
+     * @returns True if the model is saved, false otherwise
+     */
+    isSaved(): boolean;
+    /**
+     * Serialize the model to a JSON object
+     * @returns The serialized model using the configured serializer or raw attributes
+     */
+    toJSON(): TSerializer extends {
+        serialize(model: any): infer TSerializedModel;
+    } ? TSerializedModel : TAttrs;
+    /**
+     * Serialize the model to a string
+     * @returns The simple string representation of the model and its id
+     */
+    toString(): string;
+    private _checkStatus;
+}
+
+/**
+ * A fluent builder for creating strongly-typed model templates.
+ *
+ * The ModelBuilder provides a type-safe way to construct ModelTemplate instances with
+ * configurable model attributes. It follows the builder pattern, allowing method chaining
+ * to progressively refine the template's type parameters.
+ * @template TModelAttrs - The model attributes type (must have an 'id' property)
+ * @template TModelName - The string literal type for the model name
+ * @template TCollectionName - The string literal type for the collection name
+ * @template TSerializedModel - The serialized model type (for toJSON)
+ * @template TSerializedCollection - The serialized collection type (for toJSON)
+ * @example
+ * ```typescript
+ * // Create a basic template
+ * const userTemplate = model().name('user').collection('users').create();
+ *
+ * // Create a template with specific model attributes
+ * interface User { id: string; name: string; email: string; }
+ * const typedUserTemplate = model()
+ *   .name('user')
+ *   .collection('users')
+ *   .attrs<UserAttrs>()
+ *   .create();
+ *
+ * // With custom JSON types
+ * const jsonTypedTemplate = model()
+ *   .name('user')
+ *   .collection('users')
+ *   .attrs<UserAttrs>()
+ *   .json<UserJSON, UsersJSON>()
+ *   .create();
+ * ```
+ */
+declare class ModelBuilder<TModelAttrs extends {
+    id: any;
+} = {
+    id: string;
+}, TModelName extends string = string, TCollectionName extends string = string, TSerializedModel = TModelAttrs, TSerializedCollection = TSerializedModel[]> {
+    private _modelName?;
+    private _collectionName?;
+    /**
+     * Sets the model name identifier.
+     * @template T - The string literal type for the model name
+     * @param modelName - The name identifier for the model (e.g., 'user', 'post')
+     * @returns A new ModelBuilder instance with the model name set
+     * @example
+     * ```typescript
+     * const builder = model().name('user');
+     * ```
+     */
+    name<T extends string>(modelName: T): ModelBuilder<TModelAttrs, T, TCollectionName, TSerializedModel, TSerializedCollection>;
+    /**
+     * Sets the collection name identifier.
+     * @template T - The string literal type for the collection name
+     * @param collectionName - The name identifier for the collection (e.g., 'users', 'posts')
+     * @returns A new ModelBuilder instance with the collection name set
+     * @example
+     * ```typescript
+     * const builder = model().name('user').collection('users');
+     * ```
+     */
+    collection<T extends string>(collectionName: T): ModelBuilder<TModelAttrs, TModelName, T, TSerializedModel, TSerializedCollection>;
+    /**
+     * Sets the model attributes type.
+     *
+     * This method allows you to specify the exact shape of your model attributes,
+     * providing strong typing for the resulting template. Serialization types are
+     * reset to default to the new attributes type (use .json() to override).
+     * @template T - The model attributes type (must extend { id: any })
+     * @returns A new ModelBuilder instance with the specified model type
+     * @example
+     * ```typescript
+     * interface User { id: string; name: string; email: string; }
+     * const builder = model().name('user').collection('users').attrs<UserAttrs>();
+     * ```
+     */
+    attrs<T extends {
+        id: any;
+    }>(): ModelBuilder<T, TModelName, TCollectionName, T, T[]>;
+    /**
+     * Specifies serialization types for this model.
+     *
+     * This method sets the types returned by model.toJSON() and collection.toJSON().
+     * If not called, toJSON() will return the model attributes type.
+     * @template TModel - The serialized model type (single instance)
+     * @template TCollection - The serialized collection type (array)
+     * @returns A new ModelBuilder with serialization types
+     * @example
+     * ```typescript
+     * interface UserJSON {
+     *   id: string;
+     *   name: string;
+     *   email: string;
+     * }
+     *
+     * interface UsersJSON {
+     *   users: UserJSON[];
+     * }
+     *
+     * const userModel = model()
+     *   .name('user')
+     *   .collection('users')
+     *   .attrs<UserAttrs>()
+     *   .json<UserJSON, UsersJSON>() // Specify serialization types
+     *   .create();
+     * ```
+     */
+    json<TModel = TModelAttrs, TCollection = TModel[]>(): ModelBuilder<TModelAttrs, TModelName, TCollectionName, TModel, TCollection>;
+    /**
+     * Creates the final ModelTemplate with all configured types and metadata.
+     *
+     * This method produces the immutable ModelTemplate that can be used throughout
+     * your application for type-safe model operations. The template includes the
+     * model and collection names, a unique symbol key, and hidden type properties
+     * for attributes and serialization.
+     * @returns The configured ModelTemplate instance with hidden type properties
+     * @throws Error if model name or collection name is not set
+     * @example
+     * ```typescript
+     * const userTemplate = model()
+     *   .name('user')
+     *   .collection('users')
+     *   .attrs<UserAttrs>()
+     *   .create();
+     * ```
+     */
+    create(): ModelTemplate<TModelName, TCollectionName> & {
+        __attrs: TModelAttrs;
+        __json: {
+            model: TSerializedModel;
+            collection: TSerializedCollection;
+        };
+    };
+}
+/**
+ * Creates a new ModelBuilder for constructing type-safe model templates.
+ *
+ * This is the primary entry point for creating model templates. It provides a fluent
+ * interface for configuring model attributes and metadata.
+ * @returns A new ModelBuilder instance ready for configuration
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const userTemplate = model()
+ *   .name('user')
+ *   .collection('users')
+ *   .create();
+ *
+ * // With typed attributes
+ * interface UserAttrs { id: string; name: string; email: string; }
+ * const typedUserTemplate = model()
+ *   .name('user')
+ *   .collection('users')
+ *   .attrs<UserAttrs>()
+ *   .create();
+ *
+ * // With custom JSON types
+ * interface UserJSON { id: string; name: string; email: string; }
+ * interface UsersJSON { users: UserJSON[]; }
+ * const jsonTypedTemplate = model()
+ *   .name('user')
+ *   .collection('users')
+ *   .attrs<UserAttrs>()
+ *   .json<UserJSON, UsersJSON>()
+ *   .create();
+ * ```
+ */
+declare function model(): ModelBuilder<{
+    id: string;
+}, string, string>;
+
+export { type Association, type BelongsTo, Collection, type CollectionConfig, type CollectionCreateAttrs, type CollectionInstance, type CreateAssociation, type CreateManyAssociation, type DataSerializerOptions, type DbRecordInput, Factory, type FactoryAfterCreateHook, type FactoryAttrs, type FixtureAttrs, type FixtureConfig, type FixtureLoadStrategy, type HasMany, IdentityManager, type InferCollectionName, type InferModelAttrs, type InferModelName, type InferSerializedCollection, type InferSerializedModel, type LinkAssociation, type LinkManyAssociation, type ModelAttrs, type ModelInstance, type ModelTemplate, type ModelTraits, type ModelUpdateAttrs, type NewModelInstance, NumberIdentityManager, type OrderBy, type PartialModelAttrs, type QueryOptions, type SchemaCollections, type SchemaInstance, type SeedFunction, type SeedScenarios, type Seeds, Serializer, type SerializerOptions, StringIdentityManager, type StructuralSerializerOptions, type TraitDefinition, type Where, associations, belongsTo, collection, create, createMany, factory, hasMany, link, linkMany, model, schema };