tspace-mysql 1.9.0 → 1.9.1-beta.2

package/dist/lib/core/Model.d.ts

@@ -4,9 +4,10 @@ import { AbstractModel } from "./Abstracts/AbstractModel";
 import { Blueprint } from "./Blueprint";
 import { JoinModel } from "./JoinModel";
 import { CONSTANTS } from "../constants";
-import type { T } from "./UtilityTypes";
-import type { TCache, TRelationOptions, TValidateSchema, TGlobalSetting, TPattern, TRelationQueryOptions, TModelOrObject, TRelationKeys, TLifecycle } from "../types";
 import { Join } from "./Join";
+import { QueryBuilder } from "./Driver";
+import type { T } from "./UtilityTypes";
+import type { TRelationOptions, TValidateSchema, TGlobalSetting, TPattern, TRelationQueryOptions, TModelOrObject, TRelationKeys, TLifecycle, TCacheModel, TRawStringQuery, TAction, TSaveModelResult } from "../types";
 /**
  *
  * The 'Model' class is a representation of a database table
@@ -33,7 +34,7 @@ import { Join } from "./Join";
  * const users = await new User().findMany()
  * console.log(users)
  */
-declare class Model<TS extends Record<string, any> = any, TR = unknown> extends AbstractModel {
+declare class Model<TS extends Record<string, any> = any, TR = unknown, TA extends TAction = any> extends AbstractModel {
     constructor();
     /**
      * The 'global' method is used setting global variables in models.
@@ -79,11 +80,389 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @returns {Model} instance of the Model
      */
     static get instance(): Model;
+    /**
+     * The 'query' method is used to return instance
+     * @static
+     * @example
+     * const user = await User.query().where('id',1).findOne();
+     * console.log(user);
+     */
+    static query<T>(this: new () => T): T;
+    /**
+     *
+     * The 'find' method is used to retrieve a single record from a database table by its primary key.
+     *
+     * It allows you to retrieve a single record from a database table that meets the specified criteria.
+     * @type     {?object}  options
+     * @property {?object} options.select
+     * @property {?object} options.except
+     * @property {?object[]} options.orderBy
+     * @property {?string[]} options.groupBy
+     * @property {?string} options.having
+     * @property {?number} options.limit
+     * @property {?number} options.offset
+     * @property {?object} options.where
+     * @property {?string[]} options.whereRaw
+     * @property {?object} options.whereQuery
+     * @property {?{condition,callback}} options.when
+     * @property {?{localKey , referenceKey}[]} options.join
+     * @property {?{localKey , referenceKey}[]} options.rightJoin
+     * @property {?{localKey , referenceKey}[]} options.leftJoin
+     * @property {?string[]} options.relations
+     * @property {string[]} options.relationExists
+     * @property {?{condition,callback}} options.relationQuery
+     * @property {?boolean} options.debug
+     * @returns {promise<object>[]}
+     *
+     * @example
+     * import { User } from '../Models/User'
+     *
+     * const users = await User.find({
+     *       select : { id: true, name: true },
+     *       where : {
+     *           id: 1
+     *       }
+     *   })
+     *
+     */
+    static find<Self extends Model, M extends Model = Self, S extends T.SelectOptions<M> | undefined = undefined, SR extends T.RelationOptions<M> | undefined = undefined, E extends T.ExceptOptions<M> | undefined = undefined, SRS extends Record<string, TRawStringQuery> | undefined = undefined, G extends Record<string, T.RepositoryGenericTypeOptions> | undefined = {}>(this: new () => Self, primaryKey: number | string, options?: T.RepositoryOptions<M, S, SR, E, SRS, G>): Promise<T.ResultFiltered<M, S, SR, E, SRS, G> | null>;
+    /**
+     *
+     * The 'findOne' method is used to retrieve the get record that matches the query conditions.
+     *
+     * It allows you to retrieve a single record from a database table that meets the specified criteria.
+     * @type     {?object}  options
+     * @property {?object} options.select
+     * @property {?object} options.except
+     * @property {?object[]} options.orderBy
+     * @property {?string[]} options.groupBy
+     * @property {?string} options.having
+     * @property {?number} options.limit
+     * @property {?number} options.offset
+     * @property {?object} options.where
+     * @property {?string[]} options.whereRaw
+     * @property {?object} options.whereQuery
+     * @property {?{condition,callback}} options.when
+     * @property {?{localKey , referenceKey}[]} options.join
+     * @property {?{localKey , referenceKey}[]} options.rightJoin
+     * @property {?{localKey , referenceKey}[]} options.leftJoin
+     * @property {?string[]} options.relations
+     * @property {string[]} options.relationExists
+     * @property {?{condition,callback}} options.relationQuery
+     * @property {?boolean} options.debug
+     * @returns {promise<object>[]}
+     *
+     * @example
+     * import { User } from '../Models/User'
+     *
+     * const users = await User.findOne({
+     *       select : { id: true, name: true },
+     *       where : {
+     *           id: 1
+     *       }
+     *   })
+     *
+     */
+    static findOne<Self extends Model, M extends Model = Self, S extends T.SelectOptions<M> | undefined = undefined, SR extends T.RelationOptions<M> | undefined = undefined, E extends T.ExceptOptions<M> | undefined = undefined, SRS extends Record<string, TRawStringQuery> | undefined = undefined, G extends Record<string, T.RepositoryGenericTypeOptions> | undefined = {}>(this: new () => Self, options?: T.RepositoryOptions<M, S, SR, E, SRS, G>): Promise<T.ResultFiltered<M, S, SR, E, SRS, G> | null>;
+    /**
+     *
+     * The 'findMany' method is used to retrieve the get record that matches the query conditions.
+     *
+     * It allows you to retrieve a single record from a database table that meets the specified criteria.
+     * @type     {?object}  options
+     * @property {?object} options.select
+     * @property {?object} options.except
+     * @property {?object[]} options.orderBy
+     * @property {?string[]} options.groupBy
+     * @property {?string} options.having
+     * @property {?number} options.limit
+     * @property {?number} options.offset
+     * @property {?object} options.where
+     * @property {?string[]} options.whereRaw
+     * @property {?object} options.whereQuery
+     * @property {?{condition,callback}} options.when
+     * @property {?{localKey , referenceKey}[]} options.join
+     * @property {?{localKey , referenceKey}[]} options.rightJoin
+     * @property {?{localKey , referenceKey}[]} options.leftJoin
+     * @property {?string[]} options.relations
+     * @property {string[]} options.relationExists
+     * @property {?{condition,callback}} options.relationQuery
+     * @property {?boolean} options.debug
+     * @returns {promise<object>[]}
+     *
+     * @example
+     * import { User } from '../Models/User'
+     *
+     * const users = await User.findMany({
+     *       select : { id: true, name: true },
+     *       where : {
+     *           id: 1
+     *       }
+     *   })
+     *
+     */
+    static findMany<Self extends Model, M extends Model = Self, S extends T.SelectOptions<M> | undefined = undefined, SR extends T.RelationOptions<M> | undefined = undefined, E extends T.ExceptOptions<M> | undefined = undefined, SRS extends Record<string, TRawStringQuery> | undefined = undefined, G extends Record<string, T.RepositoryGenericTypeOptions> | undefined = {}>(this: new () => Self, options?: T.RepositoryOptions<M, S, SR, E, SRS, G>): Promise<T.ResultFiltered<M, S, SR, E, SRS, G>[]>;
+    /**
+     *
+     * The 'paginate' method is used to perform pagination on a set of database query results obtained through the Query Builder.
+     *
+     * It allows you to split a large set of query results into smaller, more manageable pages,
+     * making it easier to display data in a web application and improve user experience.
+     * @type     {?object}  options
+     * @property {?object} options.select
+     * @property {?object} options.except
+     * @property {?object[]} options.orderBy
+     * @property {?string[]} options.groupBy
+     * @property {?string} options.having
+     * @property {?number} options.limit
+     * @property {?number} options.offset
+     * @property {?object} options.where
+     * @property {?string[]} options.whereRaw
+     * @property {?object} options.whereQuery
+     * @property {?{condition,callback}} options.when
+     * @property {?{localKey , referenceKey}[]} options.join
+     * @property {?{localKey , referenceKey}[]} options.rightJoin
+     * @property {?{localKey , referenceKey}[]} options.leftJoin
+     * @property {?string[]} options.relations
+     * @property {string[]} options.relationExists
+     * @property {?{condition,callback}} options.relationQuery
+     * @property {?boolean} options.debug
+     * @property {?number} options.page
+     * @returns {promise<{ meta , data[]}>}
+     *
+     * @example
+     * import { User } from '../Models/User'
+     *
+     *  const users = await User.paginate({
+     *       limit:15,
+     *       page: 1,
+     *       select : { id: true, name: true },
+     *       where : {
+     *           id: 1
+     *       }
+     *   })
+     */
+    static paginate<Self extends Model, M extends Model = Self, S extends T.SelectOptions<M> | undefined = undefined, SR extends T.RelationOptions<M> | undefined = undefined, E extends T.ExceptOptions<M> | undefined = undefined, SRS extends Record<string, TRawStringQuery> | undefined = undefined, G extends Record<string, T.RepositoryGenericTypeOptions> | undefined = {}>(this: new () => Self, options?: Omit<Partial<T.RepositoryOptions<M, S, SR, E, SRS, G>> & {
+        page?: number;
+    }, 'offset'>): Promise<T.PaginateResultFiltered<M, S, SR, E, SRS, G>>;
+    /**
+     * The 'exists' method is used to determine if any records exist in the database table that match the query conditions.
+     *
+     * It returns a boolean value indicating whether there are any matching records.
+     * @type     {?object}  options
+     * @property {?object} options.select
+     * @property {?object} options.except
+     * @property {?object[]} options.orderBy
+     * @property {?string[]} options.groupBy
+     * @property {?string} options.having
+     * @property {?number} options.limit
+     * @property {?number} options.offset
+     * @property {?object} options.where
+     * @property {?string[]} options.whereRaw
+     * @property {?object} options.whereQuery
+     * @property {?{condition,callback}} options.when
+     * @property {?{localKey , referenceKey}[]} options.join
+     * @property {?{localKey , referenceKey}[]} options.rightJoin
+     * @property {?{localKey , referenceKey}[]} options.leftJoin
+     * @property {?boolean} options.debug
+     * @property {?number} options.page
+     *
+     * @example
+     *  import { User } from '../Models/User'
+     *
+     *  const users = await User.exists({
+     *       where : {
+     *           id: 1
+     *       }
+     *   })
+     *
+     */
+    static exists<Self extends Model, M extends Model = Self>(this: new () => Self, options: Partial<Omit<T.RepositoryOptions<M>, "relations" | "relationQuery">>): Promise<boolean>;
+    /**
+     * The 'toQuery' method is used to retrieve the raw SQL query that would be executed by a query builder instance without actually executing it.
+     *
+     * This method is particularly useful for debugging and understanding the SQL queries generated by your application.
+     * @type     {?object}  options
+     * @property {?object} options.select
+     * @property {?object} options.except
+     * @property {?object[]} options.orderBy
+     * @property {?string[]} options.groupBy
+     * @property {?string} options.having
+     * @property {?number} options.limit
+     * @property {?number} options.offset
+     * @property {?object} options.where
+     * @property {?string[]} options.whereRaw
+     * @property {?object} options.whereQuery
+     * @property {?{condition,callback}} options.when
+     * @property {?{localKey , referenceKey}[]} options.join
+     * @property {?{localKey , referenceKey}[]} options.rightJoin
+     * @property {?{localKey , referenceKey}[]} options.leftJoin
+     * @property {?boolean} options.debug
+     * @property {?number} options.page
+     *
+     * @example
+     *  import { User } from '../Models/User'
+     *
+     *  const users = await User.exists({
+     *       where : {
+     *           id: 1
+     *       }
+     *   })
+     *
+     */
+    static toQuery<Self extends Model, M extends Model = Self>(this: new () => Self, options: Partial<Omit<T.RepositoryOptions<M>, "relations" | "relationQuery">>): string;
+    /**
+     * The 'create' method is used to insert a new record into a database table associated.
+     *
+     * It simplifies the process of creating and inserting records.
+     * @type     {object}  options
+     * @property {object} options.data
+     * @property {?boolean} options.debug
+     * @property {?transaction} options.transaction
+     * @return {promise<T.Result<M>>}
+     */
+    static create<Self extends Model, M extends Model = Self, NR extends boolean | undefined = false>(this: new () => Self, options: T.RepositoryCreate<M, NR>): Promise<NR extends true ? undefined : T.Result<M>>;
+    /**
+     * The 'createMany' method is used to insert a new records into a database table associated.
+     *
+     * It simplifies the process of creating and inserting records with an array.
+     * @type     {object}  options
+     * @property {object[]} options.data
+     * @property {?boolean} options.debug
+     * @property {?transaction} options.transaction
+     * @return {promise<TS[]>}
+     */
+    static createMany<Self extends Model, M extends Model = Self, NR extends boolean | undefined = false>(this: new () => Self, options: T.RepositoryCreateMultiple<M, NR>): Promise<NR extends true ? undefined : T.Result<M>[]>;
+    /**
+     *
+     * The 'createOrUpdate' method allows you to update an existing record in a database table if it exists or create a new record if it does not exist.
+     *
+     * This method is particularly useful when you want to update a record based on certain conditions and,
+     * if the record matching those conditions doesn't exist, create a new one with the provided data.
+     * @type     {object}  options
+     * @property {object} options.data
+     * @property {object} options.where
+     * @property {?boolean} options.debug
+     * @return {promise<NR extends true ? undefined : T.Result<M>[]>}
+     */
+    static createOrUpdate<Self extends Model, M extends Model = Self, NR extends boolean | undefined = false>(this: new () => Self, options: T.RepositoryCreateOrThings<M, NR>): Promise<NR extends true ? undefined : T.Result<M>[]>;
+    /**
+     * The 'createNotExists' method to insert data into a database table while ignoring any duplicate key constraint violations.
+     *
+     * This method is particularly useful when you want to insert records into a table and ensure that duplicates are not inserted,
+     * but without raising an error or exception if duplicates are encountered.
+     *
+     * @type     {object}  options
+     * @property {object} options.data
+     * @property {object} options.where
+     * @property {?boolean} options.debug
+     * @property {?transaction} options.transaction
+     * @return {promise<T | null>}
+     */
+    static createNotExists<Self extends Model, M extends Model = Self, NR extends boolean | undefined = false>(this: new () => Self, options: T.RepositoryCreateOrThings<M, NR>): Promise<NR extends true ? undefined : T.Result<M> | null>;
+    /**
+     *
+     * The 'createOrSelect' method to insert data into a database table while select any duplicate key constraint violations.
+     *
+     * This method is particularly useful when you want to insert records into a table and ensure that duplicates are not inserted,
+     * but if exists should be returns a result.
+     * @type     {object}  options
+     * @property {object} options.data
+     * @property {object} options.where
+     * @property {?boolean} options.debug
+     * @return {promise<T.Result<M>>}
+     */
+    static createOrSelect<Self extends Model, M extends Model = Self, NR extends boolean | undefined = false>(this: new () => Self, options: T.RepositoryCreateOrThings<M, NR>): Promise<NR extends true ? undefined : T.Result<M> | null>;
+    /**
+     * The 'update' method is used to update existing records in a database table that are associated.
+     *
+     * It simplifies the process of updating records by allowing you to specify the values to be updated using a single call.
+     *
+     * It allows you to remove one record that match certain criteria.
+     * @type     {object} options
+     * @property {object} options.data
+     * @property {object} options.where
+     * @property {?boolean} options.debug
+     * @property {?transaction} options.transaction
+     * @return {promise< NR extends true ? undefined : T.Result<M> | null>}
+     */
+    static update<Self extends Model, M extends Model = Self, NR extends boolean | undefined = false>(this: new () => Self, options: T.RepositoryUpdate<M, NR>): Promise<NR extends true ? undefined : T.Result<M> | null>;
+    /**
+     * The 'updateMany' method is used to update existing records in a database table that are associated.
+     *
+     * It simplifies the process of updating records by allowing you to specify the values to be updated using a single call.
+     *
+     * It allows you to remove more records that match certain criteria.
+     * @type     {object} options
+     * @property {object} options.data
+     * @property {object} options.where
+     * @property {?boolean} options.debug
+     * @property {?transaction} options.transaction
+     * @return {promise<T.Result<M>[]>}
+     */
+    static updateMany<Self extends Model, M extends Model = Self, NR extends boolean | undefined = false>(this: new () => Self, options: T.RepositoryUpdate<M, NR>): Promise<NR extends true ? undefined : T.Result<M>[]>;
     /**
      * The 'cache' method is used get the functions from the Cache
-     * @returns {TCache} cache
+     * @returns {TCacheModel} cache
+     */
+    static get cache(): TCacheModel;
+    /**
+     * The 'lockTable' method is used table lock and execute the callback within the lock scope.
+     *
+     * The lock is automatically released after the callback completes,
+     * regardless of whether it resolves or throws an error.
+     *
+     * READ:
+     * - Other sessions can read.
+     * - Other sessions must wait before writing.
+     * - SELECT: allowed
+     * - INSERT: waits
+     * - UPDATE: waits
+     * - DELETE: waits
+     *
+     * WRITE:
+     * - Other sessions must wait before reading or writing.
+     * - SELECT: waits
+     * - INSERT: waits
+     * - UPDATE: waits
+     * - DELETE: waits
+     *
+     * The lock is released automatically after the callback completes.
+     *
+     * @Note
+     * This approach is not recommended in clustered or load-balance environments,
+     * because locks are session-bound and requests may be routed to different database connections.
+     *
+     * @template T
+     * @param {'READ'|'WRITE'} mode Lock mode.
+     * @param {(query: this) => Promise<T>} handler Function executed while the table is locked.
+     * @returns {Promise<T>} The value returned by the callback.
+     *
+     * @example
+     * await User.lockTable('READ', async (query) => {
+     *   query.get();
+     *   return
+     * });
+     *
+     * @example
+     * await User.lockTable('WRITE', async (query) => {
+     *   // Avoid creating a new query instance inside the lock.
+     *   // The new instance uses a different connection/session and
+     *   // may wait for the current table lock to be released.
+     *
+     *   new User().insert({
+     *     first_name: 'John',
+     *     last_name: 'Doe'
+     *   }).save();
+     *
+     *   // Use the locked query instance instead.
+     *   await query.insert({
+     *     first_name: 'John',
+     *     last_name: 'Doe'
+     *   }).save();
+     * });
      */
-    static get cache(): TCache;
+    static lockTable<T, Self extends Model, M extends Model = Self>(this: new () => Self, mode: 'WRITE' | 'READ', handler: (model: M) => Promise<T>): Promise<T>;
     /**
      *  The 'boot' method is a special method that you can define within a model.
      *  @example
@@ -223,29 +602,29 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      */
     protected useSchema(schema: Record<string, Blueprint>): this;
     /**
-    * The "useTransform " method is used to define value transformers for model columns..
-    *
-    * Each transformer defines how a value is converted:
-    * - `to`   : before persisting to the database
-    * - `from` : after retrieving from the database
-    *
-    * Transformers can be synchronous or asynchronous.
-    *
-    * @param {object} transforms
-    * @example
-    * import { Blueprint } from 'tspace-mysql';
-    * class User extends Model {
-    *     boot() {
-    *        this.useTransform({
-    *            name : {
-    *              to   : async (v) => `${v}-> transform@before`,
-    *              from : async (v) => `${v}-> transform@after`,
-    *            },
-    *         })
-    *     }
-    * }
-    * @returns {this} this
-    */
+     * The "useTransform " method is used to define value transformers for model columns..
+     *
+     * Each transformer defines how a value is converted:
+     * - `to`   : before persisting to the database
+     * - `from` : after retrieving from the database
+     *
+     * Transformers can be synchronous or asynchronous.
+     *
+     * @param {object} transforms
+     * @example
+     * import { Blueprint } from 'tspace-mysql';
+     * class User extends Model {
+     *     boot() {
+     *        this.useTransform({
+     *            name : {
+     *              to   : async (v) => `${v}-> transform@before`,
+     *              from : async (v) => `${v}-> transform@after`,
+     *            },
+     *         })
+     *     }
+     * }
+     * @returns {this} this
+     */
     protected useTransform(transforms: Record<string, {
         to: (value: unknown) => any | Promise<any>;
         from: (value: unknown) => any | Promise<any>;
@@ -524,7 +903,7 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * this
      *   .useLifecycle("beforeInsert", fnA)
      *   .useLifecycle("afterInsert", fnB);
-    */
+     */
     protected useLifecycle(type: TLifecycle, funcs: Function | Function[]): this;
     /**
      * The "whenCreatingTable" method is used exection function when creating the table.
@@ -597,7 +976,7 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @returns {this} this
      */
     audit(userId: number, metadata?: Record<string, any>): this;
-    meta(meta: "MAIN" | "SUBORDINATE"): this;
+    metaTag(meta: "MAIN" | "SUBORDINATE"): this;
     /**
      * The 'typeOfSchema' method is used get type of schema.
      * @returns {TS} type of schema
@@ -613,11 +992,13 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @param {Object}  object
      * @property {string} key key of cache
      * @property {number} expires ms
+     * @property {boolean} namespace whether to use namespace for cache key, default is false, namespace is `${database}:${table}:${key}`
      * @returns {this} this
      */
-    cache({ key, expires }: {
+    cache({ key, expires, namespace }: {
         key: string;
         expires: number;
+        namespace?: boolean;
     }): this;
     /**
      *
@@ -626,6 +1007,12 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @returns {this} this
      */
     select<K extends T.ColumnKeys<this> | "*">(...columns: K[]): this;
+    /**
+     *
+     * @override
+     * @param {string[]} ...columns
+     * @returns {this} this
+     */
     addSelect<K extends T.ColumnKeys<this>>(...columns: K[]): this;
     /**
      *
@@ -674,7 +1061,9 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @param {string} column
      * @returns {string} return table.column
      */
-    bindColumn(column: string, pattern?: boolean): string;
+    bindColumn(column: string, opts?: {
+        pattern: boolean;
+    }): string;
     /**
      *
      * @override
@@ -724,7 +1113,7 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @param {Object} options keep data
      * @returns {Model} Model
      */
-    copyModel(instance: Model, options?: {
+    copyModel(instance: Model<any, any, any>, options?: {
         update?: boolean;
         insert?: boolean;
         delete?: boolean;
@@ -764,7 +1153,7 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @override
      * @returns {string} return sql query
      */
-    CTEs<M extends Model>(as: string, callback: (query: M) => M, bindModel?: new () => M): this;
+    CTEs<M extends Model<any, any, any>>(as: string, callback: (query: M) => M, bindModel?: new () => M): this;
     /**
      * The 'disableSoftDelete' method is used to disable the soft delete.
      *
@@ -1106,6 +1495,55 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
     withQuery<K extends T.RelationKeys<this>, R extends T.Relations<this>>(nameRelation: K, callback: (query: `$${K & string}` extends keyof R ? R[`$${K & string}`] extends (infer X)[] ? X : R[`$${K & string}`] extends Model ? R[`$${K & string}`] : Model : K extends keyof R ? R[K] extends (infer X)[] ? X : R[K] extends Model ? R[K] : Model : Model) => any, options?: {
         pivot: boolean;
     }): this;
+    /**
+    *
+    * The 'withQueryExists' method is particularly useful when you want to filter or add conditions records based on related data.
+    *
+    * Use relation '${name}' registry models then return callback queries
+    * @param {string} nameRelation name relation in registry in your model
+    * @param {function} callback query callback
+    * @param {object} options pivot the query
+    * @example
+    *   import { Model } from 'tspace-mysql'
+    *   class User extends Model {
+    *       constructor(){
+    *           super()
+    *           this.hasMany({ name : 'posts' , model : Post })
+    *       }
+    *   }
+    *
+    *   class Post extends Model {
+    *       constructor(){
+    *           super()
+    *           this.hasMany({ name : 'comments' , model : Comment })
+    *           this.belongsTo({ name : 'user' , model : User })
+    *       }
+    *   }
+    *
+    *   class Comment extends Model {
+    *       constructor(){
+    *           super()
+    *           this.hasMany({ name : 'users' , model : User })
+    *           this.belongsTo({ name : 'post' , model : Post })
+    *       }
+    *   }
+    *
+    *   await new User().with('posts')
+    *   .withQueryExists('posts', (query : Post) => {
+    *       return query.with('comments','user')
+    *       .withQuery('comments', (query : Comment) => {
+    *           return query.with('user','post')
+    *       })
+    *       .withQueryExists('user', (query : User) => {
+    *           return query.with('posts').withQueryExists('posts',(query : Post)=> {
+    *               return query.with('comments','user')
+    *               // relation n, n, ...n
+    *           })
+    *       })
+    *   })
+    *  .findMany()
+    * @returns {this} this
+    */
     withQueryExists<K extends T.RelationKeys<this>, R extends T.Relations<this>>(nameRelation: K, callback: (query: `$${K & string}` extends keyof R ? R[`$${K & string}`] extends (infer X)[] ? X : R[`$${K & string}`] extends Model ? R[`$${K & string}`] : Model : K extends keyof R ? R[K] extends (infer X)[] ? X : R[K] extends Model ? R[K] : Model : Model) => any, options?: {
         pivot: boolean;
     }): this;
@@ -1221,6 +1659,23 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @returns {Model} model instance
      */
     findWithQuery<K extends T.RelationKeys<this>>(name: K): Model | null;
+    /**
+     * The 'ofMany' method is used to transform a many relationship,
+     * into a single related model by selecting one record using an aggregate
+     * function such as MAX or MIN on the specified column.
+     *
+     * @note
+     * This method is not supported on `belongsToMany` relationships.
+     *
+     * @param {string} column The column used for aggregation (e.g. `"id"`, `"created_at"`).
+     * @param {"MAX" | "MIN"} aggregate The aggregate function used to select the record.
+     * @param {((query: Model) => void) | undefined} callback A callback used to apply additional constraints to the aggregate query.
+     *
+     * Only filtering methods are supported. Methods that modify the result set,
+     * such as `select` `orderBy`, `groupBy`, `limit`, `offset`, `union`, and `having`, are not supported.
+     * @returns this
+    */
+    ofMany<K extends T.ColumnKeys<this>, S extends Model | unknown, M = S extends this ? this : S extends Model ? S : this>(column: K, aggregate: "MAX" | "MIN", callback?: (query: M) => M): this;
     /**
      * The 'hasOne' relationship defines a one-to-one relationship between two database tables.
      *
@@ -1313,6 +1768,42 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @returns  {this}   this
      */
     protected belongsToManySingle<K extends TR extends object ? TRelationKeys<TR> : string>({ name, as, model, localKey, foreignKey, freezeTable, pivot, oldVersion, modelPivot, }: TRelationOptions<K>): this;
+    /**
+     * The 'createRelation' method is useful for Creates a relation accessor for a model.
+     *
+     * This method defines how a model relates to another model
+     * (hasOne, hasMany, belongsTo, belongsToMany) and returns
+     * a function that can be used to modify the relation query.
+     *
+     * Example:
+     * ```ts
+     * public posts = this.createRelation(Post, {
+     *   type: 'hasMany',
+     *   foreignKey: 'user_id',
+     * });
+     *
+     * user.posts(q => q.where('id', 1));
+     * ```
+     *
+     * @template M - Target model type
+     * @template K - Optional relation name type
+     *
+     * @param model - The related model constructor
+     * @param options - Relation configuration options
+     * @param options.type - Type of relation (hasOne, hasMany, belongsTo, belongsToMany)
+     * @param options.name - Optional relation name (when applicable)
+     * @param options.as - Alias for relation
+     * @param options.localKey - Local key for the relation
+     * @param options.foreignKey - Foreign key for the relation
+     * @param options.freezeTable - Override pivot/table name
+     * @param options.pivot - Pivot table name (for many-to-many)
+     * @param options.oldVersion - Enable legacy relation behavior
+     *
+     * @returns A function that accepts a query modifier and returns the relation result
+     */
+    protected createRelation<M extends Model, K = void>(model: new () => M, options: (K extends void ? Omit<TRelationQueryOptions, 'name' | 'model'> & Partial<Pick<TRelationQueryOptions, 'name'>> : Omit<TRelationQueryOptions<K>, 'model'>) & {
+        type: 'hasOne' | 'hasMany' | 'belongsTo' | 'belongsToMany';
+    }): (modifier?: T.QueryModifier<M>) => this;
     /**
      * The 'hasOneBuilder' method is useful for creating 'hasOne' relationship to function
      *
@@ -1327,7 +1818,7 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @param    {Function?} callback callback of query
      * @returns  {this} this
      */
-    protected hasOneBuilder({ name, as, model, localKey, foreignKey, freezeTable, }: TRelationQueryOptions, callback?: Function): this;
+    protected hasOneBuilder<K = void>({ name, as, model, localKey, foreignKey, freezeTable, }: K extends void ? Omit<TRelationQueryOptions, 'name'> & Partial<Pick<TRelationQueryOptions, 'name'>> : TRelationQueryOptions<K>, callback?: Function): this;
     /**
      * The 'hasManyBuilder' method is useful for creating 'hasMany' relationship to function
      *
@@ -1342,7 +1833,7 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @param    {function?} callback callback of query
      * @returns  {this} this
      */
-    protected hasManyBuilder({ name, as, model, localKey, foreignKey, freezeTable, }: TRelationQueryOptions, callback?: Function): this;
+    protected hasManyBuilder<K = void>({ name, as, model, localKey, foreignKey, freezeTable, }: K extends void ? Omit<TRelationQueryOptions, 'name'> & Partial<Pick<TRelationQueryOptions, 'name'>> : TRelationQueryOptions<K>, callback?: Function): this;
     /**
      * The 'belongsToBuilder' method is useful for creating 'belongsTo' relationship to function
      * @param    {object}  relation registry relation in your model
@@ -1356,7 +1847,7 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @param    {function?} callback callback of query
      * @returns  {this} this
      */
-    protected belongsToBuilder({ name, as, model, localKey, foreignKey, freezeTable, }: TRelationQueryOptions, callback?: Function): this;
+    protected belongsToBuilder<K = void>({ name, as, model, localKey, foreignKey, freezeTable, }: K extends void ? Omit<TRelationQueryOptions, 'name'> & Partial<Pick<TRelationQueryOptions, 'name'>> : TRelationQueryOptions<K>, callback?: Function): this;
     /**
      * The 'belongsToManyBuilder' method is useful for creating 'belongsToMany' relationship to function
      *
@@ -1371,7 +1862,7 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @param    {function?} callback callback of query
      * @returns  {this} this
      */
-    protected belongsToManyBuilder({ name, as, model, localKey, foreignKey, freezeTable, pivot, oldVersion, modelPivot, }: TRelationQueryOptions, callback?: Function): this;
+    protected belongsToManyBuilder<K = void>({ name, as, model, localKey, foreignKey, freezeTable, pivot, oldVersion, modelPivot, }: K extends void ? Omit<TRelationQueryOptions, 'name'> & Partial<Pick<TRelationQueryOptions, 'name'>> : TRelationQueryOptions<K>, callback?: Function): this;
     /**
      * The 'trashed' method is used to specify that you want to retrieve only the soft-deleted records from a database table.
      *
@@ -1404,22 +1895,26 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @returns {string} string
      */
     toTableNameAndColumn(column: string): string;
+    where<K extends T.ColumnKeys<this>, V extends T.ColumnValue<this, K>>(column: K, value: V): this;
+    where<K extends T.ColumnKeys<this>, V extends T.ColumnValue<this, K>>(column: K, operator: "=" | "<" | ">" | "!=" | "<>" | "<=" | ">=" | "LIKE" | "like", value: V): this;
+    where(column: Partial<{
+        [K in keyof T.ColumnOptions<this>]: T.ColumnOptions<this>[K];
+    }>): this;
+    /**
+    * @override
+    * @param {string | K} column if arguments is object
+    * @param {any?} value
+    * @returns {this} this
+    */
+    orWhere<K extends T.ColumnKeys<this>, V extends T.ColumnValue<this, K>>(column: K, value: V): this;
     /**
      * @override
      * @param {string | K} column if arguments is object
-     * @param {string?} operator ['=', '<', '>' ,'!=', '!<', '!>' ,'LIKE']
+     * @param {string?} operator "=" | "<" | ">" | "!=" | "<>" | "<=" | ">=" | "LIKE"  | "like"
      * @param {any?} value
      * @returns {this} this
      */
-    where<K extends T.ColumnKeys<this>>(column: K | Record<string, any>, operator?: any, value?: any): this;
-    /**
-     * @override
-     * @param {string} column
-     * @param {string?} operator ['=', '<', '>' ,'!=', '!<', '!>' ,'LIKE']
-     * @param {any?} value
-     * @returns {this}
-     */
-    orWhere<K extends T.ColumnKeys<this>>(column: K, operator?: any, value?: any): this;
+    orWhere<K extends T.ColumnKeys<this>, V extends T.ColumnValue<this, K>>(column: K, operator: "=" | "<" | ">" | "!=" | "<>" | "<=" | ">=" | "LIKE" | "like", value: V): this;
     /**
      * @override
      * @param {string} column
@@ -1560,28 +2055,28 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @param {array} array
      * @returns {this}
      */
-    whereBetween<K extends T.ColumnKeys<this>>(column: K, array: [any, any]): this;
+    whereBetween<K extends T.ColumnKeys<this>, V extends T.ColumnValue<this, K>>(column: K, array: [V, V]): this;
     /**
      * @override
      * @param {string} column
      * @param {array} array
      * @returns {this}
      */
-    orWhereBetween<K extends T.ColumnKeys<this>>(column: K, array: [any, any]): this;
+    orWhereBetween<K extends T.ColumnKeys<this>, V extends T.ColumnValue<this, K>>(column: K, array: [V, V]): this;
     /**
      * @override
      * @param {string} column
      * @param {array} array
      * @returns {this}
      */
-    whereNotBetween<K extends T.ColumnKeys<this>>(column: K, array: [any, any]): this;
+    whereNotBetween<K extends T.ColumnKeys<this>, V extends T.ColumnValue<this, K>>(column: K, array: [V, V]): this;
     /**
      * @override
      * @param {string} column
      * @param {array} array
      * @returns {this}
      */
-    orWhereNotBetween<K extends T.ColumnKeys<this>>(column: K, array: [any, any]): this;
+    orWhereNotBetween<K extends T.ColumnKeys<this>, V extends T.ColumnValue<this, K>>(column: K, array: [V, V]): this;
     /**
      * @override
      * @param {string} column
@@ -1652,7 +2147,13 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @param {Function} callback callback query
      * @returns {this}
      */
-    whereQuery<T extends Model | unknown, M = T extends this ? this : T extends Model ? T : this>(callback: (query: M) => M): this;
+    whereQuery(callback: T.QueryModifier<this>): this;
+    /**
+     * @override
+     * @param {Function} callback callback query
+     * @returns {this}
+     */
+    orWhereQuery<T extends Model | unknown, M = T extends this ? this : T extends Model ? T : this>(callback: (query: M) => M): this;
     /**
      * @override
      * @param {string[]} columns
@@ -1680,7 +2181,7 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @param {string | number | undefined | null | Boolean} condition when condition true will return query callback
      * @returns {this} this
      */
-    when<T extends Model | unknown, M = T extends this ? this : T extends Model ? T : this>(condition: string | number | undefined | null | boolean, callback: (query: M) => M): this;
+    when(condition: string | number | undefined | null | boolean, callback: T.QueryModifier<this>): this;
     /**
      * This 'union' method is used to union statement sql
      *
@@ -1802,6 +2303,40 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @returns {this}
      */
     crossJoinModel(m1: TModelOrObject | ((join: JoinModel) => JoinModel), m2?: TModelOrObject): this;
+    /**
+     *
+     * @override
+     * @param {string=} c [column=id]
+     * @returns {promise<number>}
+     */
+    count<K extends T.ColumnKeys<this> | "id" | "_id">(c?: K): Promise<number>;
+    /**
+     *
+     * @override
+     * @param {string=} c [column=id]
+     * @returns {promise<number>}
+     */
+    avg<K extends T.ColumnKeys<this> | "id" | "_id">(c?: K): Promise<number>;
+    /**
+     *
+     * @override
+     * @param {string=} c [column=id]
+     * @returns {promise<number>}
+     */
+    sum<K extends T.ColumnKeys<this> | "id" | "_id">(c?: K): Promise<number>;
+    /**
+     *
+     * @override
+     * @param {string=} c [column=id]
+     * @returns {promise<number>}
+     */
+    max<K extends T.ColumnKeys<this> | "id" | "_id">(c?: K): Promise<number>;
+    /**
+     * @override
+     * @param {string} c
+     * @returns {promise<number>}
+     */
+    min<K extends T.ColumnKeys<this> | "id" | "_id">(c: K): Promise<number>;
     /**
      * @override
      * @returns {promise<boolean>} promise boolean
@@ -1871,6 +2406,12 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @returns {promise<Record<string,any> | null>} Record | null
      */
     findOne<K>(cb?: Function): Promise<T.Result<this, K> | null>;
+    /**
+     * @override
+     * @param {number} id callback function return query sql
+     * @returns {promise<Record<string,any> | null>} Record | null
+     */
+    find<K>(primaryKey: number | string): Promise<T.Result<this, K> | null>;
     /**
      * @override
      * @returns {promise<object | Error>} Record | throw error
@@ -1898,28 +2439,30 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
     findMany<K>(cb?: Function): Promise<T.Result<this, K>[]>;
     /**
      * @override
-     * @param    {object?} paginationOptions by default page = 1 , limit = 15
-     * @property {number} paginationOptions.limit
-     * @property {number} paginationOptions.page
+     * @param    {object?}  opts by default page = 1 , limit = 15
+     * @property {number?}  opts.limit
+     * @property {number?}  opts.page
+     * @property {boolean?} opts.distinct
      * @returns  {promise<Pagination>} Pagination
      */
-    pagination<K>(paginationOptions?: {
+    pagination<K>(opts?: {
         limit?: number;
         page?: number;
-        alias?: boolean;
+        distinct?: boolean;
     }): Promise<T.PaginateResult<this, K>>;
     /**
      *
      * @override
-     * @param     {?object} paginationOptions by default page = 1 , limit = 15
-     * @property  {number}  paginationOptions.limit
-     * @property  {number}  paginationOptions.page
+     * @param     {?object} opts by default page = 1 , limit = 15
+     * @property  {number?} opts.limit
+     * @property  {number?} opts.page
+     * @property {boolean?} opts.distinct
      * @returns   {promise<Pagination>} Pagination
      */
-    paginate<K>(paginationOptions?: {
+    paginate<K>(opts?: {
         limit?: number;
         page?: number;
-        alias?: boolean;
+        distinct?: boolean;
     }): Promise<T.PaginateResult<this, K>>;
     /**
      * @override
@@ -1950,164 +2493,130 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @param {object} data for insert
      * @returns {this} this
      */
-    insert<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: {
-        [P in Exclude<K & keyof C, "id"> as null extends C[P] ? any : undefined extends C[P] ? never : P]: Extract<C[P], Date> extends never ? C[P] : any;
-    }): this;
+    insert<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: T.InsertInput<K, C>): Model<TS, TR, "create">;
     /**
      * @override
      * @param {object} data for insert
      * @returns {this} this
      */
-    create<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: {
-        [P in Exclude<K & keyof C, "id"> as null extends C[P] ? any : undefined extends C[P] ? never : P]: Extract<C[P], Date> extends never ? C[P] : any;
-    }): this;
+    create<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: T.InsertInput<K, C>): Model<TS, TR, "create">;
     /**
      * @override
      * @param {object} data
      * @param {array?} updateNotExists options for except update some records in your ${data}
      * @returns {this} this
      */
-    update<K extends T.ColumnKeys<this>, T extends T.ColumnOptions<this>>(data: {
-        [P in K & keyof T]: T[P];
-    }, updateNotExists?: T.ColumnKeys<this>[]): this;
+    update<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: T.UpdateInput<K, C>, updateNotExists?: T.ColumnKeys<this>[]): Model<TS, TR, "update">;
     /**
      * @override
      * @param {object} data
      * @param {array?} updateNotExists options for except update some records in your ${data}
      * @returns {this} this
      */
-    updateMany<K extends T.ColumnKeys<this>, T extends T.ColumnOptions<this>>(data: {
-        [P in K & keyof T]: T[P];
-    }, updateNotExists?: string[]): this;
-    /**
-   *
-   * @override
-   * @param {Array<{when: Record<string, string | number | boolean | null | undefined>, columns: Record<string, string | number | boolean | null | undefined>}>>} cases
-   *   An array of update cases.
-   *   - `when` is an object specifying the conditions to match records.
-   *   - `columns` is an object specifying the new values to set for the matched records.
-   *
-   * @property {Record<string,string | number | boolean | null | undefined>}  cases.when
-   * @property {Record<string,string | number | boolean | null | undefined>}  cases.columns
-   * @returns {this} this
-   */
+    updateMany<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: T.UpdateInput<K, C>, updateNotExists?: string[]): Model<TS, TR, "updateMany">;
+    /**
+     *
+     * @override
+     * @param {Array<{when: Record<string, string | number | boolean | null | undefined>, columns: Record<string, string | number | boolean | null | undefined>}>>} cases
+     *   An array of update cases.
+     *   - `when` is an object specifying the conditions to match records.
+     *   - `columns` is an object specifying the new values to set for the matched records.
+     *
+     * @property {Record<string,string | number | boolean | null | undefined>}  cases.when
+     * @property {Record<string,string | number | boolean | null | undefined>}  cases.columns
+     * @returns {this} this
+     */
     updateCases<T extends T.ColumnOptions<this>, K extends keyof T, U extends Model | unknown, M = U extends this ? this : U extends Model ? U : this>(cases: {
         condition: ((query: M) => M) | Partial<{
-            [P in K & keyof T]: T[P];
+            [P in K & keyof T]: Extract<T[P], Record<string, unknown>> extends never ? T[P] : string;
         }>;
         columns: Partial<{
-            [P in K & keyof T]: T[P];
+            [P in K & keyof T]: Extract<T[P], Record<string, unknown>> extends never ? T[P] : string;
         }>;
-    }[]): this;
+    }[]): Model<TS, TR, "updateMany">;
     /**
      * @override
      * @param {object} data
      * @returns {this} this
      */
-    updateNotExists<K extends T.ColumnKeys<this>, T extends T.ColumnOptions<this>>(data: {
-        [P in K & keyof T]: T[P];
-    }): this;
+    updateNotExists<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: T.UpdateInput<K, C>): Model<TS, TR, "update">;
     /**
      * @override
      * @param {object} data for update or create
      * @returns {this} this
      */
-    updateOrCreate<K extends T.ColumnKeys<this>, T extends T.ColumnOptions<this>>(data: {
-        [P in K & keyof T]: T[P];
-    }): this;
+    updateOrCreate<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: T.InsertOrUpdateInput<K, C>): Model<TS, TR, "createOrUpdate">;
     /**
      * @override
      * @param {object} data for update or create
      * @returns {this} this
      */
-    updateOrInsert<K extends T.ColumnKeys<this>, T extends T.ColumnOptions<this>>(data: {
-        [P in K & keyof T]: T[P];
-    }): this;
+    updateOrInsert<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: T.InsertOrUpdateInput<K, C>): Model<TS, TR, "createOrUpdate">;
     /**
      * @override
      * @param {object} data for update or create
      * @returns {this} this
      */
-    insertOrUpdate<K extends T.ColumnKeys<this>, T extends T.ColumnOptions<this>>(data: {
-        [P in K & keyof T]: T[P];
-    }): this;
+    insertOrUpdate<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: T.InsertOrUpdateInput<K, C>): Model<TS, TR, "createOrUpdate">;
     /**
      * @override
      * @param {object} data for update or create
      * @returns {this} this
      */
-    createOrUpdate<K extends T.ColumnKeys<this>, T extends T.ColumnOptions<this>>(data: {
-        [P in K & keyof T]: T[P];
-    }): this;
+    createOrUpdate<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: T.InsertOrUpdateInput<K, C>): Model<TS, TR, "createOrUpdate">;
     /**
      * @override
      * @param {object} data for create
      * @returns {this} this
      */
-    createOrSelect<K extends T.ColumnKeys<this>, T extends T.ColumnOptions<this>>(data: {
-        [P in K & keyof T]: T[P];
-    }): this;
+    createOrSelect<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: T.InsertInput<K, C>): Model<TS, TR, "createOrSelect">;
     /**
      * @override
      * @param {object} data for update or create
      * @returns {this} this
      */
-    insertOrSelect<K extends T.ColumnKeys<this>, T extends T.ColumnOptions<this>>(data: {
-        [P in K & keyof T]: T[P];
-    }): this;
+    insertOrSelect<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: T.InsertInput<K, C>): Model<TS, TR, "createOrSelect">;
     /**
      *
      * @override
      * @param {object} data create not exists data
      * @returns {this} this
      */
-    createNotExists<K extends T.ColumnKeys<this>, T extends T.ColumnOptions<this>>(data: {
-        [P in K & keyof T]: T[P];
-    }): this;
+    createNotExists<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: T.InsertInput<K, C>): Model<TS, TR, "createNotExists">;
     /**
      *
      * @override
      * @param {object} data create not exists data
      * @returns {this} this this
      */
-    insertNotExists<K extends T.ColumnKeys<this>, T extends T.ColumnOptions<this>>(data: {
-        [P in K & keyof T]: T[P];
-    }): this;
+    insertNotExists<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: T.InsertInput<K, C>): Model<TS, TR, "createNotExists">;
     /**
      * @override
      * @param {Record<string,any>[]} data create multiple data
      * @returns {this} this this
      */
-    createMultiple<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: {
-        [P in Exclude<K & keyof C, "id"> as null extends C[P] ? any : undefined extends C[P] ? never : P]: Extract<C[P], Date> extends never ? C[P] : any;
-    }[]): this;
+    createMultiple<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: T.InsertInput<K, C>[]): Model<TS, TR, "createMany">;
     /**
      *
      * @override
      * @param {Record<string,any>[]} data create multiple data
      * @returns {this} this
      */
-    createMany<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: {
-        [P in Exclude<K & keyof C, "id"> as null extends C[P] ? any : undefined extends C[P] ? never : P]: Extract<C[P], Date> extends never ? C[P] : any;
-    }[]): this;
+    createMany<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: T.InsertInput<K, C>[]): Model<TS, TR, "createMany">;
     /**
      *
      * @override
      * @param {Record<string,any>[]} data create multiple data
      * @returns {this} this
      */
-    insertMultiple<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: {
-        [P in Exclude<K & keyof C, "id"> as null extends C[P] ? any : undefined extends C[P] ? never : P]: Extract<C[P], Date> extends never ? C[P] : any;
-    }[]): this;
+    insertMultiple<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: T.InsertInput<K, C>[]): Model<TS, TR, "createMany">;
     /**
      *
      * @override
      * @param {Record<string,any>[]} data create multiple data
      * @returns {this} this
      */
-    insertMany<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: {
-        [P in Exclude<K & keyof C, "id"> as null extends C[P] ? any : undefined extends C[P] ? never : P]: Extract<C[P], Date> extends never ? C[P] : any;
-    }[]): this;
+    insertMany<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: T.InsertInput<K, C>[]): Model<TS, TR, "createMany">;
     /**
      * The 'getSchemaModel' method is used get a schema model
      * @returns {Record<string, Blueprint> | null} Record<string, Blueprint> | null
@@ -2131,7 +2640,7 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      */
     save({ waitMs }?: {
         waitMs?: number | undefined;
-    }): Promise<T.InsertResult<this> | T.InsertManyResult<this> | T.InsertNotExistsResult<this> | T.UpdateResult<this> | T.UpdateManyResult<this> | null | undefined>;
+    }): Promise<TSaveModelResult<this, TA>>;
     /**
      *
      * @override
@@ -2180,6 +2689,7 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
     private _makeTableName;
     private _handleSoftDelete;
     private _prepareQueryPipeline;
+    private _ensureRelationOwnerKeysSelected;
     private _handleGlobalScope;
     /**
      * @override
@@ -2191,9 +2701,7 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * generate sql statements
      * @override
      */
-    protected _queryBuilder({ onFormat }?: {
-        onFormat?: boolean | undefined;
-    }): any;
+    protected _queryBuilder(): QueryBuilder;
     private _runBefore;
     private _runAfter;
     private _validateSchema;
@@ -2213,6 +2721,7 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
     private _insertOrSelectModel;
     private _updateModel;
     private _assertError;
+    disabledRetry(): this;
     private _checkSchemaOrNextError;
     private _stoppedRetry;
     private _observer;
@@ -2221,6 +2730,7 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
     private _isModel;
     private _getBlueprintByColumn;
     private _handleJoinModel;
+    private _formatedInputData;
     private _initialModel;
 }
 export { Model };