ilana-orm 1.0.2 → 1.0.5

package/cli/ilana.js

@@ -131,8 +131,8 @@ function generateModel(name, options = {}) {
 
 function getModelTemplate(className, tableName) {
   if (isTypeScriptProject()) {
-    return `import Model from 'ilana-orm/orm/Model';
-// import { MoneyCast, EncryptedCast } from 'ilana-orm/orm/CustomCasts';
+    return `import Model from 'ilana-orm/orm/Model.js';
+// import { MoneyCast, EncryptedCast } from 'ilana-orm/orm/CustomCasts.js';
 
 export default class ${className} extends Model {
   protected static table = '${tableName}';
@@ -223,7 +223,7 @@ module.exports = ${className};
 
 function getPivotModelTemplate(className, tableName) {
   if (isTypeScriptProject()) {
-    return `import Model from 'ilana-orm/orm/Model';
+    return `import Model from 'ilana-orm/orm/Model.js';
 
 export default class ${className} extends Model {
   protected static table = '${tableName}';
@@ -260,8 +260,8 @@ function generateFactory(className) {
   }
 
   const template = isTypeScriptProject() ?
-    `import { defineFactory } from 'ilana-orm/orm/Factory';
-import ${className} from '../../models/${className}';
+    `import { defineFactory } from 'ilana-orm/orm/Factory.js';
+import ${className} from '../../models/${className}.js';
 
 export default defineFactory(${className}, (faker) => ({
   // Define your factory attributes here
@@ -298,9 +298,9 @@ function generateSeeder(className) {
   }
 
   const template = isTypeScriptProject() ?
-    `import Seeder from 'ilana-orm/orm/Seeder';
-import ${className} from '../../models/${className}';
-import '../factories/${className}Factory';
+    `import Seeder from 'ilana-orm/orm/Seeder.js';
+import ${className} from '../../models/${className}.js';
+import '../factories/${className}Factory.js';
 
 export default class ${className}Seeder extends Seeder {
   async run(): Promise<void> {
@@ -357,7 +357,7 @@ const commands = {
 
 function getESModuleConfigTemplate() {
   return `import 'dotenv/config';
-import Database from 'ilana-orm/database/connection';
+import Database from 'ilana-orm/database/connection.js';
 
 const config = {
   default: process.env.DB_CONNECTION || 'mysql',
@@ -863,7 +863,7 @@ DB_TIMEZONE=UTC
     }
 
     const template = isTypeScriptProject() ?
-      `${modelName ? `import ${modelName} from '../models/${modelName}';\n\n` : ''}export default class ${className}Observer {
+      `${modelName ? `import ${modelName} from '../models/${modelName}.js';\n\n` : ''}export default class ${className}Observer {
   async creating(model: ${modelName || 'any'}): Promise<void> {}
   async created(model: ${modelName || 'any'}): Promise<void> {}
   async updating(model: ${modelName || 'any'}): Promise<void> {}
@@ -911,7 +911,7 @@ module.exports = ${className}Observer;
     }
 
     const template = isTypeScriptProject() ?
-      `import { CustomCast } from 'ilana-orm/orm/Model';
+      `import { CustomCast } from 'ilana-orm/orm/Model.js';
 
 export default class ${className}Cast implements CustomCast {
   get(value: any): any {

package/database/connection.d.ts

@@ -0,0 +1,45 @@
+import { Knex } from 'knex';
+
+export interface DatabaseConfig {
+  default: string;
+  connections: {
+    [name: string]: Knex.Config;
+  };
+  migrations?: {
+    directory?: string;
+    tableName?: string;
+  };
+  seeds?: {
+    directory?: string;
+  };
+}
+
+export interface Transaction extends Knex.Transaction {
+  commit(): Promise<void>;
+  rollback(): Promise<void>;
+}
+
+export default class Database {
+  static connections: Map<string, Knex>;
+  static config: DatabaseConfig;
+  static defaultConnection: string;
+  static instance: Knex;
+  private static _currentTransaction: Knex.Transaction | null;
+
+  static configure(config: DatabaseConfig): void;
+  static connection(name?: string): Knex;
+  static getDefaultConnection(): string;
+  static hasConnection(name: string): boolean;
+  static getInstance(): Knex;
+  static transaction<T>(
+    callback: (trx: Knex.Transaction) => Promise<T>,
+    attempts?: number,
+    connection?: string
+  ): Promise<T>;
+  static beginTransaction(connection?: string): Promise<Transaction>;
+  static commit(trx: Knex.Transaction): Promise<void>;
+  static rollback(trx: Knex.Transaction): Promise<void>;
+  static getCurrentTransaction(): Knex.Transaction | null;
+  static table(tableName: string, connectionName?: string): Knex.QueryBuilder;
+  static raw(sql: string, bindings?: any[]): Knex.Raw;
+}

package/index.d.ts

@@ -0,0 +1,9 @@
+export { default as Model } from './orm/Model';
+export { default as QueryBuilder } from './orm/QueryBuilder';
+export { default as Collection } from './orm/Collection';
+export { default as Database } from './database/connection';
+export * from './orm/Relation';
+export * from './orm/CustomCasts';
+
+// Default export
+export { default } from './orm/Model';

package/orm/Collection.d.ts

@@ -0,0 +1,53 @@
+export default class Collection<T = any> extends Array<T> {
+  constructor(items?: T[]);
+
+  // Static factory methods
+  static make<T>(items?: T[]): Collection<T>;
+  static times<T>(count: number, callback: (index: number) => T): Collection<T>;
+  static range(start: number, end: number): Collection<number>;
+
+  // Collection methods
+  filter(callback: (item: T, index: number) => boolean): Collection<T>;
+  map<U>(callback: (item: T, index: number) => U): Collection<U>;
+  first(): T | undefined;
+  last(): T | undefined;
+  pluck<K extends keyof T>(key: K): Collection<T[K]>;
+  unique(): Collection<T>;
+  unique<K extends keyof T>(key: K): Collection<T>;
+  groupBy<K extends keyof T>(key: K): { [key: string]: Collection<T> };
+  sortBy<K extends keyof T>(key: K): Collection<T>;
+  sortByDesc<K extends keyof T>(key: K): Collection<T>;
+  where<K extends keyof T>(key: K, value: T[K]): Collection<T>;
+  firstWhere<K extends keyof T>(key: K, value: T[K]): T | undefined;
+  sum(): number;
+  sum<K extends keyof T>(key: K): number;
+  avg(): number;
+  avg<K extends keyof T>(key: K): number;
+  min(): T | undefined;
+  min<K extends keyof T>(key: K): T[K] | undefined;
+  max(): T | undefined;
+  max<K extends keyof T>(key: K): T[K] | undefined;
+  chunk(size: number): Collection<Collection<T>>;
+  toJSON(): any[];
+
+  // Advanced collection methods
+  reject(callback: (item: T, index: number) => boolean): Collection<T>;
+  partition(callback: (item: T, index: number) => boolean): [Collection<T>, Collection<T>];
+  keyBy<K extends keyof T>(key: K): { [key: string]: T };
+  countBy<K extends keyof T>(key: K): { [key: string]: number };
+  flatten(): Collection<any>;
+  take(count: number): Collection<T>;
+  skip(count: number): Collection<T>;
+  random(): T | undefined;
+  random(count: number): Collection<T>;
+  shuffle(): Collection<T>;
+  tap(callback: (collection: this) => void): this;
+  pipe<U>(callback: (collection: this) => U): U;
+  whenEmpty(callback: (collection: this) => void): this;
+  whenNotEmpty(callback: (collection: this) => void): this;
+  unless(condition: boolean, callback: (collection: this) => void): this;
+  when(condition: boolean, callback: (collection: this) => void): this;
+  toArray(): T[];
+  isEmpty(): boolean;
+  isNotEmpty(): boolean;
+}

package/orm/CustomCasts.d.ts

@@ -0,0 +1,30 @@
+export interface Cast {
+  get(value: any): any;
+  set(value: any): any;
+}
+
+export class MoneyCast implements Cast {
+  get(value: any): number | null;
+  set(value: any): number | null;
+}
+
+export class EncryptedCast implements Cast {
+  constructor(key?: string);
+  get(value: any): string | null;
+  set(value: any): string | null;
+}
+
+export class JsonCast implements Cast {
+  get(value: any): any;
+  set(value: any): string | null;
+}
+
+export class ArrayCast implements Cast {
+  get(value: any): any[] | null;
+  set(value: any): string | null;
+}
+
+export class DateCast implements Cast {
+  get(value: any): Date | null;
+  set(value: any): string | null;
+}

package/orm/Model.d.ts

@@ -0,0 +1,160 @@
+import QueryBuilder from './QueryBuilder';
+import { HasOne, HasMany, BelongsTo, BelongsToMany, HasManyThrough, MorphTo, MorphMany } from './Relation';
+
+export interface ModelAttributes {
+  [key: string]: any;
+}
+
+export interface ModelCasts {
+  [key: string]: 'string' | 'number' | 'boolean' | 'date' | 'json' | 'array' | 'object' | 'float';
+}
+
+export interface ModelEvents {
+  [event: string]: Array<(model: any) => Promise<boolean | void> | boolean | void>;
+}
+
+export interface Observer {
+  creating?(model: any): Promise<void> | void;
+  created?(model: any): Promise<void> | void;
+  updating?(model: any): Promise<void> | void;
+  updated?(model: any): Promise<void> | void;
+  saving?(model: any): Promise<void> | void;
+  saved?(model: any): Promise<void> | void;
+  deleting?(model: any): Promise<void> | void;
+  deleted?(model: any): Promise<void> | void;
+  restoring?(model: any): Promise<void> | void;
+  restored?(model: any): Promise<void> | void;
+}
+
+export default class Model {
+  // Static properties
+  protected static table: string;
+  protected static connection?: string;
+  protected static primaryKey: string;
+  protected static keyType: 'number' | 'string';
+  protected static incrementing: boolean;
+  protected static timestamps: boolean;
+  protected static softDeletes: boolean;
+  protected static fillable: string[];
+  protected static guarded: string[];
+  protected static casts: ModelCasts;
+  protected static events: ModelEvents;
+  protected static globalScopes: Map<string, (query: QueryBuilder) => void>;
+  protected static appends: string[];
+  protected static timezone: string;
+
+  // Instance properties
+  attributes: ModelAttributes;
+  original: ModelAttributes;
+  relations: { [key: string]: any };
+  exists: boolean;
+  wasRecentlyCreated: boolean;
+  protected _dirty: Set<string>;
+  protected fillable: string[];
+  protected guarded: string[];
+  protected casts: ModelCasts;
+  protected hidden?: string[];
+  protected appends?: string[];
+  protected _deferred?: ModelAttributes;
+
+  constructor(attributes?: ModelAttributes);
+
+  // Static methods
+  static register(): void;
+  static resolveRelatedModel(related: string | typeof Model): typeof Model;
+  static query(): QueryBuilder;
+  static with(...relations: string[]): QueryBuilder;
+  static on(connectionOrTrx: string | any): QueryBuilder;
+  static all(): Promise<Model[]>;
+  static find(id: any): Promise<Model | null>;
+  static findBy(column: string, value: any): Promise<Model | null>;
+  static first(): Promise<Model | null>;
+  static firstOrFail(): Promise<Model>;
+  static latest(column?: string): QueryBuilder;
+  static oldest(column?: string): QueryBuilder;
+  static make(attributes?: ModelAttributes): Model;
+  static create(attributes?: ModelAttributes): Promise<Model>;
+  static generateUuid(): string;
+  static insert(data: ModelAttributes | ModelAttributes[]): Promise<any>;
+  static destroy(ids: any | any[]): Promise<number>;
+  static firstOrCreate(attributes: ModelAttributes, values?: ModelAttributes): Promise<Model>;
+  static firstOrNew(attributes: ModelAttributes, values?: ModelAttributes): Promise<Model>;
+  static updateOrCreate(attributes: ModelAttributes, values?: ModelAttributes): Promise<Model>;
+
+  // Scopes
+  static addGlobalScope(name: string, scope: (query: QueryBuilder) => void): void;
+  static removeGlobalScope(name: string): void;
+  static withoutGlobalScope(name: string): QueryBuilder;
+  static applyGlobalScopes(query: QueryBuilder): void;
+
+  // Events
+  static creating(callback: (model: Model) => Promise<boolean | void> | boolean | void): void;
+  static created(callback: (model: Model) => Promise<boolean | void> | boolean | void): void;
+  static updating(callback: (model: Model) => Promise<boolean | void> | boolean | void): void;
+  static updated(callback: (model: Model) => Promise<boolean | void> | boolean | void): void;
+  static saving(callback: (model: Model) => Promise<boolean | void> | boolean | void): void;
+  static saved(callback: (model: Model) => Promise<boolean | void> | boolean | void): void;
+  static deleting(callback: (model: Model) => Promise<boolean | void> | boolean | void): void;
+  static deleted(callback: (model: Model) => Promise<boolean | void> | boolean | void): void;
+  static restoring(callback: (model: Model) => Promise<boolean | void> | boolean | void): void;
+  static restored(callback: (model: Model) => Promise<boolean | void> | boolean | void): void;
+  static observe(observer: Observer | (new () => Observer)): void;
+  static fireEvent(event: string, model: Model): Promise<boolean>;
+
+  // Table info
+  protected static getTableName(): string;
+  protected static getPrimaryKey(): string;
+  protected static getKeyType(): string;
+  protected static getIncrementing(): boolean;
+  protected static getConnectionName(): string | undefined;
+
+  // Instance methods
+  getKey(): any;
+  fill(attributes: ModelAttributes): this;
+  isFillable(key: string): boolean;
+  getAttribute(key: string): any;
+  setAttribute(key: string, value: any): this;
+  syncOriginal(): void;
+  save(): Promise<boolean>;
+  update(attributes?: ModelAttributes): Promise<boolean>;
+  isDirty(key?: string): boolean;
+  getDirty(): ModelAttributes;
+  delete(): Promise<boolean>;
+  restore(): Promise<boolean>;
+  trashed(): boolean;
+  only(keys: string[]): ModelAttributes;
+  except(keys: string[]): ModelAttributes;
+  forceDelete(): Promise<boolean>;
+  toJSON(): any;
+
+  // Relationships
+  hasOne(related: string | typeof Model, foreignKey?: string, localKey?: string): HasOne;
+  hasMany(related: string | typeof Model, foreignKey?: string, localKey?: string): HasMany;
+  belongsTo(related: string | typeof Model, foreignKey?: string, ownerKey?: string): BelongsTo;
+  belongsToMany(
+    related: string | typeof Model,
+    pivotTable?: string,
+    foreignPivotKey?: string,
+    relatedPivotKey?: string,
+    parentKey?: string,
+    relatedKey?: string
+  ): BelongsToMany;
+  hasManyThrough(
+    related: string | typeof Model,
+    through: string | typeof Model,
+    firstKey?: string,
+    secondKey?: string,
+    localKey?: string,
+    secondLocalKey?: string
+  ): HasManyThrough;
+  morphTo(typeColumn?: string, idColumn?: string): MorphTo;
+  morphMany(related: string | typeof Model, typeColumn?: string, idColumn?: string): MorphMany;
+
+  // Protected methods
+  protected _initialize(): void;
+  protected _createAttributeGetters(): void;
+  protected _getCurrentTimestamp(): Date;
+  protected _getTimezoneOffset(timezone: string, date: Date): number;
+  protected _getConfig(): any;
+  protected _resolveRelatedName(related: string | typeof Model): string;
+}

package/orm/ModelRegistry.d.ts

@@ -0,0 +1,11 @@
+import Model from './Model';
+
+export default class ModelRegistry {
+  private static models: Map<string, typeof Model>;
+
+  static register(name: string, model: typeof Model): void;
+  static get(name: string): typeof Model | undefined;
+  static has(name: string): boolean;
+  static all(): Map<string, typeof Model>;
+  static clear(): void;
+}

package/orm/QueryBuilder.d.ts

@@ -0,0 +1,155 @@
+import Collection from './Collection';
+import Model from './Model';
+
+export interface PaginationResult<T> {
+  data: Collection<T>;
+  total: number;
+  perPage: number;
+  currentPage: number;
+  lastPage: number;
+  from: number | null;
+  to: number | null;
+  nextPage: number | null;
+}
+
+export interface SimplePaginationResult<T> {
+  data: Collection<T>;
+  hasMore: boolean;
+}
+
+export interface CursorPaginationResult<T> {
+  data: Collection<T>;
+  nextCursor?: string;
+  prevCursor?: string;
+  hasNextPage: boolean;
+  hasPrevPage: boolean;
+  path: string;
+  perPage: number;
+}
+
+export default class QueryBuilder {
+  protected query: any;
+  protected modelClass: typeof Model;
+  protected connectionName?: string;
+  protected eagerLoad: string[];
+  protected eagerLoadConstraints: { [key: string]: (query: QueryBuilder) => void };
+  protected _transaction?: any;
+  protected _includeTrashed?: boolean;
+  protected _onlyTrashed?: boolean;
+  protected _withoutTrashed?: boolean;
+
+  constructor(tableName: string, modelClass: typeof Model, connectionName?: string);
+
+  // Where clauses
+  where(column: string, value: any): this;
+  where(column: string, operator: string, value: any): this;
+  orWhere(column: string, value: any): this;
+  orWhere(column: string, operator: string, value: any): this;
+  whereIn(column: string, values: any[]): this;
+  whereNotIn(column: string, values: any[]): this;
+  whereNull(column: string): this;
+  whereNotNull(column: string): this;
+  whereBetween(column: string, range: [any, any]): this;
+  whereJsonContains(column: string, value: any): this;
+  whereJsonLength(column: string, operator: string, value: number): this;
+  whereDate(column: string, value: string): this;
+  whereDate(column: string, operator: string, value: string): this;
+  whereMonth(column: string, month: number): this;
+  whereYear(column: string, year: number): this;
+  whereExists(callback: (query: QueryBuilder) => void): this;
+  when<T>(condition: T, callback: (query: this, condition: T) => void, otherwise?: (query: this) => void): this;
+
+  // Joins
+  join(table: string, first: string, operator: string, second: string): this;
+  leftJoin(table: string, first: string, operator: string, second: string): this;
+  rightJoin(table: string, first: string, operator: string, second: string): this;
+
+  // Ordering and limits
+  orderBy(column: string, direction?: 'asc' | 'desc'): this;
+  latest(column?: string): this;
+  oldest(column?: string): this;
+  limit(count: number): this;
+  offset(count: number): this;
+  take(count: number): this;
+  skip(count: number): this;
+
+  // Grouping
+  groupBy(...columns: string[]): this;
+  having(column: string, operator: string, value: any): this;
+  having(rawSql: string): this;
+
+  // Locking
+  lockForUpdate(): this;
+  sharedLock(): this;
+  skipLocked(): this;
+  noWait(): this;
+
+  // Selection
+  select(...columns: string[]): this;
+  distinct(): this;
+
+  // Raw queries
+  whereRaw(sql: string, bindings?: any[]): this;
+  selectRaw(sql: string, bindings?: any[]): this;
+
+  // Aggregates
+  count(column?: string): Promise<number>;
+  sum(column: string): Promise<number>;
+  avg(column: string): Promise<number>;
+  min(column: string): Promise<any>;
+  max(column: string): Promise<any>;
+
+  // Eager loading
+  with(...relations: string[]): this;
+  withConstraints(relation: string, callback: (query: QueryBuilder) => void): this;
+  withConstraints(relations: { [key: string]: (query: QueryBuilder) => void }): this;
+  withCount(...relations: string[]): this;
+  whereHas(relation: string, callback?: (query: QueryBuilder) => void): this;
+
+  // Execution methods
+  get(): Promise<Collection<Model>>;
+  first(): Promise<Model | null>;
+  find(id: any): Promise<Model | null>;
+  findOrFail(id: any): Promise<Model>;
+  pluck(column: string): Promise<any[]>;
+  exists(): Promise<boolean>;
+
+  // Pagination
+  paginate(page?: number, perPage?: number): Promise<PaginationResult<Model>>;
+  simplePaginate(page?: number, perPage?: number): Promise<SimplePaginationResult<Model>>;
+  cursorPaginate(perPage?: number, cursor?: string, column?: string, direction?: 'asc' | 'desc'): Promise<CursorPaginationResult<Model>>;
+
+  // Chunking
+  chunk(size: number, callback: (models: Collection<Model>) => Promise<void>): Promise<void>;
+  cursor(chunkSize?: number): AsyncGenerator<Model, void, unknown>;
+  lazy(chunkSize?: number): AsyncGenerator<Model, void, unknown>;
+
+  // Insert/Update/Delete
+  insert(data: any | any[]): Promise<any>;
+  insertGetId(data: any): Promise<any>;
+  update(data: any): Promise<number>;
+  delete(): Promise<number>;
+  upsert(data: any[], uniqueBy: string[], update?: string[]): Promise<any>;
+
+  // Connection switching
+  connection(name: string): QueryBuilder;
+  on(connectionOrTrx: string | any): QueryBuilder;
+
+  // Clone query
+  clone(): QueryBuilder;
+
+  // Get underlying Knex query
+  toKnex(): any;
+
+  // Soft delete methods
+  withTrashed(): this;
+  onlyTrashed(): this;
+  withoutTrashed(): this;
+
+  // Debug
+  toSql(): string;
+
+  // Protected methods
+  protected loadRelations(models: Model[]): Promise<void>;
+  protected loadRelation(models: Model[], relationName: string): Promise<void>;
+}

package/orm/Relation.d.ts

@@ -0,0 +1,99 @@
+import QueryBuilder from './QueryBuilder';
+import Model from './Model';
+import Collection from './Collection';
+
+export class Relation {
+  protected parent: Model;
+  protected related: string | typeof Model;
+  protected foreignKey: string;
+  protected localKey: string;
+
+  constructor(parent: Model, related: string | typeof Model, foreignKey: string, localKey?: string);
+
+  getRelatedClass(): typeof Model;
+  newQuery(): QueryBuilder;
+}
+
+export class HasOne extends Relation {
+  addConstraints(): void;
+  getResults(): Promise<Model | null>;
+}
+
+export class HasMany extends Relation {
+  addConstraints(): void;
+  getResults(): Promise<Collection<Model>>;
+}
+
+export class BelongsTo extends Relation {
+  addConstraints(): void;
+  getResults(): Promise<Model | null>;
+}
+
+export class BelongsToMany extends Relation {
+  protected pivotTable: string;
+  protected parentPivotKey: string;
+  protected relatedPivotKey: string;
+  protected parentKey: string;
+  protected relatedKey: string;
+  protected pivotColumns: string[];
+  protected pivotTimestamps: boolean;
+
+  constructor(
+    parent: Model,
+    related: string | typeof Model,
+    pivotTable?: string,
+    foreignPivotKey?: string,
+    relatedPivotKey?: string,
+    parentKey?: string,
+    relatedKey?: string
+  );
+
+  withPivot(...columns: string[]): this;
+  withTimestamps(): this;
+  addConstraints(): void;
+  getResults(): Promise<Model[]>;
+  attach(id: any, attributes?: any): Promise<void>;
+  detach(id?: any): Promise<number>;
+  sync(ids: any[]): Promise<void>;
+}
+
+export class HasManyThrough extends Relation {
+  protected through: string | typeof Model;
+  protected firstKey: string;
+  protected secondKey: string;
+  protected secondLocalKey: string;
+
+  constructor(
+    parent: Model,
+    related: string | typeof Model,
+    through: string | typeof Model,
+    firstKey?: string,
+    secondKey?: string,
+    localKey?: string,
+    secondLocalKey?: string
+  );
+
+  addConstraints(): void;
+  getResults(): Promise<Collection<Model>>;
+}
+
+export class MorphTo extends Relation {
+  protected morphType: string;
+  protected morphId: string;
+
+  constructor(parent: Model, morphType: string, morphId: string);
+
+  addConstraints(): void;
+  getResults(): Promise<Model | null>;
+}
+
+export class MorphMany extends Relation {
+  protected morphType: string;
+  protected morphId: string;
+  protected morphClass: string;
+
+  constructor(parent: Model, related: string | typeof Model, morphType: string, morphId: string, morphClass: string);
+
+  addConstraints(): void;
+  getResults(): Promise<Collection<Model>>;
+}

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "ilana-orm",
-  "version": "1.0.2",
+  "version": "1.0.5",
   "description": "A fully-featured, Eloquent-style ORM for Node.js with TypeScript support",
   "main": "index.js",
+  "types": "index.d.ts",
   "bin": {
     "ilana": "cli/ilana.js"
   },
@@ -38,9 +39,12 @@
   },
   "files": [
     "*.js",
+    "*.d.ts",
     "cli/**/*.js",
     "database/**/*.js",
+    "database/**/*.d.ts",
     "orm/**/*.js",
+    "orm/**/*.d.ts",
     "README.md",
     "LICENSE",
     "ilana.png"
@@ -65,6 +69,9 @@
     "@types/jest": "^29.0.0",
     "ts-jest": "^29.0.0"
   },
+  "peerDependencies": {
+    "@types/node": ">=16.0.0"
+  },
   "engines": {
     "node": ">=16.0.0"
   }