@bunnykit/orm 0.1.8 → 0.1.10

package/README.md

@@ -1219,7 +1219,12 @@ export interface UsersAttributes {
 }
 
 declare module "../User" {
-  interface User extends UsersAttributes {}
+  interface User {
+    id: number;
+    name: string;
+    email: string | null;
+    created_at: string;
+  }
 }
 ```
 

package/dist/src/model/BelongsToMany.d.ts

@@ -1,15 +1,15 @@
 import { Builder } from "../query/Builder.js";
-import type { Model } from "./Model.js";
+import type { Model, ModelConstructor } from "./Model.js";
 export declare class BelongsToMany<T extends Model = Model> {
     protected parent: Model;
-    protected related: typeof Model;
+    protected related: ModelConstructor;
     protected table: string;
     protected foreignPivotKey: string;
     protected relatedPivotKey: string;
     protected parentKey: string;
     protected relatedKey: string;
     protected builder: Builder<T>;
-    constructor(parent: Model, related: typeof Model, table?: string, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string);
+    constructor(parent: Model, related: ModelConstructor, table?: string, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string);
     protected addConstraints(): void;
     getQuery(): Builder<T>;
     addEagerConstraints(models: Model[]): void;

package/dist/src/model/Model.d.ts

@@ -2,8 +2,8 @@ import { Connection } from "../connection/Connection.js";
 import { Builder } from "../query/Builder.js";
 import { MorphTo, MorphOne, MorphMany, MorphToMany } from "./MorphRelations.js";
 import { BelongsToMany } from "./BelongsToMany.js";
-export type ModelConstructor<T extends Model = Model> = typeof Model & (new (...args: any[]) => T);
-export type GlobalScope = (builder: Builder<any>, model: typeof Model) => void;
+export type ModelConstructor<T extends Model = Model> = (new (...args: any[]) => T) & Omit<typeof Model, "prototype">;
+export type GlobalScope = (builder: Builder<any>, model: ModelConstructor) => void;
 export type CastDefinition = string | CastsAttributes | (new (...args: any[]) => CastsAttributes);
 export interface CastsAttributes {
     get(model: Model, key: string, value: any, attributes: Record<string, any>): any;
@@ -12,10 +12,10 @@ export interface CastsAttributes {
 export declare abstract class Relation<T extends Model = Model> {
     protected builder: Builder<T>;
     protected parent: Model;
-    protected related: typeof Model;
+    protected related: ModelConstructor;
     protected foreignKey: string;
     protected localKey: string;
-    constructor(parent: Model, related: typeof Model, foreignKey?: string, localKey?: string);
+    constructor(parent: Model, related: ModelConstructor, foreignKey?: string, localKey?: string);
     abstract addConstraints(): void;
     abstract getResults(): Promise<T | T[] | null>;
     abstract addEagerConstraints(models: Model[]): void;
@@ -30,7 +30,7 @@ export declare abstract class Relation<T extends Model = Model> {
     getRelationAggregateSql(parentQuery: Builder<any>, aggregate: string, callback?: (query: Builder<any>) => void | Builder<any>): string;
 }
 export declare class HasMany<T extends Model = Model> extends Relation<T> {
-    constructor(parent: Model, related: typeof Model, foreignKey?: string, localKey?: string);
+    constructor(parent: Model, related: ModelConstructor, foreignKey?: string, localKey?: string);
     addConstraints(): void;
     addEagerConstraints(models: Model[]): void;
     getEager(): Promise<any[]>;
@@ -41,7 +41,7 @@ export declare class HasMany<T extends Model = Model> extends Relation<T> {
     ofMany(column: string, aggregate?: "max" | "min"): HasOne<T>;
 }
 export declare class BelongsTo<T extends Model = Model> extends Relation<T> {
-    constructor(parent: Model, related: typeof Model, foreignKey?: string, ownerKey?: string);
+    constructor(parent: Model, related: ModelConstructor, foreignKey?: string, ownerKey?: string);
     addConstraints(): void;
     addEagerConstraints(models: Model[]): void;
     getEager(): Promise<any[]>;
@@ -52,11 +52,11 @@ export declare class BelongsTo<T extends Model = Model> extends Relation<T> {
     protected newExistenceQuery(parentQuery: Builder<any>, aggregate: string, callback?: (query: Builder<any>) => void | Builder<any>): Builder<any>;
 }
 export declare class HasManyThrough<T extends Model = Model> extends Relation<T> {
-    protected through: typeof Model;
+    protected through: ModelConstructor;
     protected firstKey: string;
     protected secondKey: string;
     protected secondLocalKey: string;
-    constructor(parent: Model, related: typeof Model, through: typeof Model, firstKey?: string, secondKey?: string, localKey?: string, secondLocalKey?: string);
+    constructor(parent: Model, related: ModelConstructor, through: ModelConstructor, firstKey?: string, secondKey?: string, localKey?: string, secondLocalKey?: string);
     addConstraints(): void;
     addEagerConstraints(models: Model[]): void;
     getEager(): Promise<any[]>;
@@ -69,7 +69,7 @@ export declare class HasOneThrough<T extends Model = Model> extends HasManyThrou
     match(models: Model[], results: any[], relationName: string): void;
 }
 export declare class HasOne<T extends Model = Model> extends Relation<T> {
-    constructor(parent: Model, related: typeof Model, foreignKey?: string, localKey?: string);
+    constructor(parent: Model, related: ModelConstructor, foreignKey?: string, localKey?: string);
     addConstraints(): void;
     addEagerConstraints(models: Model[]): void;
     getEager(): Promise<any[]>;
@@ -102,69 +102,69 @@ export declare class Model<T extends Record<string, any> = Record<string, any>>
     static getTable(): string;
     static getConnection(): Connection;
     static setConnection(connection: Connection): void;
-    static on<M extends typeof Model>(this: M, connection: string | Connection): Builder<InstanceType<M>>;
-    static forTenant<M extends typeof Model>(this: M, tenantId: string): Builder<InstanceType<M>>;
-    static query<M extends typeof Model>(this: M): Builder<InstanceType<M>>;
+    static on<M extends ModelConstructor>(this: M, connection: string | Connection): Builder<InstanceType<M>>;
+    static forTenant<M extends ModelConstructor>(this: M, tenantId: string): Builder<InstanceType<M>>;
+    static query<M extends ModelConstructor>(this: M): Builder<InstanceType<M>>;
     static addGlobalScope(name: string, scope: GlobalScope): void;
     static removeGlobalScope(name: string): void;
     static applyGlobalScopes(builder: Builder<any>): void;
     static getQualifiedDeletedAtColumn(): string;
     static shouldAutoGeneratePrimaryKey(): Promise<boolean>;
-    static create<M extends typeof Model>(this: M, attributes: Partial<InstanceType<M> extends Model<infer U> ? U : Record<string, any>>): Promise<InstanceType<M>>;
-    static find<M extends typeof Model>(this: M, id: any): Promise<InstanceType<M> | null>;
-    static findOrFail<M extends typeof Model>(this: M, id: any): Promise<InstanceType<M>>;
-    static first<M extends typeof Model>(this: M): Promise<InstanceType<M> | null>;
-    static firstOrFail<M extends typeof Model>(this: M): Promise<InstanceType<M>>;
-    static firstOrCreate<M extends typeof Model>(this: M, attributes?: Record<string, any>, values?: Record<string, any>): Promise<InstanceType<M>>;
-    static updateOrCreate<M extends typeof Model>(this: M, attributes: Record<string, any>, values?: Record<string, any>): Promise<InstanceType<M>>;
-    static where<M extends typeof Model>(this: M, column: string | Record<string, any>, operator?: string | any, value?: any): Builder<InstanceType<M>>;
-    static orderBy<M extends typeof Model>(this: M, column: string, direction?: "asc" | "desc"): Builder<InstanceType<M>>;
-    static whereIn<M extends typeof Model>(this: M, column: string, values: any[]): Builder<InstanceType<M>>;
-    static whereNull<M extends typeof Model>(this: M, column: string): Builder<InstanceType<M>>;
-    static whereNotNull<M extends typeof Model>(this: M, column: string): Builder<InstanceType<M>>;
-    static orWhere<M extends typeof Model>(this: M, column: string | Record<string, any>, operator?: string | any, value?: any): Builder<InstanceType<M>>;
-    static whereNot<M extends typeof Model>(this: M, column: string | Record<string, any>, value?: any): Builder<InstanceType<M>>;
-    static orWhereNot<M extends typeof Model>(this: M, column: string | Record<string, any>, value?: any): Builder<InstanceType<M>>;
-    static whereDate<M extends typeof Model>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
-    static orWhereDate<M extends typeof Model>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
-    static whereDay<M extends typeof Model>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
-    static orWhereDay<M extends typeof Model>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
-    static whereMonth<M extends typeof Model>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
-    static orWhereMonth<M extends typeof Model>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
-    static whereYear<M extends typeof Model>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
-    static orWhereYear<M extends typeof Model>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
-    static whereTime<M extends typeof Model>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
-    static orWhereTime<M extends typeof Model>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
-    static latest<M extends typeof Model>(this: M, column?: string): Builder<InstanceType<M>>;
-    static oldest<M extends typeof Model>(this: M, column?: string): Builder<InstanceType<M>>;
-    static when<M extends typeof Model>(this: M, condition: any, callback: (query: Builder<any>) => void | Builder<any>, defaultCallback?: (query: Builder<any>) => void | Builder<any>): Builder<InstanceType<M>>;
-    static unless<M extends typeof Model>(this: M, condition: any, callback: (query: Builder<any>) => void | Builder<any>, defaultCallback?: (query: Builder<any>) => void | Builder<any>): Builder<InstanceType<M>>;
-    static tap<M extends typeof Model>(this: M, callback: (query: Builder<any>) => void | Builder<any>): Builder<InstanceType<M>>;
-    static take<M extends typeof Model>(this: M, count: number): Builder<InstanceType<M>>;
-    static skip<M extends typeof Model>(this: M, count: number): Builder<InstanceType<M>>;
-    static inRandomOrder<M extends typeof Model>(this: M): Builder<InstanceType<M>>;
-    static lockForUpdate<M extends typeof Model>(this: M): Builder<InstanceType<M>>;
-    static sharedLock<M extends typeof Model>(this: M): Builder<InstanceType<M>>;
-    static with<M extends typeof Model>(this: M, ...relations: string[]): Builder<InstanceType<M>>;
-    static withTrashed<M extends typeof Model>(this: M): Builder<InstanceType<M>>;
-    static onlyTrashed<M extends typeof Model>(this: M): Builder<InstanceType<M>>;
-    static withoutGlobalScope<M extends typeof Model>(this: M, scope: string): Builder<InstanceType<M>>;
-    static withoutGlobalScopes<M extends typeof Model>(this: M): Builder<InstanceType<M>>;
-    static scope<M extends typeof Model>(this: M, name: string, ...args: any[]): Builder<InstanceType<M>>;
-    static has<M extends typeof Model>(this: M, relationName: string, operator?: string, count?: number): Builder<InstanceType<M>>;
-    static whereHas<M extends typeof Model>(this: M, relationName: string, callback?: (query: Builder<any>) => void | Builder<any>, operator?: string, count?: number): Builder<InstanceType<M>>;
-    static doesntHave<M extends typeof Model>(this: M, relationName: string): Builder<InstanceType<M>>;
-    static withCount<M extends typeof Model>(this: M, relationName: string, alias?: string): Builder<InstanceType<M>>;
-    static withSum<M extends typeof Model>(this: M, relationName: string, column: string, alias?: string): Builder<InstanceType<M>>;
-    static withAvg<M extends typeof Model>(this: M, relationName: string, column: string, alias?: string): Builder<InstanceType<M>>;
-    static withMin<M extends typeof Model>(this: M, relationName: string, column: string, alias?: string): Builder<InstanceType<M>>;
-    static withMax<M extends typeof Model>(this: M, relationName: string, column: string, alias?: string): Builder<InstanceType<M>>;
-    static all<M extends typeof Model>(this: M): Promise<InstanceType<M>[]>;
-    static paginate<M extends typeof Model>(this: M, perPage?: number, page?: number): Promise<import("../query/Builder.js").Paginator<InstanceType<M>>>;
-    static chunk<M extends typeof Model>(this: M, count: number, callback: (items: InstanceType<M>[]) => void | Promise<void>): Promise<void>;
-    static each<M extends typeof Model>(this: M, count: number, callback: (item: InstanceType<M>) => void | Promise<void>): Promise<void>;
-    static cursor<M extends typeof Model>(this: M): AsyncGenerator<InstanceType<M>>;
-    static lazy<M extends typeof Model>(this: M, count?: number): AsyncGenerator<InstanceType<M>>;
+    static create<M extends ModelConstructor>(this: M, attributes: Partial<InstanceType<M> extends Model<infer U> ? U : Record<string, any>>): Promise<InstanceType<M>>;
+    static find<M extends ModelConstructor>(this: M, id: any): Promise<InstanceType<M> | null>;
+    static findOrFail<M extends ModelConstructor>(this: M, id: any): Promise<InstanceType<M>>;
+    static first<M extends ModelConstructor>(this: M): Promise<InstanceType<M> | null>;
+    static firstOrFail<M extends ModelConstructor>(this: M): Promise<InstanceType<M>>;
+    static firstOrCreate<M extends ModelConstructor>(this: M, attributes?: Record<string, any>, values?: Record<string, any>): Promise<InstanceType<M>>;
+    static updateOrCreate<M extends ModelConstructor>(this: M, attributes: Record<string, any>, values?: Record<string, any>): Promise<InstanceType<M>>;
+    static where<M extends ModelConstructor>(this: M, column: string | Record<string, any>, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static orderBy<M extends ModelConstructor>(this: M, column: string, direction?: "asc" | "desc"): Builder<InstanceType<M>>;
+    static whereIn<M extends ModelConstructor>(this: M, column: string, values: any[]): Builder<InstanceType<M>>;
+    static whereNull<M extends ModelConstructor>(this: M, column: string): Builder<InstanceType<M>>;
+    static whereNotNull<M extends ModelConstructor>(this: M, column: string): Builder<InstanceType<M>>;
+    static orWhere<M extends ModelConstructor>(this: M, column: string | Record<string, any>, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static whereNot<M extends ModelConstructor>(this: M, column: string | Record<string, any>, value?: any): Builder<InstanceType<M>>;
+    static orWhereNot<M extends ModelConstructor>(this: M, column: string | Record<string, any>, value?: any): Builder<InstanceType<M>>;
+    static whereDate<M extends ModelConstructor>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static orWhereDate<M extends ModelConstructor>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static whereDay<M extends ModelConstructor>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static orWhereDay<M extends ModelConstructor>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static whereMonth<M extends ModelConstructor>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static orWhereMonth<M extends ModelConstructor>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static whereYear<M extends ModelConstructor>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static orWhereYear<M extends ModelConstructor>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static whereTime<M extends ModelConstructor>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static orWhereTime<M extends ModelConstructor>(this: M, column: string, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static latest<M extends ModelConstructor>(this: M, column?: string): Builder<InstanceType<M>>;
+    static oldest<M extends ModelConstructor>(this: M, column?: string): Builder<InstanceType<M>>;
+    static when<M extends ModelConstructor>(this: M, condition: any, callback: (query: Builder<any>) => void | Builder<any>, defaultCallback?: (query: Builder<any>) => void | Builder<any>): Builder<InstanceType<M>>;
+    static unless<M extends ModelConstructor>(this: M, condition: any, callback: (query: Builder<any>) => void | Builder<any>, defaultCallback?: (query: Builder<any>) => void | Builder<any>): Builder<InstanceType<M>>;
+    static tap<M extends ModelConstructor>(this: M, callback: (query: Builder<any>) => void | Builder<any>): Builder<InstanceType<M>>;
+    static take<M extends ModelConstructor>(this: M, count: number): Builder<InstanceType<M>>;
+    static skip<M extends ModelConstructor>(this: M, count: number): Builder<InstanceType<M>>;
+    static inRandomOrder<M extends ModelConstructor>(this: M): Builder<InstanceType<M>>;
+    static lockForUpdate<M extends ModelConstructor>(this: M): Builder<InstanceType<M>>;
+    static sharedLock<M extends ModelConstructor>(this: M): Builder<InstanceType<M>>;
+    static with<M extends ModelConstructor>(this: M, ...relations: string[]): Builder<InstanceType<M>>;
+    static withTrashed<M extends ModelConstructor>(this: M): Builder<InstanceType<M>>;
+    static onlyTrashed<M extends ModelConstructor>(this: M): Builder<InstanceType<M>>;
+    static withoutGlobalScope<M extends ModelConstructor>(this: M, scope: string): Builder<InstanceType<M>>;
+    static withoutGlobalScopes<M extends ModelConstructor>(this: M): Builder<InstanceType<M>>;
+    static scope<M extends ModelConstructor>(this: M, name: string, ...args: any[]): Builder<InstanceType<M>>;
+    static has<M extends ModelConstructor>(this: M, relationName: string, operator?: string, count?: number): Builder<InstanceType<M>>;
+    static whereHas<M extends ModelConstructor>(this: M, relationName: string, callback?: (query: Builder<any>) => void | Builder<any>, operator?: string, count?: number): Builder<InstanceType<M>>;
+    static doesntHave<M extends ModelConstructor>(this: M, relationName: string): Builder<InstanceType<M>>;
+    static withCount<M extends ModelConstructor>(this: M, relationName: string, alias?: string): Builder<InstanceType<M>>;
+    static withSum<M extends ModelConstructor>(this: M, relationName: string, column: string, alias?: string): Builder<InstanceType<M>>;
+    static withAvg<M extends ModelConstructor>(this: M, relationName: string, column: string, alias?: string): Builder<InstanceType<M>>;
+    static withMin<M extends ModelConstructor>(this: M, relationName: string, column: string, alias?: string): Builder<InstanceType<M>>;
+    static withMax<M extends ModelConstructor>(this: M, relationName: string, column: string, alias?: string): Builder<InstanceType<M>>;
+    static all<M extends ModelConstructor>(this: M): Promise<InstanceType<M>[]>;
+    static paginate<M extends ModelConstructor>(this: M, perPage?: number, page?: number): Promise<import("../query/Builder.js").Paginator<InstanceType<M>>>;
+    static chunk<M extends ModelConstructor>(this: M, count: number, callback: (items: InstanceType<M>[]) => void | Promise<void>): Promise<void>;
+    static each<M extends ModelConstructor>(this: M, count: number, callback: (item: InstanceType<M>) => void | Promise<void>): Promise<void>;
+    static cursor<M extends ModelConstructor>(this: M): AsyncGenerator<InstanceType<M>>;
+    static lazy<M extends ModelConstructor>(this: M, count?: number): AsyncGenerator<InstanceType<M>>;
     static eagerLoadRelations(models: Model[], relations: string[]): Promise<void>;
     static eagerLoadRelation(models: Model[], relationName: string): Promise<void>;
     fill(attributes: Partial<T>): this;

package/dist/src/model/MorphRelations.d.ts

@@ -16,12 +16,12 @@ export declare class MorphTo<T extends Model = Model> {
 export declare class MorphOne<T extends Model = Model> {
     protected builder: Builder<T>;
     protected parent: Model;
-    protected related: typeof Model;
+    protected related: ModelConstructor;
     protected name: string;
     protected typeColumn: string;
     protected idColumn: string;
     protected localKey: string;
-    constructor(parent: Model, related: typeof Model, name: string, typeColumn?: string, idColumn?: string, localKey?: string);
+    constructor(parent: Model, related: ModelConstructor, name: string, typeColumn?: string, idColumn?: string, localKey?: string);
     protected getMorphType(): string;
     getQuery(): Builder<T>;
     addEagerConstraints(models: Model[]): void;
@@ -37,12 +37,12 @@ export declare class MorphOne<T extends Model = Model> {
 export declare class MorphMany<T extends Model = Model> {
     protected builder: Builder<T>;
     protected parent: Model;
-    protected related: typeof Model;
+    protected related: ModelConstructor;
     protected name: string;
     protected typeColumn: string;
     protected idColumn: string;
     protected localKey: string;
-    constructor(parent: Model, related: typeof Model, name: string, typeColumn?: string, idColumn?: string, localKey?: string);
+    constructor(parent: Model, related: ModelConstructor, name: string, typeColumn?: string, idColumn?: string, localKey?: string);
     protected getMorphType(): string;
     getQuery(): Builder<T>;
     addEagerConstraints(models: Model[]): void;
@@ -58,7 +58,7 @@ export declare class MorphMany<T extends Model = Model> {
 export declare class MorphToMany<T extends Model = Model> {
     protected builder: Builder<T>;
     protected parent: Model;
-    protected related: typeof Model;
+    protected related: ModelConstructor;
     protected name: string;
     protected table: string;
     protected foreignPivotKey: string;
@@ -66,7 +66,7 @@ export declare class MorphToMany<T extends Model = Model> {
     protected parentKey: string;
     protected relatedKey: string;
     protected morphType: string;
-    constructor(parent: Model, related: typeof Model, name: string, table?: string, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string, morphType?: string);
+    constructor(parent: Model, related: ModelConstructor, name: string, table?: string, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string, morphType?: string);
     protected addConstraints(): void;
     getQuery(): Builder<T>;
     addEagerConstraints(models: Model[]): void;

package/dist/src/query/Builder.d.ts

@@ -1,6 +1,6 @@
 import { Connection } from "../connection/Connection.js";
 import type { WhereClause, OrderClause, HavingClause, UnionClause } from "../types/index.js";
-import type { Model } from "../model/Model.js";
+import type { ModelConstructor } from "../model/Model.js";
 type RelationConstraint = (query: Builder<any>) => void | Builder<any>;
 export interface Paginator<T> {
     data: T[];
@@ -23,7 +23,7 @@ export declare class Builder<T = Record<string, any>> {
     offsetValue?: number;
     joins: string[];
     distinctFlag: boolean;
-    model?: typeof Model;
+    model?: ModelConstructor;
     eagerLoads: string[];
     randomOrderFlag: boolean;
     lockMode?: string;
@@ -32,7 +32,7 @@ export declare class Builder<T = Record<string, any>> {
     updateJoins: string[];
     constructor(connection: Connection, table: string);
     private get grammar();
-    setModel(model: typeof Model): this;
+    setModel(model: ModelConstructor): this;
     table(table: string): this;
     select(...columns: string[]): this;
     distinct(): this;

package/dist/src/typegen/TypeGenerator.js

@@ -36,7 +36,12 @@ export class TypeGenerator {
                 const modelDeclaration = this.getModelDeclaration(table, className, target.modelImportPrefix);
                 if (declarationOnly && modelDeclaration) {
                     lines.push(`declare module "${modelDeclaration.path}" {`);
-                    lines.push(`  interface ${modelDeclaration.className} extends ${interfaceName} {}`);
+                    lines.push(`  interface ${modelDeclaration.className} {`);
+                    for (const col of columns) {
+                        const tsType = TypeMapper.sqlToTsType(col.type, col.nullable);
+                        lines.push(`    ${col.name}${col.nullable ? "?" : ""}: ${tsType};`);
+                    }
+                    lines.push("  }");
                     lines.push("}");
                     lines.push("");
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bunnykit/orm",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "An Eloquent-inspired ORM for Bun's native SQL client supporting SQLite, MySQL, and PostgreSQL.",
   "license": "MIT",
   "packageManager": "bun@1.3.12",