hysteria-orm 10.6.0 → 10.6.2

package/lib/index.d.cts

@@ -2579,11 +2579,11 @@ declare class QueryBuilder<T extends Model = any, S extends Record<string, any>
             time: number;
         }>;
         insert: (data: Record<string, any>, returnType?: "millis" | "seconds") => Promise<{
-            data: T;
+            data: void;
             time: number;
         }>;
         insertMany: (data: Record<string, any>[], returnType?: "millis" | "seconds") => Promise<{
-            data: T[];
+            data: void;
             time: number;
         }>;
         update: (data: Record<string, any>, returnType?: "millis" | "seconds") => Promise<{
@@ -2682,6 +2682,9 @@ declare class QueryBuilder<T extends Model = any, S extends Record<string, any>
      * @description Executes the query and retrieves multiple results.
      */
     many(): Promise<S[]>;
+    then<TResult1 = S[], TResult2 = never>(onfulfilled?: ((value: S[]) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): Promise<S[] | TResult>;
+    finally(onfinally?: (() => void) | null | undefined): Promise<S[]>;
     /**
      * @description Executes the query and retrieves a single column from the results.
      * @param key - The column to retrieve from the results, must be a Model Column
@@ -2841,14 +2844,16 @@ declare class QueryBuilder<T extends Model = any, S extends Record<string, any>
      * @param returning - The columns to return from the query, only supported by postgres and cockroachdb - default is "*"
      * @returns WriteOperation that executes when awaited
      */
-    insert(data: Record<string, WriteQueryParam>, returning?: string[]): WriteOperation<T>;
+    insert(data: Record<string, WriteQueryParam>, returning: string[]): WriteOperation<T>;
+    insert(data: Record<string, WriteQueryParam>): WriteOperation<void>;
     /**
      * @description Insert multiple records into a table
      * @param returning - The columns to return from the query, only supported by postgres and cockroachdb - default is "*"
      * @returns WriteOperation that executes when awaited
      * @oracledb may do multiple inserts with auto-generated identity columns
      */
-    insertMany(data: Record<string, WriteQueryParam>[], returning?: string[]): WriteOperation<T[]>;
+    insertMany(data: Record<string, WriteQueryParam>[], returning: string[]): WriteOperation<T[]>;
+    insertMany(data: Record<string, WriteQueryParam>[]): WriteOperation<void>;
     /**
      * @description Updates or creates a new record using upsert functionality
      * @param data The data to insert or update
@@ -3289,6 +3294,12 @@ type UniqueType = {
     columns: string[];
     name: string;
 };
+/**
+ * @description A property decorator that constrains the decorated property to type V.
+ * TypeScript infers K from the property name and T from the class, then checks
+ * that the property at key K is assignable to V.
+ */
+type TypedPropertyDecorator<V> = <K extends string, T extends Record<K, V>>(target: T, propertyKey: K) => void;
 
 declare abstract class FooterQueryBuilder<T extends Model, S extends Record<string, any> = Record<string, any>> {
     protected sqlDataSource: SqlDataSource;
@@ -4390,7 +4401,7 @@ type PaginateWithCursorOptions<T extends Model, K extends ModelKey<T>> = {
 };
 type UpsertOptionsRawBuilder = {
     updateOnConflict?: boolean;
-    returning?: string[];
+    returning?: readonly string[];
 };
 type WriteQueryParam = string | number | boolean | Date | RawNode | object | null | undefined;
 /**
@@ -4539,17 +4550,20 @@ declare class ModelQueryBuilder<T extends Model, S extends Record<string, any> =
         };
     }): Promise<SelectedModel<T, S, R>>;
     many(options?: ManyOptions): Promise<SelectedModel<T, S, R>[]>;
+    then<TResult1 = SelectedModel<T, S, R>[], TResult2 = never>(onfulfilled?: ((value: SelectedModel<T, S, R>[]) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): Promise<SelectedModel<T, S, R>[] | TResult>;
+    finally(onfinally?: (() => void) | null | undefined): Promise<SelectedModel<T, S, R>[]>;
     chunk(chunkSize: number, options?: ManyOptions): AsyncGenerator<SelectedModel<T, S, R>[] | T[]>;
     stream(options?: ManyOptions & StreamOptions): Promise<PassThrough & AsyncGenerator<SelectedModel<T, S, R> | T>>;
     paginateWithCursor<K extends ModelKey<T>>(page: number, options?: PaginateWithCursorOptions<T, K>, cursor?: Cursor<T, K>): Promise<[CursorPaginatedData<T, S, R>, Cursor<T, K>]>;
     /**
      * @description Inserts a new record into the database, it is not advised to use this method directly from the query builder if using a ModelQueryBuilder (`Model.query()`), use the `Model.insert` method instead.
      */
-    insert(...args: Parameters<typeof this$1.model.insert<T>>): Promise<ReturnType<typeof this$1.model.insert>>;
+    insert(modelData: Partial<ModelWithoutRelations<T>>, returning: readonly (ModelKey<T> | "*")[] | undefined): WriteOperation<any>;
     /**
      * @description Inserts multiple records into the database, it is not advised to use this method directly from the query builder if using a ModelQueryBuilder (`Model.query()`), use the `Model.insertMany` method instead.
      */
-    insertMany(...args: Parameters<typeof this$1.model.insertMany<T>>): Promise<ReturnType<typeof this$1.model.insertMany>>;
+    insertMany(modelsData: Partial<ModelWithoutRelations<T>>[], returning: readonly (ModelKey<T> | "*")[] | undefined): WriteOperation<any>;
     update(data: Partial<ModelWithoutRelations<T>>, options?: UpdateOptions): WriteOperation<number>;
     softDelete(options?: SoftDeleteOptions<T>): WriteOperation<number>;
     delete(options?: DeleteOptions): WriteOperation<number>;
@@ -5367,6 +5381,11 @@ declare class SqlDataSource<D extends SqlDataSourceType = SqlDataSourceType, T e
      * @param table The table name to query from
      */
     query<S extends string>(table: TableFormat<S>, options?: RawModelOptions): QueryBuilder;
+    /**
+     * @description Returns a ModelQueryBuilder instance for the given model
+     * @param Model The model to create the query builder from
+     */
+    from<T extends typeof Model>(Model: T): ModelQueryBuilder<InstanceType<T>>;
     /**
      * @description Returns a SchemaBuilder instance for DDL operations
      * @description The builder will execute queries when awaited or when .execute() is called
@@ -5564,84 +5583,6 @@ type ExcludeMethods<T> = {
  * like save(), delete(), refresh() are not incorrectly included.
  */
 type ModelDataProperties = Pick<Model, ExcludeMethods<Model>>;
-/**
- * Model instance methods available on query results.
- * These methods enable CRUD operations on fetched models.
- *
- * All query results from Model static methods (find, findOne, findOneOrFail,
- * findBy, findOneBy, findOneByPrimaryKey, all, first, insert, insertMany,
- * upsert, upsertMany, updateRecord, softDelete) and from ModelQueryBuilder
- * (one, many, oneOrFail) include these instance methods.
- *
- * @example
- * ```typescript
- * // Using instance methods on query results
- * const user = await User.findOne({ where: { email: "test@example.com" } });
- * if (user) {
- *   user.mergeProps({ name: "Updated Name" });
- *   await user.save();
- *
- *   // Or update directly
- *   await user.update({ name: "Another Name" });
- *
- *   // Refresh from database
- *   await user.refresh();
- *
- *   // Soft delete or hard delete
- *   await user.softDelete();
- *   // or: await user.delete();
- * }
- *
- * // Works with query builder too
- * const user2 = await User.query().where("id", 1).oneOrFail();
- * await user2.update({ status: "inactive" });
- *
- * // Works with select projections
- * const user3 = await User.query().select("id", "name").one();
- * if (user3) {
- *   await user3.delete(); // Still has access to instance methods
- * }
- * ```
- *
- * Note: These signatures are simplified versions that don't carry the
- * `this: T extends Model` constraint, allowing them to work on selected
- * model results without requiring full Model type compatibility.
- */
-type ModelInstanceMethods<T extends Model> = {
-    /**
-     * Merges the provided data with the model instance.
-     * Does not persist to database - use save() or update() after merging.
-     */
-    mergeProps: (data: Partial<ModelWithoutRelations<T>>) => void;
-    /**
-     * Saves the model to the database (insert or update based on primary key).
-     * @throws {HysteriaError} If the model has no primary key defined
-     */
-    save: (options?: Omit<BaseModelMethodOptions, "ignoreHooks">) => Promise<any>;
-    /**
-     * Updates the model in the database with the provided payload.
-     * @throws {HysteriaError} If the model has no primary key or primary key value
-     */
-    update: (payload: Partial<ModelWithoutRelations<T>>, options?: Omit<BaseModelMethodOptions, "ignoreHooks">) => Promise<void>;
-    /**
-     * Soft deletes the model by setting the soft delete column.
-     * @throws {HysteriaError} If the model has no primary key or primary key value
-     */
-    softDelete: (softDeleteOptions?: {
-        column?: string;
-        value?: string | number | boolean | Date;
-    }, options?: Omit<BaseModelMethodOptions, "ignoreHooks">) => Promise<void>;
-    /**
-     * Hard deletes the model from the database.
-     * @throws {HysteriaError} If the model has no primary key or primary key value
-     */
-    delete: (options?: Omit<BaseModelMethodOptions, "ignoreHooks">) => Promise<void>;
-    /**
-     * Refreshes the model from the database, updating all properties with current values.
-     * @throws {HysteriaError} If the model has no primary key or primary key value
-     */
-    refresh: (options?: Omit<BaseModelMethodOptions, "ignoreHooks">) => Promise<void>;
-};
 /**
  * Model data without relation properties.
  * Includes only data columns from the model, excluding foreign keys and relation accessors.
@@ -5649,7 +5590,7 @@ type ModelInstanceMethods<T extends Model> = {
 type ModelWithoutRelations<T extends Model> = Pick<Omit<T, "*">, ExcludeRelations<Omit<T, "*">>> & ModelDataProperties;
 /**
  * Return type for Model query/mutation methods.
- * Combines data properties with instance methods for CRUD operations.
+ * Represents data-only properties without any business logic.
  *
  * This type is used as the return type for:
  * - Static find methods: find, findOne, findOneOrFail, findBy, findOneBy, findOneByPrimaryKey
@@ -5666,15 +5607,15 @@ type ModelWithoutRelations<T extends Model> = Pick<Omit<T, "*">, ExcludeRelation
  * const allUsers = await User.all();
  * const newUser = await User.insert({ name: "John" });
  *
- * // Each result has instance methods available
+ * // Results are plain data objects - use static methods for operations
  * if (user1) {
- *   await user1.update({ name: "Jane" });
- *   await user1.refresh();
- *   await user1.delete();
+ *   await User.updateRecord(user1, { name: "Jane" });
+ *   await User.refresh(user1);
+ *   await User.deleteRecord(user1);
  * }
  * ```
  */
-type ModelQueryResult<T extends Model> = ModelWithoutRelations<T> & ModelInstanceMethods<T>;
+type ModelQueryResult<T extends Model> = ModelWithoutRelations<T>;
 type NumberModelKey<T extends Model> = {
     [K in keyof T]: T[K] extends number | bigint ? K : never;
 }[keyof T];
@@ -5981,9 +5922,8 @@ type ComposeBuildSelect<S extends Record<string, any>, T extends Model, Columns
 /**
  * The final result type for ModelQueryBuilder queries.
  *
- * Combines selected columns (S) with loaded relations (R) and Model instance methods
- * into a single type. This ensures query results have access to CRUD operations
- * like save(), update(), delete(), etc.
+ * Combines selected columns (S) with loaded relations (R) into a single type.
+ * Query results are plain data objects without business logic.
  *
  * @typeParam M - The Model type
  * @typeParam S - Selected columns type from `select()` calls
@@ -5992,19 +5932,19 @@ type ComposeBuildSelect<S extends Record<string, any>, T extends Model, Columns
  * @example
  * // User.query().select("name").load("posts").one()
  * SelectedModel<User, { name: string }, { posts: Post[] }>
- * // Result: { name: string; posts: Post[] } & ModelInstanceMethods
+ * // Result: { name: string; posts: Post[] }
  */
-type SelectedModel<M extends Model, S extends Record<string, any> = {}, R extends Record<string, any> = {}> = S & R & ModelInstanceMethods<M>;
+type SelectedModel<M extends Model, S extends Record<string, any> = {}, R extends Record<string, any> = {}> = S & R;
 
 type NullableAndUndefinable<T> = T | (T | null) | (T | undefined) | (T | null | undefined);
 type UpsertOptions<T extends Model> = {
     ignoreHooks?: boolean;
     updateOnConflict?: boolean;
-    returning?: ModelKey<T>[];
+    returning?: ReturningKey<T>[];
 };
 type InsertOptions<T extends Model> = {
     ignoreHooks?: boolean;
-    returning?: ModelKey<T>[];
+    returning?: ReturningKey<T>[];
 };
 type ExcludeRelations<T> = {
     [K in keyof T]: T[K] extends NullableAndUndefinable<Model> | NullableAndUndefinable<Model[]> | ((...args: any[]) => any) ? never : K;
@@ -6063,6 +6003,15 @@ type WhereType<T> = BaseWhereType<T> & {
 type ModelKey<T extends Model> = {
     [K in keyof T]: T[K] extends NullableAndUndefinable<Model> | NullableAndUndefinable<Model[]> ? never : K extends "*" ? never : T[K] extends (...args: any[]) => any ? never : K;
 }[keyof T];
+/**
+ * Valid key for the `returning` option: any model column or `"*"` for all columns.
+ */
+type ReturningKey<T extends Model> = ModelKey<T> | "*";
+/**
+ * Generic constraint for the `returning` columns parameter.
+ * Used as a generic bound on insert/upsert/write methods.
+ */
+type ReturningColumns<T extends Model> = readonly ReturningKey<T>[] | undefined;
 /**
  * Extracts the value type for a model column key, adding `null` for SQL compatibility.
  * Used in type-safe where/having clauses to infer value types from column keys.
@@ -6087,7 +6036,7 @@ type FindOneType<T extends Model, S extends ModelKey<T>[] = any[], R extends Mod
 type FindType<T extends Model, S extends ModelKey<T>[] = any[], R extends ModelRelation<T>[] = never[]> = Omit<FindOneType<T, S, R>, "throwErrorOnNull"> & {
     limit?: number;
 };
-type FindReturnType<T extends Model, S extends ModelKey<T>[] = any[], R extends ModelRelation<T>[] = never[]> = (S extends readonly any[] ? S[number] extends never ? ModelWithoutRelations<T> & {
+type FindReturnType<T extends Model, S extends ModelKey<T>[] = any[], R extends ModelRelation<T>[] = never[]> = S extends readonly any[] ? S[number] extends never ? ModelWithoutRelations<T> & {
     [K in R[number] & keyof T]: T[K];
 } : {
     [K in S[number] & keyof T]: T[K];
@@ -6095,7 +6044,19 @@ type FindReturnType<T extends Model, S extends ModelKey<T>[] = any[], R extends
     [K in R[number] & keyof T]: T[K];
 } : ModelWithoutRelations<T> & {
     [K in R[number] & keyof T]: T[K];
-}) & ModelInstanceMethods<T>;
+};
+/**
+ * Return type for write operations (insert/upsert) based on the returning columns.
+ * - `undefined` or `[]` -> `void` (no data fetched)
+ * - `["*"]` -> `ModelQueryResult<T>` (full model)
+ * - `["col1", "col2"]` -> `{ col1: ...; col2: ... } & ModelDataProperties`
+ *
+ * @typeParam T - The Model type
+ * @typeParam R - The returning columns array (literal tuple for type inference)
+ */
+type WriteReturnType<T extends Model, R extends ReturningColumns<T>> = R extends undefined ? void : R extends readonly [] ? void : R extends readonly ReturningKey<T>[] ? "*" extends R[number] ? ModelQueryResult<T> : {
+    [K in R[number] & keyof T]: T[K];
+} & ModelDataProperties : never;
 
 /**
  * @description Represents a Table in the Database
@@ -6196,8 +6157,13 @@ declare abstract class Model<T extends Model<T> = any> extends Entity {
      * @mysql If no Primary Key is present in the model definition, the model will be returned
      * @sqlite If no Primary Key is present in the model definition, the model will be returned
      * @sqlite Returning Not supported and won't have effect
+     * @typeParam T - The Model type
+     * @typeParam R - The returning columns (literal tuple for type inference)
      */
-    static insert<T extends Model>(this: new () => T | typeof Model, modelData: Partial<ModelWithoutRelations<T>>, options?: BaseModelMethodOptions & InsertOptions<T>): WriteOperation<ModelQueryResult<T>>;
+    static insert<T extends Model, const R extends ReturningColumns<T> = undefined>(this: new () => T | typeof Model, modelData: Partial<ModelWithoutRelations<T>>, options?: BaseModelMethodOptions & {
+        ignoreHooks?: boolean;
+        returning?: R;
+    }): WriteOperation<WriteReturnType<T, R>>;
     /**
      * @description Saves multiple records to the database
      * @warning If not using postgres and the model has no primary key, the models will be saved, but it won't be possible to retrieve them so at that point they will be returned as an empty array
@@ -6205,8 +6171,13 @@ declare abstract class Model<T extends Model<T> = any> extends Entity {
      * @sqlite If no Primary Key is present in the model definition, the model will be returned
      * @sqlite Returning Not supported and won't have effect
      * @oracledb may do multiple inserts with auto-generated identity columns
+     * @typeParam T - The Model type
+     * @typeParam R - The returning columns (literal tuple for type inference)
      */
-    static insertMany<T extends Model>(this: new () => T | typeof Model, modelsData: Partial<ModelWithoutRelations<T>>[], options?: BaseModelMethodOptions & InsertOptions<T>): WriteOperation<ModelQueryResult<T>[]>;
+    static insertMany<T extends Model, const R extends ReturningColumns<T> = undefined>(this: new () => T | typeof Model, modelsData: Partial<ModelWithoutRelations<T>>[], options?: BaseModelMethodOptions & {
+        ignoreHooks?: boolean;
+        returning?: R;
+    }): WriteOperation<R extends readonly [] ? void : WriteReturnType<T, R>[]>;
     /**
      * @description Syncs in the through table the given models for the given relation
      * @param relation The many to many relation to sync, this is not type safe since many to many relations defined at a decorator level
@@ -6240,17 +6211,32 @@ declare abstract class Model<T extends Model<T> = any> extends Entity {
     } : T>;
     /**
      * @description Updates or creates a new record, if no searchCriteria payload is provided, provided data will be inserted as is
+     * @typeParam R - The returning columns (literal tuple for type inference). Defaults to void.
      */
-    static upsert<T extends Model>(this: new () => T | typeof Model, searchCriteria: Partial<ModelWithoutRelations<T>>, data: Partial<ModelWithoutRelations<T>>, options?: UpsertOptions<T> & BaseModelMethodOptions): Promise<ModelQueryResult<T>>;
+    static upsert<T extends Model, const R extends ReturningColumns<T> = undefined>(this: new () => T | typeof Model, searchCriteria: Partial<ModelWithoutRelations<T>>, data: Partial<ModelWithoutRelations<T>>, options?: Omit<UpsertOptions<T>, "returning"> & BaseModelMethodOptions & {
+        returning?: R;
+    }): Promise<WriteReturnType<T, R>>;
     /**
      * @description Updates or creates multiple records
      * @param {updateOnConflict} If true, the record will be updated if it exists, otherwise it will be ignored
+     * @typeParam R - The returning columns (literal tuple for type inference). Defaults to void.
      */
-    static upsertMany<T extends Model>(this: new () => T | typeof Model, conflictColumns: ModelKey<T>[], data: Partial<ModelWithoutRelations<T>>[], options?: UpsertOptions<T> & BaseModelMethodOptions): Promise<ModelQueryResult<T>[]>;
+    static upsertMany<T extends Model, const R extends ReturningColumns<T> = undefined>(this: new () => T | typeof Model, conflictColumns: ModelKey<T>[], data: Partial<ModelWithoutRelations<T>>[], options?: Omit<UpsertOptions<T>, "returning"> & BaseModelMethodOptions & {
+        returning?: R;
+    }): Promise<WriteReturnType<T, R>[]>;
     /**
      * @description Deletes a record to the database
      */
     static deleteRecord<T extends Model>(this: new () => T | typeof Model, modelSqlInstance: T, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<void>;
+    /**
+     * @description Saves (inserts or updates) a model instance to the database
+     * @description If the primary key is not set, performs an insert. If set, performs an update.
+     * @description After saving, the instance is updated with the result from the database
+     * @param modelSqlInstance The model instance to save
+     * @param options Optional transaction, connection, or ignoreHooks options
+     * @throws {HysteriaError} If the model has no primary key defined
+     */
+    static save<T extends Model>(this: new () => T | typeof Model, modelSqlInstance: Partial<T>, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<ModelQueryResult<T>>;
     /**
      * @description Soft Deletes a record to the database
      * @description default column: deletedAt
@@ -6448,38 +6434,6 @@ declare abstract class Model<T extends Model<T> = any> extends Entity {
      * @description Gives the correct model manager with the correct connection based on the options provided
      */
     private static dispatchModelManager;
-    /**
-     * @description Merges the provided data with the model instance
-     */
-    mergeProps<T extends Model = this>(this: T, data: Partial<ModelWithoutRelations<T>>): void;
-    /**
-     * @description inserts or updates the model to the database, must have a primary key in order to work
-     * @throws {HysteriaError} If the model has no primary key
-     */
-    save<T extends Model = this>(options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<T>;
-    /**
-     * @description Updates the model in the database, must have a primary key in order to work
-     * @throws {HysteriaError} If the model has no primary key valorized in the instance
-     */
-    update<T extends Model = this>(payload: Partial<ModelWithoutRelations<T>>, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<void>;
-    /**
-     * @description Soft deletes the model from the database, must have a primary key in order to work
-     * @throws {HysteriaError} If the model has no primary key valorized in the instance
-     */
-    softDelete<T extends Model = this>(this: T, softDeleteOptions?: {
-        column?: keyof ModelWithoutRelations<T>;
-        value?: string | number | boolean | Date;
-    }, options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<void>;
-    /**
-     * @description Deletes the model from the database, must have a primary key in order to work
-     * @throws {HysteriaError} If the model has no primary key valorized in the instance
-     */
-    delete<T extends Model = this>(options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<void>;
-    /**
-     * @description Refreshes the model from the database, it both updates the instance and returns the refreshed model
-     * @throws {HysteriaError} If the model has no primary key valorized in the instance
-     */
-    refresh<T extends Model = this>(options?: Omit<BaseModelMethodOptions, "ignoreHooks">): Promise<T>;
 }
 
 type BaseModelRelationType = {
@@ -6555,13 +6509,13 @@ declare namespace column {
     export { _a as enum };
 }
 declare function primaryKeyColumn(options?: Omit<ColumnOptions, "primaryKey">): PropertyDecorator;
-declare function floatColumn(options?: Omit<ColumnOptions, "serialize">): PropertyDecorator;
+declare function floatColumn(options?: Omit<ColumnOptions, "serialize">): TypedPropertyDecorator<number | null | undefined>;
 /**
  * @description Decorator to define a integer column in the model, this will automatically convert the integer to the correct format for the database
  * @description Useful in databases like postgres where the integer is returned as a string by the driver
  * @description Defaults type to integer for migration generation
  */
-declare function integerColumn(options?: Omit<ColumnOptions, "serialize">): PropertyDecorator;
+declare function integerColumn(options?: Omit<ColumnOptions, "serialize">): TypedPropertyDecorator<number | null | undefined>;
 /**
  * @description Decorator to define an auto-incrementing integer primary key column
  * @description Automatically sets primaryKey: true and nullable: false
@@ -6569,7 +6523,7 @@ declare function integerColumn(options?: Omit<ColumnOptions, "serialize">): Prop
  * @postgres SERIAL (INTEGER with auto-increment sequence)
  * @sqlite INTEGER PRIMARY KEY AUTOINCREMENT
  */
-declare function incrementColumn(options?: Omit<ColumnOptions, "serialize" | "primaryKey" | "nullable">): PropertyDecorator;
+declare function incrementColumn(options?: Omit<ColumnOptions, "serialize" | "primaryKey" | "nullable">): TypedPropertyDecorator<number | null | undefined>;
 /**
  * @description Decorator to define an auto-incrementing bigint primary key column
  * @description Automatically sets primaryKey: true and nullable: false
@@ -6577,37 +6531,37 @@ declare function incrementColumn(options?: Omit<ColumnOptions, "serialize" | "pr
  * @postgres BIGSERIAL (BIGINT with auto-increment sequence)
  * @sqlite INTEGER PRIMARY KEY AUTOINCREMENT
  */
-declare function bigIncrementColumn(options?: Omit<ColumnOptions, "serialize" | "primaryKey" | "nullable">): PropertyDecorator;
+declare function bigIncrementColumn(options?: Omit<ColumnOptions, "serialize" | "primaryKey" | "nullable">): TypedPropertyDecorator<number | null | undefined>;
 /**
  * @description Decorator to define a uuid column in the model
  * @description This will automatically generate a uuid if no value is provided
  * @description Defaults type to uuid for migration generation
  */
-declare function uuidColumn(options?: Omit<ColumnOptions, "prepare">): PropertyDecorator;
+declare function uuidColumn(options?: Omit<ColumnOptions, "prepare">): TypedPropertyDecorator<string | null | undefined>;
 /**
  * @description Decorator to define a ulid column in the model
  * @description This will automatically generate a ulid if no value is provided
  * @description Defaults type to ulid for migration generation
  */
-declare function ulidColumn(options?: Omit<ColumnOptions, "prepare">): PropertyDecorator;
+declare function ulidColumn(options?: Omit<ColumnOptions, "prepare">): TypedPropertyDecorator<string | null | undefined>;
 /**
  * @description Decorator to define a string (varchar) column in the model
  * @description Defaults type to string for migration generation
  */
 declare function stringColumn(options?: Omit<ColumnOptions, "type"> & {
     length?: number;
-}): PropertyDecorator;
+}): TypedPropertyDecorator<string | null | undefined>;
 /**
  * @description Decorator to define a text column in the model for longer text content
  * @description Defaults type to longtext for migration generation
  */
-declare function textColumn(options?: Omit<ColumnOptions, "type">): PropertyDecorator;
+declare function textColumn(options?: Omit<ColumnOptions, "type">): TypedPropertyDecorator<string | null | undefined>;
 /**
  * @description Decorator to define a bigint column in the model
  * @description Useful in databases like postgres where the bigint is returned as a string by the driver
  * @description Defaults type to bigint for migration generation
  */
-declare function bigintColumn(options?: Omit<ColumnOptions, "serialize">): PropertyDecorator;
+declare function bigintColumn(options?: Omit<ColumnOptions, "serialize">): TypedPropertyDecorator<number | bigint | null | undefined>;
 /**
  * @description Decorator to define a decimal column in the model for precise numeric values
  * @description Useful for financial data and other precise calculations
@@ -6618,37 +6572,37 @@ declare function bigintColumn(options?: Omit<ColumnOptions, "serialize">): Prope
 declare function decimalColumn(options?: Omit<ColumnOptions, "serialize"> & {
     precision?: number;
     scale?: number;
-}): PropertyDecorator;
+}): TypedPropertyDecorator<number | null | undefined>;
 /**
  * @description Decorator to define a binary/blob column in the model
  * @description Defaults type to binary for migration generation
  */
-declare function binaryColumn(options?: Omit<ColumnOptions, "type">): PropertyDecorator;
+declare function binaryColumn(options?: Omit<ColumnOptions, "type">): TypedPropertyDecorator<Buffer | Uint8Array | string | null | undefined>;
 /**
  * @description Decorator to define an enum column in the model
  * @description Defaults type to enum for migration generation
  * @param values The allowed enum values
  * @param options Additional column options
  */
-declare function enumColumn(values: readonly string[], options?: Omit<ColumnOptions, "type">): PropertyDecorator;
+declare function enumColumn<const V extends readonly string[]>(values: V, options?: Omit<ColumnOptions, "type">): TypedPropertyDecorator<V[number] | null | undefined>;
 /**
  * @description Decorator to define a symmetric encrypted column in the model with a key
  * @description This will automatically encrypt the value before it is inserted or updated in the database and decrypt it when it is retrieved from the database
  * @description If no value is provided, the value will be returned as is
  */
-declare function symmetric(options: Omit<SymmetricEncryptionOptions, "prepare" | "serialize">): PropertyDecorator;
+declare function symmetric(options: Omit<SymmetricEncryptionOptions, "prepare" | "serialize">): TypedPropertyDecorator<string | null | undefined>;
 /**
  * @description Decorator to define a asymmetric encrypted column in the model with public and private keys
  * @description This will automatically encrypt the value before it is inserted or updated in the database and decrypt it when it is retrieved from the database
  * @description If no value is provided, the value will be returned as is
  */
-declare function asymmetric(options: Omit<AsymmetricEncryptionOptions, "prepare" | "serialize">): PropertyDecorator;
+declare function asymmetric(options: Omit<AsymmetricEncryptionOptions, "prepare" | "serialize">): TypedPropertyDecorator<string | null | undefined>;
 /**
  * @description Decorator to define a boolean column in the model
  * @description This will automatically convert the boolean to the correct format for the database, useful for mysql since it stores booleans as tinyint(1)
  * @description Defaults type to boolean for migration generation
  */
-declare function booleanColumn(options?: Omit<ColumnOptions, "prepare" | "serialize">): PropertyDecorator;
+declare function booleanColumn(options?: Omit<ColumnOptions, "prepare" | "serialize">): TypedPropertyDecorator<boolean | null | undefined>;
 /**
  * @description Decorator to define a DATE_ONLY column in the model (YYYY-MM-DD)
  * @description This will automatically convert the date to DATE_ONLY format
@@ -6661,7 +6615,7 @@ declare function booleanColumn(options?: Omit<ColumnOptions, "prepare" | "serial
  * @param options.prepare Optional custom prepare function that receives the pre-handled value
  * @param options.serialize Optional custom serialize function that receives the pre-handled value
  */
-declare function dateOnlyColumn(options?: Omit<DateColumnOptions, "format">): PropertyDecorator;
+declare function dateOnlyColumn(options?: Omit<DateColumnOptions, "format">): TypedPropertyDecorator<Date | string | null | undefined>;
 /**
  * @description Decorator to define a DATETIME column in the model (YYYY-MM-DD HH:mm:ss)
  * @description This will automatically convert the date to ISO format
@@ -6674,7 +6628,7 @@ declare function dateOnlyColumn(options?: Omit<DateColumnOptions, "format">): Pr
  * @param options.prepare Optional custom prepare function that receives the pre-handled value
  * @param options.serialize Optional custom serialize function that receives the pre-handled value
  */
-declare function datetimeColumn(options?: Omit<DateColumnOptions, "format">): PropertyDecorator;
+declare function datetimeColumn(options?: Omit<DateColumnOptions, "format">): TypedPropertyDecorator<Date | string | null | undefined>;
 /**
  * @description Decorator to define a TIMESTAMP column in the model (Unix timestamp)
  * @description This will automatically convert the date to Unix timestamp format
@@ -6687,7 +6641,7 @@ declare function datetimeColumn(options?: Omit<DateColumnOptions, "format">): Pr
  * @param options.prepare Optional custom prepare function that receives the pre-handled value
  * @param options.serialize Optional custom serialize function that receives the pre-handled value
  */
-declare function timestampColumn(options?: Omit<DateColumnOptions, "format">): PropertyDecorator;
+declare function timestampColumn(options?: Omit<DateColumnOptions, "format">): TypedPropertyDecorator<Date | string | null | undefined>;
 /**
  * @description Decorator to define a TIME_ONLY column in the model (HH:mm:ss)
  * @description This will automatically convert the date to TIME_ONLY format
@@ -6700,14 +6654,14 @@ declare function timestampColumn(options?: Omit<DateColumnOptions, "format">): P
  * @param options.prepare Optional custom prepare function that receives the pre-handled value
  * @param options.serialize Optional custom serialize function that receives the pre-handled value
  */
-declare function timeOnlyColumn(options?: Omit<DateColumnOptions, "format">): PropertyDecorator;
+declare function timeOnlyColumn(options?: Omit<DateColumnOptions, "format">): TypedPropertyDecorator<Date | string | null | undefined>;
 /**
  * @description Decorator to define a json column in the model
  * @description This will automatically convert the json to the correct format for the database
  * @throws json parse error if the value from the database is not valid json
  * @description Defaults type to jsonb for migration generation
  */
-declare function jsonColumn(options?: Omit<ColumnOptions, "prepare" | "serialize">): PropertyDecorator;
+declare function jsonColumn(options?: Omit<ColumnOptions, "prepare" | "serialize">): TypedPropertyDecorator<unknown>;
 declare function getModelColumns(target: typeof Model): ColumnType[];
 /**
  * relations
@@ -6720,22 +6674,22 @@ declare function getModelColumns(target: typeof Model): ColumnType[];
  * belongsTo<typeof Post>(() => User, 'userId')
  * ```
  */
-declare function belongsTo<M extends typeof Model = any, R extends typeof Model = any>(model: () => R, foreignKey?: ModelKey<InstanceType<M>>, options?: BaseModelRelationType): PropertyDecorator;
-declare function belongsTo<R extends typeof Model = any>(model: () => R, foreignKey?: string, options?: BaseModelRelationType): PropertyDecorator;
+declare function belongsTo<M extends typeof Model = any, R extends typeof Model = any>(model: () => R, foreignKey?: ModelKey<InstanceType<M>>, options?: BaseModelRelationType): TypedPropertyDecorator<InstanceType<R> | null | undefined>;
+declare function belongsTo<R extends typeof Model = any>(model: () => R, foreignKey?: string, options?: BaseModelRelationType): TypedPropertyDecorator<InstanceType<R> | null | undefined>;
 /**
  * @description Establishes a has one relation with the given model
  * @default foreignKey by default will be the singular of the model name plus "_id"
  * @example User will have foreignKey "user_id" on the Post model
  */
-declare function hasOne<T extends typeof Model>(model: () => T, foreignKey?: ModelKey<InstanceType<T>>): PropertyDecorator;
-declare function hasOne<T extends typeof Model>(model: () => T, foreignKey?: string): PropertyDecorator;
+declare function hasOne<T extends typeof Model>(model: () => T, foreignKey?: ModelKey<InstanceType<T>>): TypedPropertyDecorator<InstanceType<T> | null | undefined>;
+declare function hasOne<T extends typeof Model>(model: () => T, foreignKey?: string): TypedPropertyDecorator<InstanceType<T> | null | undefined>;
 /**
  * @description Establishes a has many relation with the given model
  * @default foreignKey by default will be the singular of the model name plus "_id"
  * @example User will have foreignKey "user_id" on the Post model
  */
-declare function hasMany<T extends typeof Model>(model: () => T, foreignKey?: ModelKey<InstanceType<T>>): PropertyDecorator;
-declare function hasMany<T extends typeof Model>(model: () => T, foreignKey?: string): PropertyDecorator;
+declare function hasMany<T extends typeof Model>(model: () => T, foreignKey?: ModelKey<InstanceType<T>>): TypedPropertyDecorator<InstanceType<T>[] | null | undefined>;
+declare function hasMany<T extends typeof Model>(model: () => T, foreignKey?: string): TypedPropertyDecorator<InstanceType<T>[] | null | undefined>;
 /**
  * @description Establishes a many to many relation with the given model
  * @default foreignKey by default will be the singular of the model that establishes the relation name plus "_id"
@@ -6746,8 +6700,8 @@ declare function hasMany<T extends typeof Model>(model: () => T, foreignKey?: st
  * @param throughModelKeys.rightForeignKey The foreign key of the through model from the related model (the model you are joining to)
  * @example User will have foreignKey "user_id" on the Join table by default
  */
-declare function manyToMany<R extends typeof Model, T extends typeof Model, TM extends ThroughModel<T>>(model: () => R, throughModel: TM, throughModelKeys?: ManyToManyOptions<T, TM>, options?: BaseModelRelationType): PropertyDecorator;
-declare function manyToMany<R extends typeof Model>(model: () => R, throughModel: string | (() => typeof Model), throughModelKeys?: ManyToManyStringOptions, options?: BaseModelRelationType): PropertyDecorator;
+declare function manyToMany<R extends typeof Model, T extends typeof Model, TM extends ThroughModel<T>>(model: () => R, throughModel: TM, throughModelKeys?: ManyToManyOptions<T, TM>, options?: BaseModelRelationType): TypedPropertyDecorator<InstanceType<R>[] | null | undefined>;
+declare function manyToMany<R extends typeof Model>(model: () => R, throughModel: string | (() => typeof Model), throughModelKeys?: ManyToManyStringOptions, options?: BaseModelRelationType): TypedPropertyDecorator<InstanceType<R>[] | null | undefined>;
 declare function getRelationsMetadata(target: typeof Model): LazyRelationType[];
 /**
  * @description Returns the relations of the model
@@ -7924,4 +7878,4 @@ declare const generateOpenApiModelWithMetadata: <T extends new () => Model>(mode
     $id?: string;
 }>;
 
-export { type AbstractConstructor, type AdminJsActionOptions, type AdminJsAssets, type AdminJsBranding, type AdminJsInstance, type AdminJsLocale, type AdminJsOptions, type AdminJsPage, type AdminJsPropertyOptions, type AdminJsResourceOptions, type AdminJsSettings, type AnyConstructor, type AsymmetricEncryptionOptions, type BaseModelMethodOptions, type BaseModelRelationType, BaseSeeder, type BigIntFields, BigIntMixin, type BuildSelectType, type BuildSingleSelectType, type CacheAdapter, type CacheKeys, ClientMigrator, Collection, type ColumnDataTypeOption, type ColumnDataTypeOptionSimple, type ColumnDataTypeOptionWithBinary, type ColumnDataTypeOptionWithDatePrecision, type ColumnDataTypeOptionWithEnum, type ColumnDataTypeOptionWithLength, type ColumnDataTypeOptionWithPrecision, type ColumnDataTypeOptionWithScaleAndPrecision, type ColumnDataTypeOptionWithText, type ColumnOptions, type ColumnType, type CommonDataSourceInput, type ComposeBuildSelect, type ComposeSelect, type ConnectionPolicies, type Constructor, type DataSourceInput, type DataSourceType, type DateColumnOptions, type ExcludeMethods, type ExtractColumnName, type ExtractSourceColumn, type FetchHooks, type GetColumnType, type GetConnectionReturnType, HysteriaError, InMemoryAdapter, type IncrementFields, IncrementMixin, type IndexType, type LazyRelationType, type ManyOptions, type ManyToManyOptions, type ManyToManyStringOptions, Migration, type MigrationConfig, type MigrationConfigBase, type MixinColumns, MixinFactory, Model, type ModelDataProperties, type ModelInstanceMethods, type ModelInstanceType, ModelQueryBuilder, type ModelQueryResult, type ModelSelectTuple, type ModelSelectableInput, type ModelWithoutRelations, MongoDataSource, type MongoDataSourceInput$1 as MongoDataSourceInput, type MssqlConnectionInstance, type MssqlDataSourceInput, type MssqlPoolInstance, type MysqlConnectionInstance, type MysqlSqlDataSourceInput, type NotNullableMysqlSqlDataSourceInput, type NotNullableOracleDBDataSourceInput, type NotNullableOracleMssqlDataSourceInput, type NotNullablePostgresSqlDataSourceInput, type NotNullableSqliteDataSourceInput, type NumberModelKey, type OneOptions, type OracleDBDataSourceInput, type OracleDBPoolInstance, type PgPoolClientInstance, type PostgresSqlDataSourceInput, QueryBuilder, type RawModelOptions, RawNode, type RawQueryOptions, RedisCacheAdapter, type RedisFetchable, type RedisStorable, type RelatedInstance, type RelationQueryBuilderType, type ReplicationType, Schema, SchemaBuilder, type SeederConfig, type SelectBrand, type SelectableColumn, type SelectedModel, type SlaveAlgorithm, type SlaveContext, type SqlCloneOptions, SqlDataSource, type SqlDataSourceInput, type SqlDataSourceModel, type SqlDataSourceType, type SqlDriverSpecificOptions, type SqlPoolType, type Sqlite3ConnectionOptions, type SqliteConnectionInstance, type SqliteDataSourceInput, type StartTransactionOptions, type SymmetricEncryptionOptions, type TableFormat, type ThroughModel, type TimestampFields, TimestampMixin, Transaction, type TransactionExecutionOptions, type UlidFields, UlidMixin, type UniqueType, type UseCacheReturnType, type UseConnectionInput, type UuidFields, UuidMixin, WriteOperation, belongsTo, bigIntMixin, column, createMixin, createModelFactory, defineMigrator, generateOpenApiModel, generateOpenApiModelSchema, generateOpenApiModelWithMetadata, getCollectionProperties, getIndexes, getModelColumns, type getPoolReturnType, getPrimaryKey, getRelations, getRelationsMetadata, getUniques, hasMany, hasOne, incrementMixin, index, HysteriaLogger as logger, manyToMany, property, RedisDataSource as redis, timestampMixin, ulidMixin, unique, uuidMixin, view, withPerformance };
+export { type AbstractConstructor, type AdminJsActionOptions, type AdminJsAssets, type AdminJsBranding, type AdminJsInstance, type AdminJsLocale, type AdminJsOptions, type AdminJsPage, type AdminJsPropertyOptions, type AdminJsResourceOptions, type AdminJsSettings, type AnyConstructor, type AsymmetricEncryptionOptions, type BaseModelMethodOptions, type BaseModelRelationType, BaseSeeder, type BigIntFields, BigIntMixin, type BuildSelectType, type BuildSingleSelectType, type CacheAdapter, type CacheKeys, ClientMigrator, Collection, type ColumnDataTypeOption, type ColumnDataTypeOptionSimple, type ColumnDataTypeOptionWithBinary, type ColumnDataTypeOptionWithDatePrecision, type ColumnDataTypeOptionWithEnum, type ColumnDataTypeOptionWithLength, type ColumnDataTypeOptionWithPrecision, type ColumnDataTypeOptionWithScaleAndPrecision, type ColumnDataTypeOptionWithText, type ColumnOptions, type ColumnType, type CommonDataSourceInput, type ComposeBuildSelect, type ComposeSelect, type ConnectionPolicies, type Constructor, type DataSourceInput, type DataSourceType, type DateColumnOptions, type ExcludeMethods, type ExtractColumnName, type ExtractSourceColumn, type FetchHooks, type FindReturnType, type GetColumnType, type GetConnectionReturnType, HysteriaError, InMemoryAdapter, type IncrementFields, IncrementMixin, type IndexType, type LazyRelationType, type ManyOptions, type ManyToManyOptions, type ManyToManyStringOptions, Migration, type MigrationConfig, type MigrationConfigBase, type MixinColumns, MixinFactory, Model, type ModelDataProperties, type ModelInstanceType, type ModelKey, ModelQueryBuilder, type ModelQueryResult, type ModelRelation, type ModelSelectTuple, type ModelSelectableInput, type ModelWithoutRelations, MongoDataSource, type MongoDataSourceInput$1 as MongoDataSourceInput, type MssqlConnectionInstance, type MssqlDataSourceInput, type MssqlPoolInstance, type MysqlConnectionInstance, type MysqlSqlDataSourceInput, type NotNullableMysqlSqlDataSourceInput, type NotNullableOracleDBDataSourceInput, type NotNullableOracleMssqlDataSourceInput, type NotNullablePostgresSqlDataSourceInput, type NotNullableSqliteDataSourceInput, type NumberModelKey, type OneOptions, type OracleDBDataSourceInput, type OracleDBPoolInstance, type PgPoolClientInstance, type PostgresSqlDataSourceInput, QueryBuilder, type RawModelOptions, RawNode, type RawQueryOptions, RedisCacheAdapter, type RedisFetchable, type RedisStorable, type RelatedInstance, type RelationQueryBuilderType, type ReplicationType, type ReturningColumns, type ReturningKey, Schema, SchemaBuilder, type SeederConfig, type SelectBrand, type SelectableColumn, type SelectedModel, type SlaveAlgorithm, type SlaveContext, type SqlCloneOptions, SqlDataSource, type SqlDataSourceInput, type SqlDataSourceModel, type SqlDataSourceType, type SqlDriverSpecificOptions, type SqlPoolType, type Sqlite3ConnectionOptions, type SqliteConnectionInstance, type SqliteDataSourceInput, type StartTransactionOptions, type SymmetricEncryptionOptions, type TableFormat, type ThroughModel, type TimestampFields, TimestampMixin, Transaction, type TransactionExecutionOptions, type TypedPropertyDecorator, type UlidFields, UlidMixin, type UniqueType, type UseCacheReturnType, type UseConnectionInput, type UuidFields, UuidMixin, WriteOperation, type WriteReturnType, belongsTo, bigIntMixin, column, createMixin, createModelFactory, defineMigrator, generateOpenApiModel, generateOpenApiModelSchema, generateOpenApiModelWithMetadata, getCollectionProperties, getIndexes, getModelColumns, type getPoolReturnType, getPrimaryKey, getRelations, getRelationsMetadata, getUniques, hasMany, hasOne, incrementMixin, index, HysteriaLogger as logger, manyToMany, property, RedisDataSource as redis, timestampMixin, ulidMixin, unique, uuidMixin, view, withPerformance };