ilana-orm 1.0.15 → 1.0.17

package/cli/ilana.js

@@ -749,6 +749,271 @@ module.exports = ${className}Cast;
 }
 
 
+// ─── Type Generator ───────────────────────────────────────────────────────────
+
+const CAST_TYPE_MAP = {
+  string: 'string', number: 'number', float: 'number',
+  boolean: 'boolean', date: 'Date',
+  json: 'Record<string, any>', object: 'Record<string, any>', array: 'any[]',
+};
+
+// Knex column builder method → { tsType, nullable default }
+const KNEX_COLUMN_MAP = {
+  increments: { type: 'number', nullable: false },
+  bigIncrements: { type: 'number', nullable: false },
+  integer: { type: 'number', nullable: true },
+  bigInteger: { type: 'number', nullable: true },
+  tinyint: { type: 'number', nullable: true },
+  smallint: { type: 'number', nullable: true },
+  mediumint: { type: 'number', nullable: true },
+  float: { type: 'number', nullable: true },
+  double: { type: 'number', nullable: true },
+  decimal: { type: 'number', nullable: true },
+  string: { type: 'string', nullable: true },
+  text: { type: 'string', nullable: true },
+  mediumtext: { type: 'string', nullable: true },
+  longtext: { type: 'string', nullable: true },
+  char: { type: 'string', nullable: true },
+  uuid: { type: 'string', nullable: true },
+  enum: { type: 'string', nullable: true },
+  set: { type: 'string', nullable: true },
+  boolean: { type: 'boolean', nullable: true },
+  date: { type: 'Date', nullable: true },
+  datetime: { type: 'Date', nullable: true },
+  timestamp: { type: 'Date', nullable: true },
+  time: { type: 'string', nullable: true },
+  json: { type: 'Record<string, any>', nullable: true },
+  jsonb: { type: 'Record<string, any>', nullable: true },
+  binary: { type: 'Buffer', nullable: true },
+};
+
+const RELATION_RETURN_MAP = {
+  hasOne: (r) => `${r} | null`,
+  hasMany: (r) => `${r}[]`,
+  belongsTo: (r) => `${r} | null`,
+  belongsToMany: (r) => `${r}[]`,
+  hasManyThrough: (r) => `${r}[]`,
+  morphTo: () => 'any',
+  morphOne: () => 'any | null',
+  morphMany: () => 'any[]',
+};
+
+// Parse migration files to extract column definitions for a given table name
+function parseMigrationsForTable(tableName, migrationsDir) {
+  if (!fs.existsSync(migrationsDir)) return {};
+
+  const columns = {};
+  const files = fs.readdirSync(migrationsDir)
+    .filter(f => f.endsWith('.js') || f.endsWith('.mjs') || f.endsWith('.ts'))
+    .sort(); // oldest first so later migrations can override
+
+  for (const file of files) {
+    const content = fs.readFileSync(path.join(migrationsDir, file), 'utf8');
+
+    // Find createTable / table blocks for this table
+    const tableBlockRegex = new RegExp(
+      `(?:createTable|table)\\s*\\(\\s*['"]${tableName}['"]\\s*,\\s*(?:async\\s*)?(?:\\(\\s*)?(\\w+)\\s*(?:\\))?\\s*(?:=>|{)[\\s\\S]*?(?=\\}\\s*\\)|\\}\\s*;)`,
+      'g'
+    );
+
+    let blockMatch;
+    while ((blockMatch = tableBlockRegex.exec(content)) !== null) {
+      const block = blockMatch[0];
+      const alias = blockMatch[1] || 'table';
+
+      // Match column definitions: table.string('col'), table.integer('col').nullable(), etc.
+      const colRegex = new RegExp(
+        `${alias}\\.(\\w+)\\s*\\(\\s*['"]([^'"]+)['"](?:[^)]*)?\\)([^;\\n]*)`,
+        'g'
+      );
+
+      let colMatch;
+      while ((colMatch = colRegex.exec(block)) !== null) {
+        const [, method, colName, rest] = colMatch;
+        const knexDef = KNEX_COLUMN_MAP[method];
+        if (!knexDef) continue;
+
+        const isNullable = /\.nullable\(\)/.test(rest);
+        const isNotNullable = /\.notNullable\(\)/.test(rest);
+        const nullable = isNullable ? true : isNotNullable ? false : knexDef.nullable;
+
+        columns[colName] = { type: knexDef.type, nullable };
+      }
+    }
+  }
+
+  return columns;
+}
+
+function parseModelFile(content, fileName) {
+  const classMatch = content.match(/class\s+(\w+)\s+extends/);
+  const className = classMatch?.[1] || toPascalCase(path.basename(fileName, path.extname(fileName)));
+
+  const tableMatch = content.match(/static\s+table\s*=\s*['"]([^'"]+)['"]/);
+  const table = tableMatch?.[1] || pluralize(toSnakeCase(className));
+
+  const fillableMatch = content.match(/(?:static\s+)?fillable\s*=\s*\[([^\]]*)\]/s);
+  const fillable = fillableMatch
+    ? [...fillableMatch[1].matchAll(/['"]([^'"]+)['"]/g)].map(m => m[1])
+    : [];
+
+  const castsMatch = content.match(/(?:static\s+)?casts\s*=\s*\{([^}]*)\}/s);
+  const casts = {};
+  if (castsMatch) {
+    for (const [, key, val] of castsMatch[1].matchAll(/['"]?(\w+)['"]?\s*:\s*['"](\w+)['"]/g)) {
+      casts[key] = val;
+    }
+  }
+
+  const pkMatch = content.match(/static\s+primaryKey\s*=\s*['"]([^'"]+)['"]/);
+  const primaryKey = pkMatch?.[1] || 'id';
+
+  const keyTypeMatch = content.match(/static\s+keyType\s*=\s*['"]([^'"]+)['"]/);
+  const keyType = (keyTypeMatch?.[1] === 'string') ? 'string' : 'number';
+
+  const timestampsMatch = content.match(/static\s+timestamps\s*=\s*(true|false)/);
+  const timestamps = timestampsMatch?.[1] !== 'false';
+
+  const softDeletesMatch = content.match(/static\s+softDeletes\s*=\s*(true|false)/);
+  const softDeletes = softDeletesMatch?.[1] === 'true';
+
+  const createdAtCol = content.match(/static\s+createdAt\s*=\s*['"]([^'"]+)['"]/)?.[1] || 'created_at';
+  const updatedAtCol = content.match(/static\s+updatedAt\s*=\s*['"]([^'"]+)['"]/)?.[1] || 'updated_at';
+  const deletedAtCol = content.match(/static\s+deletedAt\s*=\s*['"]([^'"]+)['"]/)?.[1] || 'deleted_at';
+
+  const relations = [];
+  const relRegex = /(\w+)\s*\(\s*\)\s*\{[\s\S]*?return\s+this\.(hasOne|hasMany|belongsTo|belongsToMany|hasManyThrough|morphTo|morphOne|morphMany)\s*\(\s*['"]?(\w*?)['"]?[,)]/g;
+  let m;
+  while ((m = relRegex.exec(content)) !== null) {
+    const [, methodName, relationType, relatedModel] = m;
+    if (methodName !== 'constructor') {
+      relations.push({ methodName, relationType, relatedModel: relatedModel || 'any' });
+    }
+  }
+
+  return { className, table, fillable, casts, primaryKey, keyType, timestamps, softDeletes, createdAtCol, updatedAtCol, deletedAtCol, relations };
+}
+
+function generateModelTypes(model, migrationColumns = {}) {
+  const { className, fillable, casts, primaryKey, keyType, timestamps, softDeletes, createdAtCol, updatedAtCol, deletedAtCol, relations } = model;
+
+  const relatedModels = [...new Set(
+    relations.map(r => r.relatedModel).filter(r => r && r !== 'any')
+  )];
+
+  const fields = [];
+
+  // Primary key — always non-nullable
+  fields.push(`  ${primaryKey}: ${keyType};`);
+
+  // All columns known from migrations, minus pk and timestamp cols (handled separately)
+  const tsColNames = [primaryKey, createdAtCol, updatedAtCol, deletedAtCol];
+  const allCols = new Set([...fillable, ...Object.keys(migrationColumns)]);
+
+  for (const col of allCols) {
+    if (tsColNames.includes(col)) continue;
+
+    // Cast takes priority over migration inference
+    if (casts[col]) {
+      const tsType = CAST_TYPE_MAP[casts[col]] || 'any';
+      fields.push(`  ${col}?: ${tsType};`);
+      continue;
+    }
+
+    const migCol = migrationColumns[col];
+    if (migCol) {
+      const tsType = migCol.nullable ? `${migCol.type} | null` : migCol.type;
+      fields.push(`  ${col}?: ${tsType};`);
+    } else {
+      fields.push(`  ${col}?: any;`);
+    }
+  }
+
+  if (timestamps) {
+    fields.push(`  ${createdAtCol}?: Date;`);
+    fields.push(`  ${updatedAtCol}?: Date;`);
+  }
+
+  if (softDeletes) {
+    fields.push(`  ${deletedAtCol}?: Date | null;`);
+  }
+
+  for (const { methodName, relationType, relatedModel } of relations) {
+    const returnType = RELATION_RETURN_MAP[relationType]?.(relatedModel) || 'any';
+    fields.push(`  ${methodName}?: ${returnType};`);
+  }
+
+  const relationMethods = relations.map(({ methodName, relationType }) => {
+    const map = { hasOne: 'HasOne', hasMany: 'HasMany', belongsTo: 'BelongsTo', belongsToMany: 'BelongsToMany', hasManyThrough: 'HasManyThrough', morphTo: 'MorphTo', morphOne: 'MorphOne', morphMany: 'MorphMany' };
+    return `  ${methodName}(): ${map[relationType] || 'any'};`;
+  });
+
+  const usedRelTypes = [...new Set(relations.map(r => {
+    const map = { hasOne: 'HasOne', hasMany: 'HasMany', belongsTo: 'BelongsTo', belongsToMany: 'BelongsToMany', hasManyThrough: 'HasManyThrough', morphTo: 'MorphTo', morphOne: 'MorphOne', morphMany: 'MorphMany' };
+    return map[r.relationType];
+  }).filter(Boolean))];
+
+  const coreImports = usedRelTypes.length
+    ? `import { Model, ${usedRelTypes.join(', ')} } from 'ilana-orm';`
+    : `import { Model } from 'ilana-orm';`;
+
+  return `// Auto-generated by \`npx ilana types\` — do not edit manually
+${coreImports}
+${relatedModels.length ? `import type { ${relatedModels.join(', ')} } from './index';\n` : ''}
+export interface ${className}Attributes {
+${fields.join('\n')}
+}
+
+declare class ${className} extends Model<${className}Attributes> {
+${relationMethods.length ? relationMethods.join('\n') + '\n' : ''}
+}
+
+export default ${className};
+`;
+}
+
+async function generateTypes(outDir) {
+  // Only meaningful in TypeScript projects
+  if (!isTypeScriptProject()) return;
+
+  const structure = getProjectStructure();
+  const modelsDir = path.join(process.cwd(), structure.modelsDir);
+  const migrationsDir = path.join(process.cwd(), structure.databaseDir, 'migrations');
+
+  if (!fs.existsSync(modelsDir)) return;
+
+  const modelFiles = fs.readdirSync(modelsDir)
+    .filter(f => f.endsWith('.js') || f.endsWith('.ts'))
+    .filter(f => !f.endsWith('.d.ts'));
+
+  if (modelFiles.length === 0) return;
+
+  const outputDir = path.join(process.cwd(), outDir);
+  if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
+
+  const classNames = [];
+
+  for (const file of modelFiles) {
+    const content = fs.readFileSync(path.join(modelsDir, file), 'utf8');
+    const model = parseModelFile(content, file);
+    const migrationColumns = parseMigrationsForTable(model.table, migrationsDir);
+    const dts = generateModelTypes(model, migrationColumns);
+    const outFile = path.join(outputDir, `${model.className}.d.ts`);
+    fs.writeFileSync(outFile, dts);
+    console.log(`  Generated: ${path.relative(process.cwd(), outFile)}`);
+    classNames.push(model.className);
+  }
+
+  const indexContent = classNames
+    .map(n => `export { default as ${n}, type ${n}Attributes } from './${n}';`)
+    .join('\n') + '\n';
+  fs.writeFileSync(path.join(outputDir, 'index.d.ts'), `// Auto-generated by \`npx ilana types\` — do not edit manually\n${indexContent}`);
+  console.log(`  Generated: ${path.relative(process.cwd(), path.join(outputDir, 'index.d.ts'))}`);
+  console.log(`\n✓ ${classNames.length} model type${classNames.length !== 1 ? 's' : ''} generated in ${outDir}/`);
+}
+
+// ─── Commands ─────────────────────────────────────────────────────────────────
+
 const commands = {
   async setup() {
     console.log('Setting up Ilana ORM...');
@@ -920,6 +1185,7 @@ DB_TIMEZONE=UTC
     }
 
     generateModel(name, options);
+    await generateTypes('types');
   },
 
   async migrate(...args) {
@@ -953,6 +1219,7 @@ DB_TIMEZONE=UTC
     }
 
     await runner.migrate(connection, onlyFile, toFile);
+    await generateTypes('types');
     process.exit(0);
   },
 
@@ -979,6 +1246,7 @@ DB_TIMEZONE=UTC
       await commands.seed();
     }
 
+    await generateTypes('types');
     process.exit(0);
   },
 
@@ -1043,6 +1311,7 @@ DB_TIMEZONE=UTC
     await initializeDatabase();
     const runner = new MigrationRunner();
     await runner.refresh(connection);
+    await generateTypes('types');
     process.exit(0);
   },
 
@@ -1166,6 +1435,20 @@ DB_TIMEZONE=UTC
     }
   },
 
+  async types(...args) {
+    if (!isTypeScriptProject()) {
+      console.log('Skipping type generation — not a TypeScript project.');
+      return;
+    }
+    let outDir = 'types';
+    for (const arg of args) {
+      if (arg.startsWith('--out=')) outDir = arg.split('=')[1];
+      else if (!arg.startsWith('--')) outDir = arg;
+    }
+    console.log('Generating model types...\n');
+    await generateTypes(outDir);
+  },
+
   async 'make:cast'(name) {
     if (!name) {
       console.error('Cast name is required');
@@ -1220,7 +1503,10 @@ Available commands:
   seed [name]                  Run database seeders
   db:seed [name]               Alias for seed command
   db:wipe [connection]         Drop all tables
-  
+
+  types [--out=dir]            Generate TypeScript types for all models
+                               Default output: types/
+
   help                         Show this help message
 
 Examples:
@@ -1239,6 +1525,8 @@ Examples:
   ilana migrate:fresh --seed
   ilana seed UserSeeder
   ilana db:wipe
+  ilana types
+  ilana types --out=src/types
 `);
   }
 };

package/database/schema-builder.js

@@ -104,10 +104,9 @@ class SchemaBuilder {
 
   checkPositive(column) {
     const client = this.knex.client.config.client;
-    if (client === 'pg') {
-      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD CONSTRAINT ${column}_positive CHECK (${column} > 0)`);
-    } else if (client === 'mysql2') {
-      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD CONSTRAINT ${column}_positive CHECK (${column} > 0)`);
+    if (client === 'pg' || client === 'mysql2') {
+      return this.knex.raw(`ALTER TABLE ?? ADD CONSTRAINT ?? CHECK (?? > 0)`,
+        [this.currentTable, `${column}_positive`, column]);
     }
     return Promise.resolve();
   }
@@ -115,9 +114,11 @@ class SchemaBuilder {
   checkRegex(column, pattern) {
     const client = this.knex.client.config.client;
     if (client === 'pg') {
-      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD CONSTRAINT ${column}_regex CHECK (${column} ~ '${pattern}')`);
+      return this.knex.raw(`ALTER TABLE ?? ADD CONSTRAINT ?? CHECK (?? ~ ?)`,
+        [this.currentTable, `${column}_regex`, column, pattern]);
     } else if (client === 'mysql2') {
-      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD CONSTRAINT ${column}_regex CHECK (${column} REGEXP '${pattern}')`);
+      return this.knex.raw(`ALTER TABLE ?? ADD CONSTRAINT ?? CHECK (?? REGEXP ?)`,
+        [this.currentTable, `${column}_regex`, column, pattern]);
     }
     return Promise.resolve();
   }
@@ -125,9 +126,11 @@ class SchemaBuilder {
   generatedAs(column, expression) {
     const client = this.knex.client.config.client;
     if (client === 'mysql2') {
-      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD ${column} VARCHAR(255) GENERATED ALWAYS AS (${expression}) STORED`);
+      return this.knex.raw(`ALTER TABLE ?? ADD ?? VARCHAR(255) GENERATED ALWAYS AS (${expression}) STORED`,
+        [this.currentTable, column]);
     } else if (client === 'pg') {
-      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD ${column} TEXT GENERATED ALWAYS AS (${expression}) STORED`);
+      return this.knex.raw(`ALTER TABLE ?? ADD ?? TEXT GENERATED ALWAYS AS (${expression}) STORED`,
+        [this.currentTable, column]);
     }
     return Promise.resolve();
   }
@@ -135,9 +138,9 @@ class SchemaBuilder {
   collate(tableName, collation) {
     const client = this.knex.client.config.client;
     if (client === 'mysql2') {
-      return this.knex.raw(`ALTER TABLE ${tableName} COLLATE ${collation}`);
+      return this.knex.raw(`ALTER TABLE ?? COLLATE ??`, [tableName, collation]);
     } else if (client === 'pg') {
-      return this.knex.raw(`ALTER TABLE ${tableName} ALTER COLUMN name TYPE TEXT COLLATE "${collation}"`);
+      return this.knex.raw(`ALTER TABLE ?? ALTER COLUMN name TYPE TEXT COLLATE ??`, [tableName, collation]);
     }
     return Promise.resolve();
   }
@@ -166,7 +169,9 @@ class SchemaBuilder {
   fulltext(columns, indexName) {
     if (this.knex.client.config.client === 'mysql2') {
       const name = indexName || `${columns.join('_')}_fulltext`;
-      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD FULLTEXT INDEX ${name} (${columns.join(', ')})`);
+      const colRefs = columns.map(() => '??').join(', ');
+      return this.knex.raw(`ALTER TABLE ?? ADD FULLTEXT INDEX ?? (${colRefs})`,
+        [this.currentTable, name, ...columns]);
     }
     return Promise.resolve();
   }
@@ -174,7 +179,8 @@ class SchemaBuilder {
   spatial(column, indexName) {
     if (this.knex.client.config.client === 'mysql2') {
       const name = indexName || `${column}_spatial`;
-      return this.knex.raw(`ALTER TABLE ${this.currentTable} ADD SPATIAL INDEX ${name} (${column})`);
+      return this.knex.raw(`ALTER TABLE ?? ADD SPATIAL INDEX ?? (??)`,
+        [this.currentTable, name, column]);
     }
     return Promise.resolve();
   }

package/index.js

@@ -24,6 +24,7 @@ module.exports = {
   defineFactory: Factory.defineFactory,
   
   // Relationships
+  MorphOne: Relation.MorphOne,
   ...Relation,
   
   // Custom Casts

package/index.mjs

@@ -22,6 +22,7 @@ export const {
   BelongsToMany,
   HasManyThrough,
   MorphTo,
+  MorphOne,
   MorphMany,
   MoneyCast,
   EncryptedCast,

package/orm/Factory.js

@@ -7,14 +7,14 @@ class Factory {
     this.definition = definition;
     this.faker = faker;
     this.states = new Map();
-    this.afterCreating = [];
-    this.afterMaking = [];
-    this.beforeCreating = [];
-    this.beforeMaking = [];
+    this._afterCreatingCallbacks = [];
+    this._afterMakingCallbacks = [];
+    this._beforeCreatingCallbacks = [];
+    this._beforeMakingCallbacks = [];
     this.count = 1;
     this.currentStates = [];
     this.relationships = new Map();
-    this.sequence = 0;
+    this._sequenceCount = 0;
     this.sequences = new Map();
   }
 
@@ -28,22 +28,22 @@ class Factory {
   }
 
   afterCreating(callback) {
-    this.afterCreating.push(callback);
+    this._afterCreatingCallbacks.push(callback);
     return this;
   }
 
   afterMaking(callback) {
-    this.afterMaking.push(callback);
+    this._afterMakingCallbacks.push(callback);
     return this;
   }
 
   beforeCreating(callback) {
-    this.beforeCreating.push(callback);
+    this._beforeCreatingCallbacks.push(callback);
     return this;
   }
 
   beforeMaking(callback) {
-    this.beforeMaking.push(callback);
+    this._beforeMakingCallbacks.push(callback);
     return this;
   }
 
@@ -75,7 +75,7 @@ class Factory {
   }
 
   sequence() {
-    return ++this.sequence;
+    return ++this._sequenceCount;
   }
 
   // Enhanced sequence methods
@@ -92,7 +92,7 @@ class Factory {
       this.sequences?.set(key, 0);
     } else {
       this.sequences?.clear();
-      this.sequence = 0;
+      this._sequenceCount = 0;
     }
     return this;
   }
@@ -138,8 +138,6 @@ class Factory {
     
     if (typeof this.definition === 'function') {
       modelAttributes = this.definition(faker);
-    } else if (this.definition === undefined && typeof this.definition === 'function') {
-      modelAttributes = this.definition();
     } else {
       throw new Error('Factory must have a definition function');
     }
@@ -153,7 +151,7 @@ class Factory {
 
     modelAttributes = { ...modelAttributes, ...attributes };
 
-    for (const callback of this.beforeMaking) {
+    for (const callback of this._beforeMakingCallbacks) {
       modelAttributes = callback(modelAttributes) || modelAttributes;
     }
 
@@ -167,7 +165,7 @@ class Factory {
     model.fill(modelAttributes);
 
     // Run afterMaking callbacks
-    for (const callback of this.afterMaking) {
+    for (const callback of this._afterMakingCallbacks) {
       await callback(model);
     }
 
@@ -178,14 +176,14 @@ class Factory {
     const model = await this.makeOne(attributes);
     
     // Run beforeCreating callbacks
-    for (const callback of this.beforeCreating) {
+    for (const callback of this._beforeCreatingCallbacks) {
       await callback(model);
     }
-    
+
     await model.save();
 
     // Run afterCreating callbacks
-    for (const callback of this.afterCreating) {
+    for (const callback of this._afterCreatingCallbacks) {
       await callback(model);
     }
 
@@ -243,6 +241,8 @@ class Factory {
       const batchFactory = new Factory(this.model, this.definition);
       batchFactory.count = currentBatchSize;
       batchFactory.currentStates = [...this.currentStates];
+      batchFactory._afterCreatingCallbacks = [...this._afterCreatingCallbacks];
+      batchFactory._beforeCreatingCallbacks = [...this._beforeCreatingCallbacks];
       
       const batch = await batchFactory.create(attributes);
       results.push(...(Array.isArray(batch) ? batch : [batch]));
@@ -352,6 +352,8 @@ if (typeof Model !== 'undefined') {
       // Return a new instance to avoid state pollution
       const newFactory = new Factory(this, existingFactory.definition);
       newFactory.states = new Map(existingFactory.states);
+      newFactory._afterCreatingCallbacks = [...existingFactory._afterCreatingCallbacks];
+      newFactory._beforeCreatingCallbacks = [...existingFactory._beforeCreatingCallbacks];
       return newFactory;
     }
     throw new Error(`No factory defined for model: ${this.name}`);

package/orm/Model.d.ts

@@ -1,12 +1,17 @@
 import QueryBuilder from './QueryBuilder';
-import { HasOne, HasMany, BelongsTo, BelongsToMany, HasManyThrough, MorphTo, MorphMany } from './Relation';
+import { HasOne, HasMany, BelongsTo, BelongsToMany, HasManyThrough, MorphTo, MorphOne, MorphMany } from './Relation';
 
 export interface ModelAttributes {
   [key: string]: any;
 }
 
+export interface CastInstance {
+  get(value: any): any;
+  set(value: any): any;
+}
+
 export interface ModelCasts {
-  [key: string]: 'string' | 'number' | 'boolean' | 'date' | 'json' | 'array' | 'object' | 'float';
+  [key: string]: 'string' | 'number' | 'boolean' | 'date' | 'json' | 'array' | 'object' | 'float' | CastInstance;
 }
 
 export interface ModelEvents {
@@ -26,7 +31,7 @@ export interface Observer {
   restored?(model: any): Promise<void> | void;
 }
 
-export default class Model {
+export default class Model<TAttributes extends ModelAttributes = ModelAttributes> {
   // Static properties
   protected static table: string;
   protected static connection?: string;
@@ -34,7 +39,10 @@ export default class Model {
   protected static keyType: 'number' | 'string';
   protected static incrementing: boolean;
   protected static timestamps: boolean;
+  protected static createdAt: string;
+  protected static updatedAt: string;
   protected static softDeletes: boolean;
+  protected static deletedAt: string;
   protected static fillable: string[];
   protected static guarded: string[];
   protected static casts: ModelCasts;
@@ -64,6 +72,7 @@ export default class Model {
   static resolveRelatedModel(related: string | typeof Model): typeof Model;
   static query(): QueryBuilder;
   static with(...relations: string[]): QueryBuilder;
+  static withCount(...relations: string[]): QueryBuilder;
   static on(connectionOrTrx: string | any): QueryBuilder;
   static all(): Promise<Model[]>;
   static find(id: any): Promise<Model | null>;
@@ -72,6 +81,10 @@ export default class Model {
   static firstOrFail(): Promise<Model>;
   static latest(column?: string): QueryBuilder;
   static oldest(column?: string): QueryBuilder;
+  static withTrashed(): QueryBuilder;
+  static onlyTrashed(): QueryBuilder;
+  static upsert(data: any[], uniqueBy: string[], update?: string[]): Promise<any>;
+  static withoutGlobalScopes(): QueryBuilder;
   static make(attributes?: ModelAttributes): Model;
   static create(attributes?: ModelAttributes): Promise<Model>;
   static generateUuid(): string;
@@ -111,10 +124,19 @@ export default class Model {
   // Instance methods
   getKey(): any;
   fill(attributes: ModelAttributes): this;
+  load(...relations: string[]): Promise<this>;
+  loadMissing(...relations: string[]): Promise<this>;
+  getRelation(key: string): any;
+  relationLoaded(key: string): boolean;
+  makeHidden(keys: string | string[]): this;
+  makeVisible(keys: string | string[]): this;
+  append(keys: string | string[]): this;
   isFillable(key: string): boolean;
   getAttribute(key: string): any;
   setAttribute(key: string, value: any): this;
   syncOriginal(): void;
+  getOriginal(key: string): any;
+  getOriginal(): ModelAttributes;
   save(): Promise<boolean>;
   update(attributes?: ModelAttributes): Promise<boolean>;
   isDirty(key?: string): boolean;
@@ -148,6 +170,7 @@ export default class Model {
     secondLocalKey?: string
   ): HasManyThrough;
   morphTo(typeColumn?: string, idColumn?: string): MorphTo;
+  morphOne(related: string | typeof Model, typeColumn?: string, idColumn?: string): MorphOne;
   morphMany(related: string | typeof Model, typeColumn?: string, idColumn?: string): MorphMany;
 
   // Protected methods