tspace-mysql 1.9.1 → 1.9.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 { TRelationOptions, TValidateSchema, TGlobalSetting, TPattern, TRelationQueryOptions, TModelOrObject, TRelationKeys, TLifecycle, TCacheModel, TRawStringQuery } 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.
@@ -405,6 +406,63 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @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 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
@@ -918,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
@@ -949,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;
     /**
      *
@@ -997,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
@@ -1047,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;
@@ -1087,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.
      *
@@ -1429,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;
@@ -1544,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.
      *
@@ -1636,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
      *
@@ -1650,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
      *
@@ -1665,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
@@ -1679,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
      *
@@ -1694,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.
      *
@@ -1727,8 +1895,8 @@ 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 (K & keyof T.ColumnOptions<this> extends never ? any : T.ColumnOptions<this>[K & keyof T.ColumnOptions<this>])>(column: K, value: V): this;
-    where<K extends T.ColumnKeys<this>, V extends (K & keyof T.ColumnOptions<this> extends never ? any : T.ColumnOptions<this>[K & keyof T.ColumnOptions<this>])>(column: K, operator: "=" | "<" | ">" | "!=" | "<>" | "<=" | ">=" | "LIKE" | "like", value: V): this;
+    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;
@@ -1738,7 +1906,7 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
     * @param {any?} value
     * @returns {this} this
     */
-    orWhere<K extends T.ColumnKeys<this>, V extends (K & keyof T.ColumnOptions<this> extends never ? any : T.ColumnOptions<this>[K & keyof T.ColumnOptions<this>])>(column: K, value: V): 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
@@ -1746,7 +1914,7 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @param {any?} value
      * @returns {this} this
      */
-    orWhere<K extends T.ColumnKeys<this>, V extends (K & keyof T.ColumnOptions<this> extends never ? any : T.ColumnOptions<this>[K & keyof T.ColumnOptions<this>])>(column: K, operator: "=" | "<" | ">" | "!=" | "<>" | "<=" | ">=" | "LIKE" | "like", value: V): 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
@@ -1887,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>, V extends (K & keyof T.ColumnOptions<this> extends never ? any : T.ColumnOptions<this>[K & keyof T.ColumnOptions<this>])>(column: K, array: [V, V]): 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>, V extends (K & keyof T.ColumnOptions<this> extends never ? any : T.ColumnOptions<this>[K & keyof T.ColumnOptions<this>])>(column: K, array: [V, V]): 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>, V extends (K & keyof T.ColumnOptions<this> extends never ? any : T.ColumnOptions<this>[K & keyof T.ColumnOptions<this>])>(column: K, array: [V, V]): 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>, V extends (K & keyof T.ColumnOptions<this> extends never ? any : T.ColumnOptions<this>[K & keyof T.ColumnOptions<this>])>(column: K, array: [V, V]): this;
+    orWhereNotBetween<K extends T.ColumnKeys<this>, V extends T.ColumnValue<this, K>>(column: K, array: [V, V]): this;
     /**
      * @override
      * @param {string} column
@@ -1979,7 +2147,7 @@ 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
@@ -2013,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
      *
@@ -2138,28 +2306,28 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
     /**
      *
      * @override
-     * @param {string=} column [column=id]
+     * @param {string=} c [column=id]
      * @returns {promise<number>}
      */
     count<K extends T.ColumnKeys<this> | "id" | "_id">(c?: K): Promise<number>;
     /**
      *
      * @override
-     * @param {string=} column [column=id]
+     * @param {string=} c [column=id]
      * @returns {promise<number>}
      */
     avg<K extends T.ColumnKeys<this> | "id" | "_id">(c?: K): Promise<number>;
     /**
      *
      * @override
-     * @param {string=} column [column=id]
+     * @param {string=} c [column=id]
      * @returns {promise<number>}
      */
     sum<K extends T.ColumnKeys<this> | "id" | "_id">(c?: K): Promise<number>;
     /**
      *
      * @override
-     * @param {string=} column [column=id]
+     * @param {string=} c [column=id]
      * @returns {promise<number>}
      */
     max<K extends T.ColumnKeys<this> | "id" | "_id">(c?: K): Promise<number>;
@@ -2271,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
@@ -2323,29 +2493,27 @@ 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" | "_id" | "uuid"> as null extends C[P] ? any : P]: Extract<C[P], Date> extends never ? Extract<C[P], Record<string, unknown>> extends never ? C[P] : string : 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: T.InsertInput<K, C>): 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>, C extends T.ColumnOptions<this>>(data: T.UpdateInput<K, C>, 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>, C extends T.ColumnOptions<this>>(data: T.UpdateInput<K, C>, updateNotExists?: string[]): this;
+    updateMany<K extends T.ColumnKeys<this>, C extends T.ColumnOptions<this>>(data: T.UpdateInput<K, C>, updateNotExists?: string[]): Model<TS, TR, "updateMany">;
     /**
      *
      * @override
@@ -2365,90 +2533,90 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
         columns: Partial<{
             [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>, C extends T.ColumnOptions<this>>(data: T.UpdateInput<K, C>): 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>, C extends T.ColumnOptions<this>>(data: T.InsertInput<K, C>): 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>, C extends T.ColumnOptions<this>>(data: T.InsertInput<K, C>): 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>, C extends T.ColumnOptions<this>>(data: T.InsertInput<K, C>): 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>, C extends T.ColumnOptions<this>>(data: T.InsertInput<K, C>): 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>, C extends T.ColumnOptions<this>>(data: T.InsertInput<K, C>): 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>, C extends T.ColumnOptions<this>>(data: T.InsertInput<K, C>): 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>, C extends T.ColumnOptions<this>>(data: T.InsertInput<K, C>): 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>, C extends T.ColumnOptions<this>>(data: T.InsertInput<K, C>): 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: T.InsertInput<K, C>[]): 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: T.InsertInput<K, C>[]): 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: T.InsertInput<K, C>[]): 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: T.InsertInput<K, C>[]): 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
@@ -2472,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
@@ -2533,7 +2701,7 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * generate sql statements
      * @override
      */
-    protected _queryBuilder(): any;
+    protected _queryBuilder(): QueryBuilder;
     private _runBefore;
     private _runAfter;
     private _validateSchema;