tspace-mysql 1.9.0 → 1.9.1

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

@@ -1,55 +1,53 @@
+import { TRawStringQuery } from "../types";
 import { Model } from "./Model";
-import type { T } from "./UtilityTypes";
+import { type T } from "./UtilityTypes";
 declare class RepositoryFactory<TS extends Record<string, any> = Record<string, any>, TR = unknown, M extends Model<TS, TR> = Model<TS, TR>> {
     private _model;
     constructor(_model: {
         new (): Model<TS, TR>;
     });
     /**
-     *
-     * The 'first' method is used to retrieve the first 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 | null>}
-     *
-     * @example
-     * import { Repository } from 'tspace-mysql'
-     * import { User } from '../Models/User'
-     *
-     * const userRepository =  Repository(User)
-     *
-     *  const user = await userRepository.findOne({
-     *       select : { id: true, name: true },
-     *       where : {
-     *           id: 1
-     *       }
-     *   })
-     *
-     *  const user = await userRepository.findOne()
-     */
-    first<K = {}, S extends T.SelectOptions<M> | undefined = undefined, SR extends T.RelationOptions<M> | undefined = undefined, E extends T.ExceptOptions<M> | undefined = undefined>(options?: T.RepositoryOptions<M, S, SR, E>): Promise<T.ResultFiltered<M, K, S, SR, E> | null>;
+    *
+    * 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 | null>}
+    *
+    * @example
+    * import { Repository } from 'tspace-mysql'
+    * import { User } from '../Models/User'
+    *
+    * const userRepository =  Repository(User)
+    *
+    *  const user = await userRepository.find(1,{
+    *     select : { id: true, name: true }
+    *   })
+    *
+    *  const user = await userRepository.findOne()
+    */
+    find<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 = {}>(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 findOne record that matches the query conditions.
+     * The 'findOne' method is used to retrieve the first 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
@@ -88,10 +86,10 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
      *
      *  const user = await userRepository.findOne()
      */
-    findOne<K = {}, S extends T.SelectOptions<M> | undefined = undefined, SR extends T.RelationOptions<M> | undefined = undefined, E extends T.ExceptOptions<M> | undefined = undefined>(options?: T.RepositoryOptions<M, S, SR, E>): Promise<T.ResultFiltered<M, K, S, SR, E> | null>;
+    findOne<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 = {}>(options?: T.RepositoryOptions<M, S, SR, E, SRS, G>): Promise<T.ResultFiltered<M, S, SR, E, SRS, G> | null>;
     /**
      *
-     * The 'get' method is used to retrieve the get record that matches the query conditions.
+     * 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
@@ -130,52 +128,10 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
      *
      *  const users = await userRepository.get()
      */
-    get<K = {}, S extends T.SelectOptions<M> | undefined = undefined, SR extends T.RelationOptions<M> | undefined = undefined, E extends T.ExceptOptions<M> | undefined = undefined>(options?: T.RepositoryOptions<M, S, SR, E>): Promise<T.ResultFiltered<M, K, S, SR, E>[]>;
-    /**
-     *
-     * The 'get' 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 { Repository } from 'tspace-mysql'
-     * import { User } from '../Models/User'
-     *
-     * const userRepository =  Repository(User)
-     *
-     *  const users = await userRepository.findMany({
-     *       select : { id: true, name: true },
-     *       where : {
-     *           id: 1
-     *       }
-     *   })
-     *
-     *  const users = await userRepository.findMany()
-     */
-    findMany<K = {}, S extends T.SelectOptions<M> | undefined = undefined, SR extends T.RelationOptions<M> | undefined = undefined, E extends T.ExceptOptions<M> | undefined = undefined>(options?: T.RepositoryOptions<M, S, SR, E>): Promise<T.ResultFiltered<M, K, S, SR, E>[]>;
+    findMany<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 = {}>(options?: T.RepositoryOptions<M, S, SR, E, SRS, G>): Promise<T.ResultFiltered<M, S, SR, E, SRS, G>[]>;
     /**
      *
-     * The 'pagination' method is used to perform pagination on a set of database query results obtained through the Query Builder.
+     * 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.
@@ -207,24 +163,22 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
      *
      * const userRepository =  Repository(User)
      *
-     *  const users = await userRepository.pagination({
+     *  const users = await userRepository.paginate({
      *       select : { id: true, name: true },
      *       where : {
      *           id: 1
      *       }
      *   })
      *
-     *  const users = await userRepository.pagination({ page : 1 , limit : 2 })
+     *  const users = await userRepository.paginate({ page : 1 , limit : 2 })
      */
-    pagination<K = {}, S extends T.SelectOptions<M> | undefined = undefined, SR extends T.RelationOptions<M> | undefined = undefined, E extends T.ExceptOptions<M> | undefined = undefined>(options?: Partial<T.RepositoryOptions<M, S, SR, E>> & {
+    paginate<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 = {}>(options?: Omit<Partial<T.RepositoryOptions<M, S, SR, E, SRS, G>> & {
         page?: number;
-    }): Promise<T.PaginateResultFiltered<M, K, S, SR, E>>;
+    }, '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.
      *
-     * 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
+     * It returns a boolean value indicating whether there are any matching records.
      * @type     {?object}  options
      * @property {?object} options.select
      * @property {?object} options.except
@@ -240,12 +194,7 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
      * @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 { Repository } from 'tspace-mysql'
@@ -253,39 +202,12 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
      *
      * const userRepository =  Repository(User)
      *
-     *  const users = await userRepository.paginate({
-     *       select : { id: true, name: true },
+     *  const users = await userRepository.exists({
      *       where : {
      *           id: 1
      *       }
      *   })
      *
-     *  const users = await userRepository.paginate({ page : 1 , limit : 2 })
-     */
-    paginate<K = {}, S extends T.SelectOptions<M> | undefined = undefined, SR extends T.RelationOptions<M> | undefined = undefined, E extends T.ExceptOptions<M> | undefined = undefined>(options?: Partial<T.RepositoryOptions<M, S, SR, E>> & {
-        page?: number;
-    }): Promise<T.PaginateResultFiltered<M, K, S, SR, E>>;
-    /**
-     * 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
      */
     exists(options: Partial<Omit<T.RepositoryOptions<M>, "relations" | "relationQuery">>): Promise<boolean>;
     /**
@@ -308,7 +230,6 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
      * @property {?{localKey , referenceKey}[]} options.rightJoin
      * @property {?{localKey , referenceKey}[]} options.leftJoin
      * @property {?boolean} options.debug
-     * @property {?number} options.page
      * @returns {string}
      */
     toString(options?: Partial<Omit<T.RepositoryOptions<M>, "relations" | "relationQuery">>): string;
@@ -364,7 +285,7 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
      * @property {?number} options.page
      * @return {promise<any[]>}
      */
-    toArray(column: keyof Partial<TS> | `${string}.${string}`, options?: Partial<Omit<T.RepositoryOptions<M>, "relations" | "relationQuery">>): Promise<T.Result<M>[]>;
+    toArray<K extends T.ColumnKeys<M> | `${string}.${string}`>(column: K, options?: Partial<Omit<T.RepositoryOptions<M>, "relations" | "relationQuery">>): Promise<(K extends keyof T.Result<M> ? T.Result<M>[K] : unknown)[]>;
     /**
      * The 'count' method is used to retrieve the total number of records that match the specified query conditions.
      *
@@ -389,7 +310,7 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
      * @property {?number} options.page
      * @return {promise<any[]>}
      */
-    count(column: keyof Partial<TS> | `${string}.${string}`, options?: Partial<Omit<T.RepositoryOptions<M>, "relations" | "relationQuery">>): Promise<number>;
+    count(column: T.ColumnKeys<M> | `${string}.${string}`, options?: Partial<Omit<T.RepositoryOptions<M>, "relations" | "relationQuery">>): Promise<number>;
     /**
      * The 'avg' method is used to retrieve the total number of records that match the specified query conditions.
      *
@@ -414,7 +335,7 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
      * @property {?number} options.page
      * @return {promise<any[]>}
      */
-    avg(column: keyof Partial<TS> | `${string}.${string}`, options?: Partial<Omit<T.RepositoryOptions<M>, "relations" | "relationQuery">>): Promise<number>;
+    avg(column: T.ColumnKeys<M> | `${string}.${string}`, options?: Partial<Omit<T.RepositoryOptions<M>, "relations" | "relationQuery">>): Promise<number>;
     /**
      * The 'sum' method is used to retrieve the total number of records that match the specified query conditions.
      *
@@ -439,7 +360,7 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
      * @property {?number} options.page
      * @return {promise<any[]>}
      */
-    sum(column: keyof Partial<TS> | `${string}.${string}`, options?: Partial<Omit<T.RepositoryOptions<M>, "relations" | "relationQuery">>): Promise<number>;
+    sum(column: T.ColumnKeys<M> | `${string}.${string}`, options?: Partial<Omit<T.RepositoryOptions<M>, "relations" | "relationQuery">>): Promise<number>;
     /**
      * The 'max' method is used to retrieve the maximum value of a numeric column in a database table.
      *
@@ -464,7 +385,7 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
      * @property {?number} options.page
      * @return {promise<any[]>}
      */
-    max(column: keyof Partial<TS> | `${string}.${string}`, options?: Partial<Omit<T.RepositoryOptions<M>, "relations" | "relationQuery">>): Promise<number>;
+    max(column: T.ColumnKeys<M> | `${string}.${string}`, options?: Partial<Omit<T.RepositoryOptions<M>, "relations" | "relationQuery">>): Promise<number>;
     /**
      * The 'min' method is used to retrieve the minimum (lowest) value of a numeric column in a database table.
      *
@@ -489,7 +410,7 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
      * @property {?number} options.page
      * @return {promise<any[]>}
      */
-    min(column: keyof Partial<TS> | `${string}.${string}`, options?: Partial<Omit<T.RepositoryOptions<M>, "relations" | "relationQuery">>): Promise<number>;
+    min(column: T.ColumnKeys<M> | `${string}.${string}`, options?: Partial<Omit<T.RepositoryOptions<M>, "relations" | "relationQuery">>): Promise<number>;
     /**
      * The 'create' method is used to insert a new record into a database table associated.
      *
@@ -498,20 +419,9 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
      * @property {object} options.data
      * @property {?boolean} options.debug
      * @property {?transaction} options.transaction
-     * @return {promise<TS>}
-     */
-    create({ data, debug, transaction, }: T.RepositoryCreate<M>): Promise<T.Result<M>>;
-    /**
-     * The 'insert' 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<TS>}
+     * @return {promise<T.Result<M>>}
      */
-    insert({ data, debug }: T.RepositoryCreate<M>): Promise<T.Result<M>>;
+    create<NR extends boolean | undefined = false>({ data, debug, transaction, noReturn, }: T.RepositoryCreate<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.
      *
@@ -525,21 +435,7 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
      * @property {?transaction} options.transaction
      * @return {promise<T | null>}
      */
-    createNotExists({ data, where, debug, }: T.RepositoryCreateOrThings<M>): Promise<T.Result<M> | null>;
-    /**
-     * The 'insertNotExists' 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>}
-     */
-    insertNotExists({ data, where, debug, }: T.RepositoryCreateOrThings<M>): Promise<T.Result<M> | null>;
+    createNotExists<NR extends boolean | undefined = false>({ data, where, debug, noReturn, transaction }: T.RepositoryCreateOrThings<M, NR>): Promise<NR extends true ? undefined : T.Result<M> | null>;
     /**
      * The 'createMultiple' method is used to insert a new records into a database table associated.
      *
@@ -550,9 +446,9 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
      * @property {?transaction} options.transaction
      * @return {promise<TS[]>}
      */
-    createMultiple({ data, debug, transaction, }: T.RepositoryCreateMultiple<M>): Promise<T.Result<M>[]>;
+    createMultiple<NR extends boolean | undefined = false>({ data, debug, transaction, noReturn }: T.RepositoryCreateMultiple<M, NR>): Promise<NR extends true ? undefined : T.Result<M>[]>;
     /**
-     * The 'createMultiple' method is used to insert a new records into a database table associated.
+     * 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
@@ -561,7 +457,7 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
      * @property {?transaction} options.transaction
      * @return {promise<TS[]>}
      */
-    insertMultiple({ data, debug, }: T.RepositoryCreateMultiple<M>): Promise<T.Result<M>[]>;
+    createMany<NR extends boolean | undefined = false>({ data, debug, transaction, noReturn }: 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.
@@ -572,22 +468,9 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
      * @property {object} options.data
      * @property {object} options.where
      * @property {?boolean} options.debug
-     * @return {promise<TS>}
-     */
-    createOrUpdate({ data, where, debug, }: T.RepositoryCreateOrThings<M>): Promise<T.Result<M>>;
-    /**
-     *
-     * The 'insertOrUpdate' 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<TS>}
+     * @return {promise<T.Result<M>>}
      */
-    insertOrUpdate({ data, where, debug, }: T.RepositoryCreateOrThings<M>): Promise<T.Result<M>>;
+    createOrUpdate<NR extends boolean | undefined = false>({ data, where, debug, transaction, noReturn }: T.RepositoryCreateOrThings<M, NR>): Promise<NR extends true ? undefined : T.Result<M>>;
     /**
      *
      * The 'createOrSelect' method to insert data into a database table while select any duplicate key constraint violations.
@@ -598,23 +481,9 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
      * @property {object} options.data
      * @property {object} options.where
      * @property {?boolean} options.debug
-     * @return {promise<TS>}
-     */
-    createOrSelect({ data, where, debug, }: T.RepositoryCreateOrThings<M>): Promise<T.Result<M>>;
-    /**
-     *
-     * The 'insertOrSelect' 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
-     * @property {?transaction} options.transaction
-     * @return {promise<TS>}
+     * @return {promise<T.Result<M>>}
      */
-    insertOrSelect({ data, where, debug, }: T.RepositoryCreateOrThings<M>): Promise<T.Result<M>>;
+    createOrSelect<NR extends boolean | undefined = false>({ data, where, debug, transaction, noReturn }: 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.
      *
@@ -626,9 +495,9 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
      * @property {object} options.where
      * @property {?boolean} options.debug
      * @property {?transaction} options.transaction
-     * @return {promise<TS>}
+     * @return {promise<T.Result<M>>}
      */
-    update({ data, where, debug, transaction, }: T.RepositoryUpdate<M>): Promise<T.Result<M>>;
+    update<NR extends boolean | undefined = false>({ data, where, debug, transaction, noReturn }: 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.
      *
@@ -640,9 +509,9 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
      * @property {object} options.where
      * @property {?boolean} options.debug
      * @property {?transaction} options.transaction
-     * @return {promise<TS>}
+     * @return {promise<T.Result<M>[]>}
      */
-    updateMany({ data, where, debug, transaction, }: T.RepositoryUpdate<M>): Promise<T.Result<M>[]>;
+    updateMany<NR extends boolean | undefined = false>({ data, where, debug, transaction, noReturn }: T.RepositoryUpdate<M, NR>): Promise<NR extends true ? undefined : T.Result<M>[]>;
     /**
      * The 'updateCases' method is used to update records in a table based on specific conditions.
      *
@@ -681,7 +550,7 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
      * })
      *
      */
-    updateCases({ cases, debug, transaction, }: T.RepositoryUpdateMultiple<M>): Promise<T.Result<M>[]>;
+    updateCases<NR extends boolean | undefined = false>({ cases, debug, transaction, noReturn }: T.RepositoryUpdateMultiple<M, NR>): Promise<NR extends true ? undefined : T.Result<M>[]>;
     /**
      * The 'delete' method is used to delete records from a database table based on the specified query conditions.
      *
@@ -715,9 +584,6 @@ declare class RepositoryFactory<TS extends Record<string, any> = Record<string,
  *
  * It provides methods for querying, inserting, updating, and deleting records in the database associated with the model.
  *
- *
- *
- * The 'bind' method is used to bind the model to the repository
  * @param {Model} model A class constructor for a model
  * @returns {RepositoryFactory<T,R>}
  *