bun-query-builder 0.1.2 → 0.1.5

package/dist/actions/benchmark.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Run performance benchmarks
+ */
+export declare function runBenchmark(options?: BenchmarkOptions): Promise<void>;
+export declare interface BenchmarkOptions {
+  operations?: string
+  iterations?: number
+}

package/dist/actions/cache.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Clear the query cache
+ */
+export declare function cacheClear(): Promise<void>;
+/**
+ * Show cache statistics and configuration
+ *
+ * Note: The current cache implementation doesn't track detailed statistics.
+ * This command shows the current configuration.
+ */
+export declare function cacheStats(): Promise<void>;
+/**
+ * Configure query cache settings
+ */
+export declare function cacheConfig(options?: CacheConfigOptions): Promise<void>;
+export declare interface CacheConfigOptions {
+  size?: number
+}

package/dist/actions/console.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Start an interactive REPL for running queries
+ */
+export declare function startConsole(): Promise<void>;
+/**
+ * Tinker - alias for startConsole
+ */
+export declare function tinker(): Promise<void>;

package/dist/actions/data.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Export data from a table
+ */
+export declare function exportData(tableName: string, options?: ExportOptions): Promise<void>;
+/**
+ * Import data into a table
+ */
+export declare function importData(tableName: string, filePath: string, options?: ImportOptions): Promise<void>;
+/**
+ * Dump database or specific tables to SQL
+ */
+export declare function dumpDatabase(options?: DumpOptions): Promise<void>;
+export declare interface ExportOptions {
+  format?: 'json' | 'csv' | 'sql'
+  output?: string
+  limit?: number
+}
+export declare interface ImportOptions {
+  format?: 'json' | 'csv'
+  truncate?: boolean
+}
+export declare interface DumpOptions {
+  tables?: string
+  output?: string
+}

package/dist/actions/db-info.d.ts

@@ -0,0 +1,22 @@
+import type { SupportedDialect } from '@/types';
+/**
+ * Get database information and statistics
+ */
+export declare function dbInfo(): Promise<DatabaseInfo>;
+/**
+ * Get database statistics (alias for dbInfo)
+ */
+export declare function dbStats(): Promise<DatabaseInfo>;
+export declare interface TableInfo {
+  name: string
+  rowCount: number
+  columns?: number
+  indexes?: number
+}
+export declare interface DatabaseInfo {
+  dialect: SupportedDialect
+  database: string
+  tables: TableInfo[]
+  totalTables: number
+  totalRows: number
+}

package/dist/actions/db-optimize.d.ts

@@ -0,0 +1,12 @@
+import type { SupportedDialect } from '@/types';
+/**
+ * Optimize database tables (VACUUM, ANALYZE, OPTIMIZE)
+ */
+export declare function dbOptimize(options?: OptimizeOptions): Promise<void>;
+export declare interface OptimizeOptions {
+  dialect?: SupportedDialect
+  aggressive?: boolean
+  tables?: string[]
+  verbose?: boolean
+}
+export { dbOptimize as optimizeDatabase };

package/dist/actions/db-wipe.d.ts

@@ -0,0 +1,11 @@
+import type { SupportedDialect } from '@/types';
+/**
+ * Drop all tables in the database
+ */
+export declare function dbWipe(options?: WipeOptions): Promise<void>;
+export declare interface WipeOptions {
+  dialect?: SupportedDialect
+  force?: boolean
+  verbose?: boolean
+}
+export { dbWipe as wipeDatabase };

package/dist/actions/index.d.ts

@@ -1,8 +1,25 @@
+export { runBenchmark } from './benchmark';
+export { cacheClear, cacheConfig, cacheStats } from './cache';
+export { startConsole, tinker } from './console';
+export { dumpDatabase, exportData, importData } from './data';
+export { dbInfo, dbStats } from './db-info';
+export { dbOptimize, optimizeDatabase } from './db-optimize';
+export { dbWipe, wipeDatabase } from './db-wipe';
 export { explain } from './explain';
 export { file } from './file';
+export { inspectTable, tableInfo } from './inspect';
 export { introspect } from './introspect';
-export { executeMigration, generateMigration } from './migrate';
+export { makeModel } from './make-model';
+export { executeMigration, generateMigration, resetDatabase } from './migrate';
+export { migrateGenerate } from './migrate-generate';
+export { migrateRollback } from './migrate-rollback';
+export { migrateList, migrateStatus } from './migrate-status';
+export { modelShow, showModel } from './model-show';
 export { ping } from './ping';
+export { explainAllQueries, queryExplainAll } from './query-explain-all';
+export { generateDiagram, relationDiagram } from './relation-diagram';
+export { freshDatabase, makeSeeder, runSeeder, runSeeders } from './seed';
 export { sql } from './sql';
 export { unsafe } from './unsafe';
+export { checkSchema, validateSchema } from './validate';
 export { waitReady } from './wait-ready';

package/dist/actions/inspect.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Inspect a table's structure, indexes, and statistics
+ */
+export declare function inspectTable(tableName: string, options?: InspectOptions): Promise<TableInspection>;
+/**
+ * Alias for inspectTable
+ */
+export declare function tableInfo(tableName: string, options?: InspectOptions): Promise<TableInspection>;
+export declare interface ColumnInfo {
+  name: string
+  type: string
+  nullable: boolean
+  default: any
+  isPrimaryKey?: boolean
+  isForeignKey?: boolean
+}
+export declare interface IndexInfo {
+  name: string
+  columns: string[]
+  unique: boolean
+}
+export declare interface TableInspection {
+  tableName: string
+  rowCount: number
+  columns: ColumnInfo[]
+  indexes: IndexInfo[]
+}
+export declare interface InspectOptions {
+  verbose?: boolean
+}

package/dist/actions/make-model.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generate a new model file
+ */
+export declare function makeModel(name: string, options?: MakeModelOptions): Promise<void>;
+export declare interface MakeModelOptions {
+  table?: string
+  dir?: string
+  timestamps?: boolean
+}

package/dist/actions/migrate-generate.d.ts

@@ -0,0 +1,6 @@
+import type { GenerateMigrationResult, MigrateOptions } from '@/types';
+/**
+ * Generate migration files from model changes (alias for generateMigration)
+ */
+export declare function migrateGenerate(dir?: string, opts?: MigrateOptions): Promise<GenerateMigrationResult>;
+export { migrateGenerate as generateMigration };

package/dist/actions/migrate-rollback.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Rollback migrations
+ *
+ * Note: This removes migration entries from the migrations table.
+ * Since migrations are auto-generated from models, you should:
+ * 1. Revert your model changes
+ * 2. Run rollback to remove migration records
+ * 3. Generate fresh migrations
+ */
+export declare function migrateRollback(options?: RollbackOptions): Promise<void>;
+export declare interface RollbackOptions {
+  steps?: number
+}

package/dist/actions/migrate-status.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Get migration status - shows which migrations have been executed and which are pending
+ */
+export declare function migrateStatus(): Promise<MigrationStatus[]>;
+/**
+ * List all migrations (alias for status)
+ */
+export declare function migrateList(): Promise<MigrationStatus[]>;
+export declare interface MigrationStatus {
+  file: string
+  status: 'executed' | 'pending' | 'transient'
+  executedAt?: string
+}

package/dist/actions/migrate.d.ts

@@ -1,3 +1,21 @@
-import type { GenerateMigrationResult, MigrateOptions } from '../types';
-export declare function generateMigration(dir: string, opts?: MigrateOptions): Promise<GenerateMigrationResult>;
-export declare function executeMigration(migration: GenerateMigrationResult): Promise<boolean>;
+import type { GenerateMigrationResult, MigrateOptions } from '@/types';
+/**
+ * Generate migration files by comparing old models (from generated/) with new models (from source).
+ *
+ * Workflow:
+ * 1. Loads previous model state from the 'generated/' directory (old model copies)
+ * 2. Loads current models from the source directory
+ * 3. Compares both to detect all changes:
+ *    - Dropped tables, columns, indexes
+ *    - New tables, columns, indexes
+ *    - Modified columns (type changes, etc.)
+ * 4. Generates SQL migration files for all detected changes
+ * 5. Copies current models to 'generated/' for next comparison
+ *
+ * This follows Laravel's migration philosophy where model changes drive schema changes.
+ */
+export declare function generateMigration(dir?: string, opts?: MigrateOptions): Promise<GenerateMigrationResult>;
+export declare function executeMigration(): Promise<boolean>;
+export declare function resetDatabase(dir?: string, opts?: MigrateOptions): Promise<boolean>;
+export declare function deleteMigrationFiles(dir?: string, workspaceRoot?: string, opts?: MigrateOptions): Promise<void>;
+export declare function copyModelsToGenerated(dir?: string, workspaceRoot?: string): Promise<void>;

package/dist/actions/model-show.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Show detailed information about a specific model
+ */
+export declare function modelShow(modelName: string, options?: ModelShowOptions): Promise<ModelDetails | void>;
+export declare interface ModelShowOptions {
+  dir?: string
+  verbose?: boolean
+  json?: boolean
+}
+export declare interface ModelDetails {
+  name: string
+  table: string
+  primaryKey: string
+  attributes: Record<string, any>
+  relations?: Record<string, any>
+  scopes?: Record<string, any>
+  hooks?: string[]
+  indexes?: any[]
+  timestamps?: boolean
+  softDeletes?: boolean
+}
+export { modelShow as showModel };

package/dist/actions/query-explain-all.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Run EXPLAIN on all SQL files in a directory
+ */
+export declare function queryExplainAll(path: string, options?: ExplainAllOptions): Promise<ExplainResult[]>;
+export declare interface ExplainAllOptions {
+  verbose?: boolean
+  json?: boolean
+  format?: 'text' | 'json'
+}
+export declare interface ExplainResult {
+  file: string
+  query: string
+  plan: any[]
+  error?: string
+}
+export { queryExplainAll as explainAllQueries };

package/dist/actions/relation-diagram.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Generate relationship diagram from models
+ */
+export declare function relationDiagram(options?: DiagramOptions): Promise<string>;
+export declare interface DiagramOptions {
+  dir?: string
+  format?: 'mermaid' | 'dot'
+  output?: string
+  verbose?: boolean
+}
+export { relationDiagram as generateDiagram };

package/dist/actions/seed.d.ts

@@ -0,0 +1,18 @@
+import type { RunSeederOptions, SeederConfig } from '@/seeder';
+/**
+ * Run all seeders from a directory
+ */
+export declare function runSeeders(config?: SeederConfig): Promise<void>;
+/**
+ * Run a specific seeder by class name
+ */
+export declare function runSeeder(className: string, options?: RunSeederOptions): Promise<void>;
+/**
+ * Generate a new seeder file
+ */
+export declare function makeSeeder(name: string): Promise<void>;
+/**
+ * Refresh database and run all seeders
+ * This will drop all tables and re-run migrations and seeders
+ */
+export declare function freshDatabase(options?: { seedersDir?: string, modelsDir?: string, verbose?: boolean }): Promise<void>;

package/dist/actions/validate.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Validate that models match the database schema
+ */
+export declare function validateSchema(dir?: string): Promise<ValidationResult>;
+/**
+ * Check schema (alias for validateSchema)
+ */
+export declare function checkSchema(dir?: string): Promise<ValidationResult>;
+export declare interface ValidationIssue {
+  type: 'missing_table' | 'extra_table' | 'missing_column' | 'extra_column' | 'type_mismatch'
+  severity: 'error' | 'warning'
+  table?: string
+  column?: string
+  expected?: string
+  actual?: string
+  message: string
+}
+export declare interface ValidationResult {
+  valid: boolean
+  issues: ValidationIssue[]
+}

package/dist/client.d.ts

@@ -2,6 +2,28 @@ import { config } from './config';
 import type { DatabaseSchema } from './schema';
 import type { SchemaMeta } from './meta';
 export declare function createQueryBuilder<DB extends DatabaseSchema<any>>(state?: Partial<InternalState>): QueryBuilder<DB>;
+/**
+ * # `clearQueryCache()`
+ *
+ * Clears all cached query results.
+ *
+ * @example
+ * ```ts
+ * clearQueryCache()
+ * ```
+ */
+export declare function clearQueryCache(): void;
+/**
+ * # `setQueryCacheMaxSize(size)`
+ *
+ * Sets the maximum number of cached queries (default 100).
+ *
+ * @example
+ * ```ts
+ * setQueryCacheMaxSize(500)
+ * ```
+ */
+export declare function setQueryCacheMaxSize(size: number): void;
 export declare interface WhereRaw {
   raw: any
 }
@@ -80,6 +102,7 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   having: (expr: WhereExpression<any>) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   havingRaw: (fragment: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   addSelect: (...columns: (keyof DB[TTable]['columns'] & string | string)[]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  select?: (columns: (keyof DB[TTable]['columns'] & string | string)[]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   selectAll?: () => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   orderByRaw: (fragment: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   union: (other: { toSQL: () => any }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
@@ -94,6 +117,8 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   whereJsonDoesntContainKey?: (path: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   whereJsonLength?: (path: string, opOrLen: WhereOperator | number, len?: number) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   with?: (...relations: string[]) => SelectQueryBuilder<DB, TTable, TSelected, any>
+  withPivot?: (relation: string, ...columns: string[]) => SelectQueryBuilder<DB, TTable, TSelected, any>
+  applyPivotColumns?: () => SelectQueryBuilder<DB, TTable, TSelected, any>
   lockForUpdate: () => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   sharedLock: () => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   withCTE: (name: string, sub: { toSQL: () => any }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
@@ -153,6 +178,10 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   lazyById: () => AsyncIterable<TSelected>
   pipe: <R>(fn: (qb: SelectQueryBuilder<DB, TTable, TSelected, TJoined>) => R) => R
   count: () => Promise<number>
+  avg: (column: keyof DB[TTable]['columns'] & string) => Promise<number>
+  sum: (column: keyof DB[TTable]['columns'] & string) => Promise<number>
+  max: (column: keyof DB[TTable]['columns'] & string) => Promise<any>
+  min: (column: keyof DB[TTable]['columns'] & string) => Promise<any>
   rows: TSelected[]
   row: TSelected
   values: () => Promise<any[][]>
@@ -163,6 +192,7 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   onlyTrashed?: () => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   scope?: (name: string, value?: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   clone?: () => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  cache?: (ttlMs?: number) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   rowNumber?: (alias?: string, partitionBy?: string | string[], orderBy?: [string, 'asc' | 'desc'][]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   denseRank?: (alias?: string, partitionBy?: string | string[], orderBy?: [string, 'asc' | 'desc'][]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   rank?: (alias?: string, partitionBy?: string | string[], orderBy?: [string, 'asc' | 'desc'][]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
@@ -188,6 +218,12 @@ export declare interface DeleteQueryBuilder<DB extends DatabaseSchema<any>, TTab
   execute: () => Promise<number>
   executeTakeFirst?: () => Promise<{ numDeletedRows?: number }>
 }
+export declare interface TableQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
+  insert: (data: Partial<DB[TTable]['columns']> | Partial<DB[TTable]['columns']>[]) => InsertQueryBuilder<DB, TTable>
+  update: (values: Partial<DB[TTable]['columns']>) => UpdateQueryBuilder<DB, TTable>
+  delete: () => DeleteQueryBuilder<DB, TTable>
+  select: (...columns: (keyof DB[TTable]['columns'] & string)[]) => SelectQueryBuilder<DB, TTable, any>
+}
 export declare interface QueryBuilder<DB extends DatabaseSchema<any>> {
   select: <TTable extends keyof DB & string, K extends keyof DB[TTable]['columns'] & string>(
     table: TTable,
@@ -197,6 +233,7 @@ export declare interface QueryBuilder<DB extends DatabaseSchema<any>> {
   insertInto: <TTable extends keyof DB & string>(table: TTable) => TypedInsertQueryBuilder<DB, TTable>
   updateTable: <TTable extends keyof DB & string>(table: TTable) => UpdateQueryBuilder<DB, TTable>
   deleteFrom: <TTable extends keyof DB & string>(table: TTable) => DeleteQueryBuilder<DB, TTable>
+  table: <TTable extends keyof DB & string>(table: TTable) => TableQueryBuilder<DB, TTable>
   selectFromSub: (sub: { toSQL: () => any }, alias: string) => SelectQueryBuilder<DB, keyof DB & string, any>
   sql: any
   raw: (strings: TemplateStringsArray, ...values: any[]) => any
@@ -237,6 +274,19 @@ export declare interface QueryBuilder<DB extends DatabaseSchema<any>> {
     table: TTable,
     rows: Partial<DB[TTable]['columns']>[],
   ) => Promise<void>
+  insertMany: <TTable extends keyof DB & string>(
+    table: TTable,
+    rows: Partial<DB[TTable]['columns']>[],
+  ) => Promise<void>
+  updateMany: <TTable extends keyof DB & string>(
+    table: TTable,
+    conditions: WhereExpression<DB[TTable]['columns']>,
+    data: Partial<DB[TTable]['columns']>,
+  ) => Promise<number>
+  deleteMany: <TTable extends keyof DB & string>(
+    table: TTable,
+    ids: any[],
+  ) => Promise<number>
   firstOrCreate: <TTable extends keyof DB & string>(
     table: TTable,
     match: Partial<DB[TTable]['columns']>,
@@ -284,6 +334,10 @@ export declare interface QueryBuilder<DB extends DatabaseSchema<any>> {
   ids?: (...names: string[]) => any
   advisoryLock?: (key: number | string) => Promise<void>
   tryAdvisoryLock?: (key: number | string) => Promise<boolean>
+  getRelationships?: (table: string) => Record<string, any>
+  hasRelationship?: (table: string, relationName: string) => boolean
+  getRelationshipType?: (table: string, relationName: string) => string | null
+  getRelationshipTarget?: (table: string, relationName: string) => string | null
 }
 declare interface InternalState {
   sql: any
@@ -424,4 +478,12 @@ export type TypedInsertQueryBuilder<DB extends DatabaseSchema<any>, TTable exten
     `${TSql} RETURNING ${string}`
   >
 }
-declare type TransactionIsolation = 'read committed' | 'repeatable read' | 'serializable'
+declare type TransactionIsolation = 'read committed' | 'repeatable read' | 'serializable'
+declare class QueryCache {
+  private cache: any;
+  private maxSize: any;
+  get(key: string): any | null;
+  set(key: string, data: any, ttlMs: number): void;
+  clear(): void;
+  setMaxSize(size: number): void;
+}

package/dist/db.d.ts

@@ -0,0 +1,11 @@
+import { SQL } from 'bun';
+/**
+ * Returns a Bun SQL instance configured for the current dialect and database settings.
+ * Handles connection errors gracefully by falling back to in-memory SQLite.
+ */
+export declare function getBunSql(): SQL;
+export declare function getOrCreateBunSql(forceNew?: any): SQL;
+// Wrapper that catches "Connection closed" errors and retries with a fresh connection
+export declare function withFreshConnection<T>(fn: (sql: SQL) => Promise<T>): Promise<T>;
+export declare const bunSql: unknown;
+export { SQL } from 'bun';

package/dist/drivers/index.d.ts

@@ -0,0 +1,10 @@
+import { MySQLDriver } from './mysql';
+import { PostgresDriver } from './postgres';
+import { SQLiteDriver } from './sqlite';
+import type { DialectDriver } from './postgres';
+import type { SupportedDialect } from '../types';
+export type { DialectDriver } from './postgres';
+export declare function getDialectDriver(dialect: SupportedDialect): DialectDriver;
+export { MySQLDriver } from './mysql';
+export { PostgresDriver } from './postgres';
+export { SQLiteDriver } from './sqlite';

package/dist/drivers/mysql.d.ts

@@ -0,0 +1,37 @@
+import type { ColumnPlan, IndexPlan, TablePlan } from '../migrations';
+export declare interface DialectDriver {
+  createEnumType: (enumTypeName: string, values: string[]) => string
+  createTable: (table: TablePlan) => string
+  createIndex: (tableName: string, index: IndexPlan) => string
+  addForeignKey: (tableName: string, columnName: string, refTable: string, refColumn: string) => string
+  addColumn: (tableName: string, column: ColumnPlan) => string
+  modifyColumn: (tableName: string, column: ColumnPlan) => string
+  dropTable: (tableName: string) => string
+  dropColumn: (tableName: string, columnName: string) => string
+  dropIndex: (tableName: string, indexName: string) => string
+  dropEnumType: (enumTypeName: string) => string
+  createMigrationsTable: () => string
+  getExecutedMigrationsQuery: () => string
+  recordMigrationQuery: () => string
+}
+export declare class MySQLDriver implements DialectDriver {
+  private quoteIdentifier(id: string): string;
+  private getColumnType(column: ColumnPlan): string;
+  private getPrimaryKeyType(column: ColumnPlan): string;
+  private getAutoIncrementClause(column: ColumnPlan): string;
+  private getDefaultValue(column: ColumnPlan): string;
+  createEnumType(_enumTypeName: string, _values: string[]): string;
+  createTable(table: TablePlan): string;
+  createIndex(tableName: string, index: IndexPlan): string;
+  addForeignKey(tableName: string, columnName: string, refTable: string, refColumn: string): string;
+  addColumn(tableName: string, column: ColumnPlan): string;
+  modifyColumn(tableName: string, column: ColumnPlan): string;
+  dropTable(tableName: string): string;
+  dropColumn(tableName: string, columnName: string): string;
+  dropIndex(tableName: string, indexName: string): string;
+  dropEnumType(_enumTypeName: string): string;
+  createMigrationsTable(): string;
+  getExecutedMigrationsQuery(): string;
+  recordMigrationQuery(): string;
+  private renderColumn(column: ColumnPlan): string;
+}

package/dist/drivers/postgres.d.ts

@@ -0,0 +1,37 @@
+import type { ColumnPlan, IndexPlan, TablePlan } from '../migrations';
+export declare interface DialectDriver {
+  createEnumType: (enumTypeName: string, values: string[]) => string
+  createTable: (table: TablePlan) => string
+  createIndex: (tableName: string, index: IndexPlan) => string
+  addForeignKey: (tableName: string, columnName: string, refTable: string, refColumn: string) => string
+  addColumn: (tableName: string, column: ColumnPlan) => string
+  modifyColumn: (tableName: string, column: ColumnPlan) => string
+  dropTable: (tableName: string) => string
+  dropColumn: (tableName: string, columnName: string) => string
+  dropIndex: (tableName: string, indexName: string) => string
+  dropEnumType: (enumTypeName: string) => string
+  createMigrationsTable: () => string
+  getExecutedMigrationsQuery: () => string
+  recordMigrationQuery: () => string
+}
+export declare class PostgresDriver implements DialectDriver {
+  private quoteIdentifier(id: string): string;
+  private getColumnType(column: ColumnPlan): string;
+  private getPrimaryKeyType(column: ColumnPlan): string;
+  private getAutoIncrementClause(_column: ColumnPlan): string;
+  private getDefaultValue(column: ColumnPlan): string;
+  createEnumType(enumTypeName: string, values: string[]): string;
+  createTable(table: TablePlan): string;
+  createIndex(tableName: string, index: IndexPlan): string;
+  addForeignKey(tableName: string, columnName: string, refTable: string, refColumn: string): string;
+  addColumn(tableName: string, column: ColumnPlan): string;
+  modifyColumn(tableName: string, column: ColumnPlan): string;
+  dropTable(tableName: string): string;
+  dropColumn(tableName: string, columnName: string): string;
+  dropIndex(tableName: string, indexName: string): string;
+  dropEnumType(enumTypeName: string): string;
+  createMigrationsTable(): string;
+  getExecutedMigrationsQuery(): string;
+  recordMigrationQuery(): string;
+  private renderColumn(column: ColumnPlan): string;
+}

package/dist/drivers/sqlite.d.ts

@@ -0,0 +1,37 @@
+import type { ColumnPlan, IndexPlan, TablePlan } from '../migrations';
+export declare interface DialectDriver {
+  createEnumType: (enumTypeName: string, values: string[]) => string
+  createTable: (table: TablePlan) => string
+  createIndex: (tableName: string, index: IndexPlan) => string
+  addForeignKey: (tableName: string, columnName: string, refTable: string, refColumn: string) => string
+  addColumn: (tableName: string, column: ColumnPlan) => string
+  modifyColumn: (tableName: string, column: ColumnPlan) => string
+  dropTable: (tableName: string) => string
+  dropColumn: (tableName: string, columnName: string) => string
+  dropIndex: (tableName: string, indexName: string) => string
+  dropEnumType: (enumTypeName: string) => string
+  createMigrationsTable: () => string
+  getExecutedMigrationsQuery: () => string
+  recordMigrationQuery: () => string
+}
+export declare class SQLiteDriver implements DialectDriver {
+  private quoteIdentifier(id: string): string;
+  private getColumnType(column: ColumnPlan): string;
+  private getPrimaryKeyType(column: ColumnPlan): string;
+  private getAutoIncrementClause(column: ColumnPlan): string;
+  private getDefaultValue(column: ColumnPlan): string;
+  createEnumType(_enumTypeName: string, _values: string[]): string;
+  createTable(table: TablePlan): string;
+  createIndex(tableName: string, index: IndexPlan): string;
+  addForeignKey(tableName: string, columnName: string, refTable: string, refColumn: string): string;
+  addColumn(tableName: string, column: ColumnPlan): string;
+  modifyColumn(tableName: string, column: ColumnPlan): string;
+  dropTable(tableName: string): string;
+  dropColumn(tableName: string, columnName: string): string;
+  dropIndex(tableName: string, indexName: string): string;
+  dropEnumType(_enumTypeName: string): string;
+  createMigrationsTable(): string;
+  getExecutedMigrationsQuery(): string;
+  recordMigrationQuery(): string;
+  private renderColumn(column: ColumnPlan): string;
+}

package/dist/index.d.ts

@@ -1,9 +1,11 @@
 export * from './actions';
 export * from './client';
 export * from './config';
+export * from './drivers';
 export * from './factory';
 export * from './loader';
 export * from './meta';
 export * from './migrations';
 export * from './schema';
+export * from './seeder';
 export * from './types';