tspace-mysql 1.9.0 → 1.9.1

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

@@ -5,7 +5,7 @@ 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 type { TRelationOptions, TValidateSchema, TGlobalSetting, TPattern, TRelationQueryOptions, TModelOrObject, TRelationKeys, TLifecycle, TCacheModel, TRawStringQuery } from "../types";
 import { Join } from "./Join";
 /**
  *
@@ -79,11 +79,332 @@ 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(): TCache;
+    static get cache(): TCacheModel;
     /**
      *  The 'boot' method is a special method that you can define within a model.
      *  @example
@@ -223,29 +544,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 +845,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.
@@ -613,11 +934,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;
     /**
      *
@@ -1404,22 +1727,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 (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(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 (K & keyof T.ColumnOptions<this> extends never ? any : T.ColumnOptions<this>[K & keyof T.ColumnOptions<this>])>(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 (K & keyof T.ColumnOptions<this> extends never ? any : T.ColumnOptions<this>[K & keyof T.ColumnOptions<this>])>(column: K, operator: "=" | "<" | ">" | "!=" | "<>" | "<=" | ">=" | "LIKE" | "like", value: V): this;
     /**
      * @override
      * @param {string} column
@@ -1560,28 +1887,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 (K & keyof T.ColumnOptions<this> extends never ? any : T.ColumnOptions<this>[K & keyof T.ColumnOptions<this>])>(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 (K & keyof T.ColumnOptions<this> extends never ? any : T.ColumnOptions<this>[K & keyof T.ColumnOptions<this>])>(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 (K & keyof T.ColumnOptions<this> extends never ? any : T.ColumnOptions<this>[K & keyof T.ColumnOptions<this>])>(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 (K & keyof T.ColumnOptions<this> extends never ? any : T.ColumnOptions<this>[K & keyof T.ColumnOptions<this>])>(column: K, array: [V, V]): this;
     /**
      * @override
      * @param {string} column
@@ -1653,6 +1980,12 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @returns {this}
      */
     whereQuery<T extends Model | unknown, M = T extends this ? this : T extends Model ? T : this>(callback: (query: M) => M): 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
@@ -1802,6 +2135,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=} column [column=id]
+     * @returns {promise<number>}
+     */
+    count<K extends T.ColumnKeys<this> | "id" | "_id">(c?: K): Promise<number>;
+    /**
+     *
+     * @override
+     * @param {string=} column [column=id]
+     * @returns {promise<number>}
+     */
+    avg<K extends T.ColumnKeys<this> | "id" | "_id">(c?: K): Promise<number>;
+    /**
+     *
+     * @override
+     * @param {string=} column [column=id]
+     * @returns {promise<number>}
+     */
+    sum<K extends T.ColumnKeys<this> | "id" | "_id">(c?: K): Promise<number>;
+    /**
+     *
+     * @override
+     * @param {string=} column [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 +2238,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
@@ -1951,52 +2324,46 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @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;
+        [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;
     /**
      * @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>): this;
     /**
      * @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>[]): this;
     /**
      * @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[]): 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
+     */
     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;
     /**
@@ -2004,110 +2371,84 @@ declare class Model<TS extends Record<string, any> = any, TR = unknown> extends
      * @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>): this;
     /**
      * @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.InsertInput<K, C>): this;
     /**
      * @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.InsertInput<K, C>): this;
     /**
      * @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.InsertInput<K, C>): this;
     /**
      * @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.InsertInput<K, C>): this;
     /**
      * @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>): this;
     /**
      * @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>): this;
     /**
      *
      * @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>): this;
     /**
      *
      * @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>): this;
     /**
      * @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>[]): this;
     /**
      *
      * @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>[]): this;
     /**
      *
      * @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>[]): this;
     /**
      *
      * @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>[]): this;
     /**
      * The 'getSchemaModel' method is used get a schema model
      * @returns {Record<string, Blueprint> | null} Record<string, Blueprint> | null
@@ -2180,6 +2521,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 +2533,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(): any;
     private _runBefore;
     private _runAfter;
     private _validateSchema;
@@ -2213,6 +2553,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 +2562,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 };