@depup/typeorm-extension 3.9.0-depup.0 → 4.0.0-depup.0

package/dist/index.d.mts

@@ -0,0 +1,1456 @@
+import { DataSource, DataSourceOptions, EntityMetadata, EntitySchema, EntityTarget, Migration, ObjectLiteral, ObjectType, QueryRunner, Repository, SaveOptions, SelectQueryBuilder } from "typeorm";
+import { CompilerOptions, TypeAcquisition } from "typescript";
+import { DatabaseType } from "typeorm/driver/types/DatabaseType.js";
+//#region src/errors/base.d.ts
+declare class TypeormExtensionError extends Error {}
+//#endregion
+//#region src/errors/driver.d.ts
+declare class DriverError extends TypeormExtensionError {
+  constructor(message?: string);
+  static undeterminable(): DriverError;
+  static notSupported(driverName: string): DriverError;
+  static schemaAlterationNotSupported(driverName: string): DriverError;
+  static columnConversionExpressionNotSupported(driverName: string): DriverError;
+  static columnGenerationExpressionUnknown(columnName: string): DriverError;
+  static connectionClosed(): DriverError;
+  static databaseNotFound(database: string): DriverError;
+}
+//#endregion
+//#region src/errors/entity-metadata.d.ts
+declare class EntityMetadataError extends TypeormExtensionError {
+  constructor(message?: string);
+  static notRegistered(name: string): EntityMetadataError;
+}
+//#endregion
+//#region src/errors/entity-relation-lookup.d.ts
+type EntityRelationLookupErrorOptions = {
+  message: string;
+  relation: string;
+  columns: string[];
+};
+declare class EntityRelationLookupError extends TypeormExtensionError {
+  /**
+   * The property name of the relation.
+   */
+  relation: string;
+  /**
+   * The property names of the join columns.
+   */
+  columns: string[];
+  constructor(options: EntityRelationLookupErrorOptions);
+  static notReferenced(relation: string, columns: string[]): EntityRelationLookupError;
+  static notFound(relation: string, columns: string[]): EntityRelationLookupError;
+}
+//#endregion
+//#region src/errors/options.d.ts
+declare class OptionsError extends TypeormExtensionError {
+  constructor(message?: string);
+  static undeterminable(): OptionsError;
+  static notFound(): OptionsError;
+  static databaseNotDefined(): OptionsError;
+}
+//#endregion
+//#region src/database/schema/drift/type.d.ts
+/**
+ * A single reconciling statement, in the shape typeorm's schema builder emits it.
+ */
+type SchemaDriftStatement = {
+  query: string;
+  parameters?: unknown[];
+};
+/**
+ * The difference between the database schema and the entity metadata.
+ *
+ * The up statements would reconcile the database schema with the entity metadata,
+ * the down statements would revert that reconciliation.
+ */
+type SchemaDrift = {
+  /**
+   * Whether the database schema deviates from the entity metadata.
+   */
+  exists: boolean;
+  up: SchemaDriftStatement[];
+  down: SchemaDriftStatement[];
+};
+type SchemaDriftOptions = {
+  /**
+   * Report no drift if the data source has no migrations registered.
+   *
+   * Useful for a data source which is shared between a migration driven
+   * environment (postgres, mysql, ...) and a synchronize driven one
+   * (e.g. an in-memory sqlite test database wired with `migrations: []`).
+   *
+   * default: false
+   */
+  skipWithoutMigrations?: boolean;
+};
+//#endregion
+//#region src/errors/schema.d.ts
+declare class SchemaDriftError extends TypeormExtensionError {
+  /**
+   * The statements which would reconcile the database schema
+   * with the entity metadata.
+   */
+  readonly statements: SchemaDriftStatement[];
+  constructor(statements?: SchemaDriftStatement[], message?: string);
+  static detected(statements: SchemaDriftStatement[]): SchemaDriftError;
+}
+//#endregion
+//#region src/errors/schema-alteration.d.ts
+/**
+ * The database is in neither the state the alteration expects nor the one it
+ * would produce, so there is nothing it can safely do.
+ *
+ * Raised instead of returning quietly, because a repair migration which does
+ * not repair anything is indistinguishable from a successful one — the guard
+ * exists to make a run resumable, not to swallow a wrong description of the
+ * database.
+ */
+declare class SchemaAlterationError extends TypeormExtensionError {
+  static tableNotFound(table: string): SchemaAlterationError;
+  static columnNotFound(table: string, column: string): SchemaAlterationError;
+  static columnMismatch(table: string, column: string): SchemaAlterationError;
+  static indexNotFound(table: string, name: string): SchemaAlterationError;
+  static foreignKeyNotFound(table: string, name: string): SchemaAlterationError;
+}
+//#endregion
+//#region src/database/core/type.d.ts
+/**
+ * A connection against a database server (never a TypeORM DataSource).
+ *
+ * execute() takes a statement in the server's native language:
+ * SQL text for SQL speaking servers, a JSON encoded command document
+ * for mongodb (executed via db.command()).
+ *
+ * Lifecycle: open() performs the handshake once — concurrent and repeated
+ * calls share the same attempt — and is optional, since execute() opens
+ * the connection on demand. close() is terminal: a closed connection cannot
+ * be reopened, and closing a never-opened connection is a no-op.
+ */
+interface IDatabaseConnection {
+  open(): Promise<void>;
+  execute(statement: string): Promise<unknown>;
+  close(): Promise<void>;
+}
+/**
+ * Factory for database server connections.
+ *
+ * create() is cheap — no I/O happens before open().
+ * The optional database argument overrides the connection's target database
+ * (e.g. the initial database, or a freshly created database). When omitted,
+ * the server side default (maintenance database) is used.
+ */
+interface IDatabaseConnectionFactory {
+  create(database?: string): IDatabaseConnection;
+}
+/**
+ * Filesystem effects for file backed databases (better-sqlite3).
+ */
+interface IFileSystem {
+  assertDirectoryWritable(path: string): Promise<void>;
+  /**
+   * Whether the file exists and is writable.
+   * A missing file yields false; any other failure propagates.
+   */
+  isFileWritable(path: string): Promise<boolean>;
+  /**
+   * Create an empty file. Fails when the file already exists.
+   */
+  createFile(path: string): Promise<void>;
+  /**
+   * Remove the file. Returns false when it did not exist;
+   * any other failure propagates.
+   */
+  removeFile(path: string): Promise<boolean>;
+}
+/**
+ * Dialect neutral connection facts, derived once per operation
+ * from the resolved DataSourceOptions.
+ */
+type ConnectionParams = {
+  database?: string;
+  host?: string;
+  user?: string;
+  password?: string;
+  port?: number;
+  ssl?: unknown;
+  url?: string;
+  connectString?: string;
+  sid?: string | number;
+  serviceName?: string;
+  domain?: string;
+  /**
+   * Driver specific connection options which are not connection facts of their
+   * own, e.g. the tedious `options` object of the mssql driver
+   * (encrypt, trustServerCertificate, instanceName, ...).
+   */
+  driverOptions?: Record<string, any>;
+  charset?: string;
+  characterSet?: string;
+  schema?: string;
+  template?: string;
+  extra?: Record<string, any>;
+};
+type DatabaseCreateOperation = {
+  params: ConnectionParams;
+  ifNotExist: boolean;
+  initialDatabase?: string;
+};
+type DatabaseDropOperation = {
+  params: ConnectionParams;
+  ifExist: boolean;
+  initialDatabase?: string;
+};
+/**
+ * A dialect owns the create/drop orchestration for one driver type and
+ * receives its connection factory (or filesystem) via the constructor.
+ *
+ * Implementations must stay pure: types, typed errors and pure helpers only —
+ * no native clients, no I/O, no environment state.
+ */
+interface IDatabaseDialect {
+  create(operation: DatabaseCreateOperation): Promise<unknown>;
+  drop(operation: DatabaseDropOperation): Promise<unknown>;
+}
+type DatabaseDialectName = 'postgres' | 'cockroachdb' | 'mysql' | 'mssql' | 'oracle' | 'mongodb' | 'better-sqlite3';
+/**
+ * Composition overrides for building a dialect —
+ * used by tests and the caller supplied connection escape hatch.
+ * Only the slot a dialect actually consumes has an effect.
+ */
+type DatabaseDialectOverrides = {
+  connectionFactory?: IDatabaseConnectionFactory;
+  fs?: IFileSystem;
+  cwd?: string;
+};
+type DatabaseDialectRegistryEntry = {
+  buildParams: (options: DataSourceOptions) => ConnectionParams;
+  buildDialect: (options: DataSourceOptions, params: ConnectionParams, overrides: DatabaseDialectOverrides) => IDatabaseDialect;
+};
+//#endregion
+//#region src/database/core/cockroachdb/module.d.ts
+declare class CockroachDBDialect implements IDatabaseDialect {
+  protected connectionFactory: IDatabaseConnectionFactory;
+  constructor(connectionFactory: IDatabaseConnectionFactory);
+  create(operation: DatabaseCreateOperation): Promise<unknown>;
+  drop(operation: DatabaseDropOperation): Promise<unknown>;
+}
+//#endregion
+//#region src/database/core/cockroachdb/statements.d.ts
+/**
+ * @link https://github.com/typeorm/typeorm/blob/master/src/driver/cockroachdb/CockroachQueryRunner.ts#L347
+ *
+ * The double space after the IF NOT EXISTS clause is preserved
+ * from the previous implementation.
+ */
+declare function buildCockroachDBCreateDatabaseQuery(database: string, ifNotExist: boolean): string;
+/**
+ * @link https://github.com/typeorm/typeorm/blob/master/src/driver/cockroachdb/CockroachQueryRunner.ts#L356
+ */
+declare function buildCockroachDBDropDatabaseQuery(database: string, ifExist: boolean): string;
+//#endregion
+//#region src/database/core/mongodb/module.d.ts
+declare class MongoDBDialect implements IDatabaseDialect {
+  protected connectionFactory: IDatabaseConnectionFactory;
+  constructor(connectionFactory: IDatabaseConnectionFactory);
+  /**
+   * Connecting to the target database creates it lazily server side.
+   */
+  create(operation: DatabaseCreateOperation): Promise<unknown>;
+  drop(operation: DatabaseDropOperation): Promise<unknown>;
+}
+//#endregion
+//#region src/database/core/mongodb/statements.d.ts
+/**
+ * MongoDB statements are JSON encoded command documents,
+ * executed via db.command() by the adapter.
+ *
+ * @link https://www.mongodb.com/docs/manual/reference/command/dropDatabase/
+ */
+declare function buildMongoDBDropDatabaseCommand(): string;
+//#endregion
+//#region src/database/core/mongodb/uri.d.ts
+declare function buildMongoDBConnectionUri(params: ConnectionParams, database?: string): string;
+//#endregion
+//#region src/database/core/mssql/module.d.ts
+declare class MsSQLDialect implements IDatabaseDialect {
+  protected connectionFactory: IDatabaseConnectionFactory;
+  constructor(connectionFactory: IDatabaseConnectionFactory);
+  create(operation: DatabaseCreateOperation): Promise<unknown>;
+  drop(operation: DatabaseDropOperation): Promise<unknown>;
+}
+//#endregion
+//#region src/database/core/mssql/statements.d.ts
+/**
+ * @link https://github.com/typeorm/typeorm/blob/master/src/driver/sqlserver/SqlServerQueryRunner.ts#L416
+ *
+ * NOTE: the previous implementation appended a `CHARACTER SET` clause,
+ * which is not valid T-SQL (SQL Server uses `COLLATE <collation_name>`).
+ * The clause was removed; a proper collation option is future work.
+ */
+declare function buildMsSQLCreateDatabaseQuery(params: ConnectionParams, ifNotExist: boolean): string;
+/**
+ * @link https://github.com/typeorm/typeorm/blob/master/src/driver/sqlserver/SqlServerQueryRunner.ts#L425
+ */
+declare function buildMsSQLDropDatabaseQuery(database: string, ifExist: boolean): string;
+//#endregion
+//#region src/database/core/mysql/module.d.ts
+/**
+ * Serves mysql AND mariadb.
+ */
+declare class MySQLDialect implements IDatabaseDialect {
+  protected connectionFactory: IDatabaseConnectionFactory;
+  constructor(connectionFactory: IDatabaseConnectionFactory);
+  create(operation: DatabaseCreateOperation): Promise<unknown>;
+  drop(operation: DatabaseDropOperation): Promise<unknown>;
+}
+//#endregion
+//#region src/database/core/mysql/statements.d.ts
+declare const MYSQL_FOREIGN_KEY_CHECKS_OFF = "SET FOREIGN_KEY_CHECKS=0;";
+declare const MYSQL_FOREIGN_KEY_CHECKS_ON = "SET FOREIGN_KEY_CHECKS=1;";
+declare const MYSQL_FOREIGN_KEY_CHECKS_SELECT = "SELECT @@SESSION.foreign_key_checks AS `value`;";
+/**
+ * Infer the CHARACTER SET from a collation (charset) when it is not
+ * explicitly configured, e.g. utf8mb4_general_ci -> utf8mb4.
+ */
+declare function deriveMySQLCharacterSet(charset: string, characterSet?: string): string | undefined;
+/**
+ * @link https://github.com/typeorm/typeorm/blob/master/src/driver/mysql/MysqlQueryRunner.ts#L297
+ */
+declare function buildMySQLCreateDatabaseQuery(params: ConnectionParams, ifNotExist: boolean): string;
+/**
+ * @link https://github.com/typeorm/typeorm/blob/master/src/driver/mysql/MysqlQueryRunner.ts#L306
+ */
+declare function buildMySQLDropDatabaseQuery(database: string, ifExist: boolean): string;
+//#endregion
+//#region src/database/core/oracle/module.d.ts
+declare class OracleDialect implements IDatabaseDialect {
+  protected connectionFactory: IDatabaseConnectionFactory;
+  constructor(connectionFactory: IDatabaseConnectionFactory);
+  create(operation: DatabaseCreateOperation): Promise<unknown>;
+  /**
+   * Dropping a database is not supported for oracle
+   * (preserved behaviour of the previous implementation).
+   */
+  drop(_operation: DatabaseDropOperation): Promise<unknown>;
+}
+//#endregion
+//#region src/database/core/oracle/statements.d.ts
+/**
+ * Assemble the TNS connect descriptor when none is configured.
+ */
+declare function buildOracleConnectString(params: ConnectionParams): string;
+/**
+ * @link https://github.com/typeorm/typeorm/blob/master/src/driver/oracle/OracleQueryRunner.ts#L295
+ *
+ * NOTE: IF NOT EXISTS is not valid Oracle SQL. The statement is preserved
+ * byte-for-byte from the previous implementation for fidelity — changing
+ * it is a semantic decision, not a refactor side effect.
+ */
+declare function buildOracleCreateDatabaseQuery(database: string): string;
+//#endregion
+//#region src/database/core/params.d.ts
+declare function buildConnectionParams(options: DataSourceOptions): ConnectionParams;
+//#endregion
+//#region src/database/core/postgres/module.d.ts
+declare class PostgresDialect implements IDatabaseDialect {
+  protected connectionFactory: IDatabaseConnectionFactory;
+  constructor(connectionFactory: IDatabaseConnectionFactory);
+  create(operation: DatabaseCreateOperation): Promise<unknown>;
+  drop(operation: DatabaseDropOperation): Promise<unknown>;
+}
+//#endregion
+//#region src/database/core/postgres/statements.d.ts
+declare function buildPostgresDatabaseExistsQuery(database: string): string;
+/**
+ * @link https://github.com/typeorm/typeorm/blob/master/src/driver/postgres/PostgresQueryRunner.ts#L326
+ */
+declare function buildPostgresCreateDatabaseQuery(params: ConnectionParams): string;
+declare function buildPostgresCreateSchemaQuery(schema: string): string;
+/**
+ * @link https://github.com/typeorm/typeorm/blob/master/src/driver/postgres/PostgresQueryRunner.ts#L343
+ */
+declare function buildPostgresDropDatabaseQuery(database: string, ifExist: boolean): string;
+//#endregion
+//#region src/database/core/sqlite/module.d.ts
+/**
+ * better-sqlite3 never opens a server connection —
+ * create/drop are filesystem effects following SQL database semantics:
+ * create produces the file (or fails when it exists, unless ifNotExist),
+ * drop removes it (or fails when it is missing, unless ifExist).
+ */
+declare class SQLiteDialect implements IDatabaseDialect {
+  protected fs: IFileSystem;
+  protected cwd: string;
+  constructor(fs: IFileSystem, cwd: string);
+  create(operation: DatabaseCreateOperation): Promise<unknown>;
+  drop(operation: DatabaseDropOperation): Promise<unknown>;
+}
+//#endregion
+//#region src/database/core/sqlite/path.d.ts
+declare function resolveSQLiteDatabasePath(database: string, cwd: string): string;
+declare function resolveSQLiteDatabaseDirectory(database: string, cwd: string): string;
+//#endregion
+//#region src/database/core/utils.d.ts
+declare function hasResultRows(input: unknown): boolean;
+//#endregion
+//#region src/database/methods/check/types.d.ts
+type DatabaseCheckContext = {
+  /**
+   * Options for finding the typeorm DataSource.
+   *
+   * Default: undefined
+   */
+  options?: DataSourceOptions;
+  /**
+   * Use alias to access already registered DataSource / DataSourceOptions.
+   *
+   * default: undefined
+   */
+  alias?: string;
+  /**
+   * Indicates whether to destroy the data-source
+   * afterward or not.
+   * If a datasource previously existed, this option will be ignored.
+   *
+   * default: true
+   */
+  dataSourceCleanup?: boolean;
+  /**
+   * Use predefined data-source for checks.
+   *
+   * default: undefined
+   */
+  dataSource?: DataSource;
+};
+type DatabaseCheckResult = {
+  /**
+   * Indicates whether the database
+   * has already been created or not.
+   *
+   * default: false
+   */
+  exists: boolean;
+  /**
+   * Indicates whether the database's schema
+   * is up-to-date.
+   *
+   * default: false
+   */
+  schema: boolean;
+  /**
+   * Array of un applied migrations.
+   *
+   * default: []
+   */
+  migrationsPending: Migration[];
+};
+//#endregion
+//#region src/database/methods/check/module.d.ts
+/**
+ * Check database setup progress.
+ *
+ * @param context
+ */
+declare function checkDatabase(context?: DatabaseCheckContext): Promise<DatabaseCheckResult>;
+//#endregion
+//#region src/utils/tsconfig/type.d.ts
+type StripEnums<T extends Record<string, any>> = { [K in keyof T]: T[K] extends boolean ? T[K] : T[K] extends string ? T[K] : T[K] extends object ? T[K] : T[K] extends Array<any> ? T[K] : T[K] extends undefined ? undefined : any; };
+interface TSConfig {
+  compilerOptions?: StripEnums<CompilerOptions>;
+  exclude?: string[];
+  compileOnSave?: boolean;
+  extends?: string;
+  files?: string[];
+  include?: string[];
+  typeAcquisition?: TypeAcquisition;
+}
+//#endregion
+//#region src/utils/tsconfig/module.d.ts
+declare function readTSConfig(input?: string): Promise<TSConfig>;
+//#endregion
+//#region src/data-source/find/type.d.ts
+type DataSourceFindOptions = {
+  /**
+   * Directory where to look for DataSource files.
+   */
+  directory?: string;
+  /**
+   * DataSource file name.
+   */
+  fileName?: string;
+  /**
+   * This option indicates if file paths should be preserved,
+   * and treated as if the just-in-time compilation environment is detected.
+   */
+  preserveFilePaths?: boolean;
+  /**
+   * Directory path to the tsconfig.json file
+   *
+   * Default: process.cwd() + path.sep + tsconfig.json
+   */
+  tsconfig?: string | TSConfig;
+};
+//#endregion
+//#region src/data-source/find/module.d.ts
+declare function findDataSource(context?: DataSourceFindOptions): Promise<DataSource | undefined>;
+//#endregion
+//#region src/data-source/options/type.d.ts
+type DataSourceOptionsBuildContext = {
+  /**
+   * Data source file name without extension
+   *
+   * Default: data-source
+   */
+  dataSourceName?: string;
+  /**
+   * Directory where to find dataSource + config
+   *
+   * Default: process.cwd()
+   */
+  directory?: string;
+  /**
+   * Directory path to the tsconfig.json file
+   *
+   * Default: process.cwd() + path.sep + tsconfig.json
+   */
+  tsconfig?: string | TSConfig;
+  /**
+   * This option indicates if file paths should be preserved,
+   * and treated as if the just-in-time compilation environment is detected.
+   */
+  preserveFilePaths?: boolean;
+};
+//#endregion
+//#region src/data-source/options/module.d.ts
+/**
+ * Build DataSourceOptions from DataSource or from configuration.
+ *
+ * @param context
+ */
+declare function buildDataSourceOptions(context?: DataSourceOptionsBuildContext): Promise<DataSourceOptions>;
+//#endregion
+//#region src/data-source/options/singleton.d.ts
+declare function setDataSourceOptions(options: DataSourceOptions, alias?: string): void;
+declare function hasDataSourceOptions(alias?: string): boolean;
+declare function useDataSourceOptions(alias?: string): Promise<DataSourceOptions>;
+//#endregion
+//#region src/data-source/options/utils/env.d.ts
+declare function hasEnvDataSourceOptions(): boolean;
+declare function readDataSourceOptionsFromEnv(): DataSourceOptions | undefined;
+declare function mergeDataSourceOptionsWithEnv(options: DataSourceOptions): DataSourceOptions;
+//#endregion
+//#region src/data-source/options/utils/merge.d.ts
+declare function mergeDataSourceOptions(target: DataSourceOptions, source: DataSourceOptions): DataSourceOptions;
+//#endregion
+//#region src/data-source/singleton.d.ts
+declare function setDataSource(dataSource: DataSource, alias?: string): void;
+declare function hasDataSource(alias?: string): boolean;
+declare function unsetDataSource(alias?: string): void;
+declare function useDataSource(alias?: string): Promise<DataSource>;
+//#endregion
+//#region src/data-source/type.d.ts
+type DataSourceCacheOption = DataSourceOptions['cache'];
+//#endregion
+//#region src/database/methods/type.d.ts
+type DatabaseBaseContext = {
+  /**
+   * Options for finding the typeorm DataSource.
+   */
+  options: DataSourceOptions;
+  /**
+   * Options for the find method, where to look for the data-source file.
+   */
+  findOptions?: DataSourceFindOptions;
+  /**
+   * Initial database to connect.
+   *
+   * default: undefined
+   */
+  initialDatabase?: string;
+  /**
+   * Caller supplied server-level connection.
+   * It is treated as already open, and the caller owns its lifecycle —
+   * the library never opens or closes it.
+   *
+   * default: undefined
+   */
+  connection?: Pick<IDatabaseConnection, 'execute'>;
+};
+type DatabaseBaseContextInput = Partial<DatabaseBaseContext>;
+type DatabaseCreateContext = Omit<DatabaseBaseContext, 'findOptions'> & {
+  /**
+   * Only create database if not already exist.
+   *
+   * default: true
+   */
+  ifNotExist: boolean;
+  /**
+   * Synchronize or migrate the database scheme.
+   *
+   * default: true
+   */
+  synchronize: boolean;
+};
+type DatabaseCreateContextInput = Partial<DatabaseCreateContext>;
+type DatabaseDropContext = Omit<DatabaseBaseContext, 'findOptions'> & {
+  /**
+   * Only drop database if existed.
+   *
+   * Default: true
+   */
+  ifExist?: boolean;
+};
+type DatabaseDropContextInput = Partial<DatabaseDropContext>;
+//#endregion
+//#region src/database/methods/create/module.d.ts
+/**
+ * Create database for specified driver in ConnectionOptions.
+ *
+ * @throws DriverError
+ * @throws OptionsError
+ *
+ * @param input
+ */
+declare function createDatabase(input?: DatabaseCreateContextInput): Promise<unknown>;
+//#endregion
+//#region src/database/methods/drop/module.d.ts
+/**
+ * Drop database for specified driver in ConnectionOptions.
+ *
+ * @throws DriverError
+ * @throws OptionsError
+ *
+ * @param input
+ */
+declare function dropDatabase(input?: DatabaseDropContextInput): Promise<unknown>;
+//#endregion
+//#region src/database/driver/cockroachdb.d.ts
+/**
+ * @deprecated Use createDatabase() instead — dialect dispatch is automatic.
+ */
+declare function createCockroachDBDatabase(input?: DatabaseCreateContextInput): Promise<unknown>;
+/**
+ * @deprecated Use dropDatabase() instead — dialect dispatch is automatic.
+ */
+declare function dropCockroachDBDatabase(input?: DatabaseDropContextInput): Promise<unknown>;
+//#endregion
+//#region src/database/driver/mongodb.d.ts
+/**
+ * @deprecated Use createDatabase() instead — dialect dispatch is automatic.
+ */
+declare function createMongoDBDatabase(input?: DatabaseCreateContextInput): Promise<unknown>;
+/**
+ * @deprecated Use dropDatabase() instead — dialect dispatch is automatic.
+ */
+declare function dropMongoDBDatabase(input?: DatabaseDropContextInput): Promise<unknown>;
+//#endregion
+//#region src/database/driver/mssql.d.ts
+/**
+ * @deprecated Use createDatabase() instead — dialect dispatch is automatic.
+ */
+declare function createMsSQLDatabase(input?: DatabaseCreateContextInput): Promise<unknown>;
+/**
+ * @deprecated Use dropDatabase() instead — dialect dispatch is automatic.
+ */
+declare function dropMsSQLDatabase(input?: DatabaseDropContextInput): Promise<unknown>;
+//#endregion
+//#region src/database/driver/mysql.d.ts
+/**
+ * @deprecated Use createDatabase() instead — dialect dispatch is automatic.
+ */
+declare function createMySQLDatabase(input?: DatabaseCreateContextInput): Promise<unknown>;
+/**
+ * @deprecated Use dropDatabase() instead — dialect dispatch is automatic.
+ */
+declare function dropMySQLDatabase(input?: DatabaseDropContextInput): Promise<unknown>;
+//#endregion
+//#region src/database/driver/oracle.d.ts
+/**
+ * @deprecated Use createDatabase() instead — dialect dispatch is automatic.
+ */
+declare function createOracleDatabase(input?: DatabaseCreateContextInput): Promise<unknown>;
+/**
+ * @deprecated Use dropDatabase() instead — dialect dispatch is automatic.
+ */
+declare function dropOracleDatabase(input?: DatabaseDropContextInput): Promise<unknown>;
+//#endregion
+//#region src/database/driver/postgres.d.ts
+/**
+ * @deprecated Use createDatabase() instead — dialect dispatch is automatic.
+ */
+declare function createPostgresDatabase(input?: DatabaseCreateContextInput): Promise<unknown>;
+/**
+ * @deprecated Use dropDatabase() instead — dialect dispatch is automatic.
+ */
+declare function dropPostgresDatabase(input?: DatabaseDropContextInput): Promise<unknown>;
+//#endregion
+//#region src/database/driver/sqlite.d.ts
+/**
+ * @deprecated Use createDatabase() instead — dialect dispatch is automatic.
+ */
+declare function createSQLiteDatabase(input?: DatabaseCreateContextInput): Promise<unknown>;
+/**
+ * @deprecated Use dropDatabase() instead — dialect dispatch is automatic.
+ */
+declare function dropSQLiteDatabase(input?: DatabaseDropContextInput): Promise<unknown>;
+//#endregion
+//#region src/database/schema/alter/checks.d.ts
+/**
+ * Run a callback with the mysql/mariadb foreign key checks disabled and restore
+ * the previous state afterwards (nesting safe). A no-op wrapper on every other
+ * driver, so a migration using it stays portable.
+ *
+ * Re-adding a constraint which was already enforcing does not need to be
+ * re-validated — the check only buys a full table scan, plus a failure mode for
+ * rows some past import inserted with the checks off.
+ */
+declare function withForeignKeyChecksDisabled<T>(queryRunner: QueryRunner, fn: () => Promise<T>): Promise<T>;
+//#endregion
+//#region src/database/schema/alter/type.d.ts
+/**
+ * Every guarded alteration takes it: raise a `SchemaAlterationError` when the
+ * database is in neither the expected nor the desired state, rather than
+ * returning `false` and leaving a repair migration to report success without
+ * having repaired anything.
+ *
+ * Being already in the desired state is never an error — that is what keeps a
+ * run resumable, and it returns `false` in both modes.
+ *
+ * @default true
+ */
+type SchemaStrictInput = {
+  strict?: boolean;
+};
+type SchemaRenameIndexInput = SchemaStrictInput & {
+  /**
+   * Table name, optionally schema qualified (e.g. `public.user`).
+   */
+  table: string;
+  /**
+   * Current index name.
+   */
+  from: string;
+  /**
+   * Desired index name.
+   */
+  to: string;
+};
+/**
+ * What a foreign key constraint consists of, beyond its name.
+ */
+type SchemaForeignKeyMeta = {
+  columns: string[];
+  referencedTable: string;
+  referencedColumns: string[];
+  onDelete?: string;
+  onUpdate?: string;
+};
+type SchemaRenameForeignKeyInput = SchemaStrictInput & {
+  /**
+   * Table name, optionally schema qualified (e.g. `public.user`).
+   */
+  table: string;
+  /**
+   * Current constraint name.
+   */
+  from: string;
+  /**
+   * Desired constraint name.
+   */
+  to: string;
+  /**
+   * Used to re-create the constraint when neither `from` nor `to` exists —
+   * the state a run interrupted between the drop and the re-add leaves behind
+   * on mysql, where it can no longer be read back from the database.
+   *
+   * Ignored while `from` still exists: the normal path always describes the
+   * constraint from the database, so a rename can not silently change it.
+   */
+  meta?: SchemaForeignKeyMeta;
+};
+type SchemaColumnType = {
+  type: string;
+  length?: string | number;
+  /**
+   * Only compared/applied if defined.
+   */
+  nullable?: boolean;
+};
+type SchemaChangeColumnTypeInput = SchemaStrictInput & {
+  /**
+   * Table name, optionally schema qualified (e.g. `public.user`).
+   */
+  table: string;
+  column: string;
+  /**
+   * The column type expected to be present. The helper is a no-op if the
+   * column does not match it (e.g. because it is already migrated).
+   */
+  from: SchemaColumnType;
+  to: SchemaColumnType;
+  /**
+   * postgres/cockroachdb only — raw SQL computing the new value from the old
+   * one, e.g. `client_id::uuid`.
+   *
+   * `ALTER COLUMN ... TYPE` converts the values with the assignment cast
+   * between the two types, and refuses the change when there is none. Pass an
+   * expression to describe the conversion in that case; without one, postgres
+   * rejects the statement rather than touching the data.
+   *
+   * Raises a `DriverError` on a dialect which has no counterpart, rather than
+   * ignoring it and leaving the server to coerce the values its own way.
+   */
+  using?: string;
+};
+//#endregion
+//#region src/database/schema/alter/columns.d.ts
+/**
+ * Change the type (and optionally the nullability) of a column, but only if it
+ * still matches the `from` description.
+ *
+ * Returns false when the column already matches `to`, which keeps a repair
+ * migration resumable and safe to run against a database which never had the
+ * drift. When the column matches neither description (or is missing) the
+ * database is not in a state this can act on, and `strict` (the default)
+ * raises a `SchemaAlterationError` rather than reporting a repair which did
+ * not happen.
+ *
+ * The column is altered in place, so it keeps the values it holds. That is the
+ * reason the statement is built here: typeorm's `changeColumn` drops and
+ * re-adds the column as soon as the type or the length differs, which empties
+ * it. Drivers this module has no dialect for still go through typeorm — safe
+ * on sqlite, which recreates the table and copies the values over.
+ *
+ * Widening a column a foreign key depends on additionally needs
+ * {@see withForeignKeyChecksDisabled} on mysql, and is refused outright by
+ * mariadb — there the constraint has to be dropped around the change.
+ *
+ * postgres converts the values with the assignment cast between the two types
+ * and refuses a change which has none; pass `using` to describe the conversion
+ * for those.
+ *
+ * @throws SchemaAlterationError if the column matches neither description and
+ *         `strict`.
+ */
+declare function changeColumnType(queryRunner: QueryRunner, input: SchemaChangeColumnTypeInput): Promise<boolean>;
+//#endregion
+//#region src/database/schema/alter/foreign-keys.d.ts
+/**
+ * Rename a foreign key constraint, preserving its columns, its referenced
+ * table/columns and its referential actions — all of which are read back from
+ * the database, so the rename can not silently change the constraint.
+ *
+ * postgres renames the constraint in place, mysql has to drop and re-add it
+ * (with the foreign key checks disabled, since the constraint was already
+ * enforcing) and to take care of the backing index it may have created under
+ * the constraint name.
+ *
+ * Returns false when a constraint is already named `to`, which keeps a repair
+ * migration resumable. If neither name exists — the state an interrupted mysql
+ * rename leaves behind, where the constraint took its own description with it —
+ * the passed `meta` is used to restore it; without it `strict` (the default)
+ * raises a `SchemaAlterationError`, since there is nothing left to rename.
+ *
+ * @throws DriverError for a driver which can not express the rename.
+ * @throws SchemaAlterationError if neither name exists (and no `meta` describes
+ *         the constraint) and `strict`.
+ */
+declare function renameForeignKey(queryRunner: QueryRunner, input: SchemaRenameForeignKeyInput): Promise<boolean>;
+//#endregion
+//#region src/database/schema/alter/indices.d.ts
+/**
+ * Rename an index.
+ *
+ * Returns false when an index is already named `to` — that is what keeps a
+ * repair migration resumable, since mysql commits DDL regardless of the
+ * surrounding transaction.
+ *
+ * When neither name is present (or the table is missing) the database is not
+ * in a state this can act on, and `strict` (the default) raises a
+ * `SchemaAlterationError` rather than reporting a repair which did not happen.
+ *
+ * Note that an index which backs a constraint is not reported as an index by
+ * the driver: a unique constraint on postgres lives in `table.uniques`, and a
+ * foreign key's backing index on mysql only becomes visible once the constraint
+ * is dropped (see renameForeignKey).
+ *
+ * @throws DriverError for a driver which can not express the rename.
+ * @throws SchemaAlterationError if neither name exists and `strict`.
+ */
+declare function renameIndex(queryRunner: QueryRunner, input: SchemaRenameIndexInput): Promise<boolean>;
+//#endregion
+//#region src/database/schema/drift/module.d.ts
+/**
+ * Compare the database schema against the entity metadata and return the
+ * statements which would reconcile the former with the latter.
+ *
+ * A schema which is built by migrations in production but by synchronize()
+ * in tests has no guard against the two descriptions drifting apart. Run this
+ * right after the migrations to close that gap:
+ *
+ * ```ts
+ * const drift = await getSchemaDrift(dataSource);
+ * if (drift.exists) {
+ *     console.log(drift.up.map((statement) => statement.query));
+ * }
+ * ```
+ *
+ * The inspection itself never writes to the database. A data source built from
+ * the passed options is therefore built with `synchronize`, `migrationsRun` and
+ * `dropSchema` disabled, and an uninitialized DataSource which has any of them
+ * enabled is left untouched and inspected through an own instance — otherwise
+ * initializing it would mutate (or drop) the very schema being inspected.
+ */
+declare function getSchemaDrift(input: DataSource | DataSourceOptions, options?: SchemaDriftOptions): Promise<SchemaDrift>;
+/**
+ * Throw if the database schema deviates from the entity metadata.
+ *
+ * @throws SchemaDriftError
+ */
+declare function assertSchemaMatchesMetadata(input: DataSource | DataSourceOptions, options?: SchemaDriftOptions): Promise<void>;
+//#endregion
+//#region src/database/schema/synchronize.d.ts
+declare function synchronizeDatabaseSchema(input: DataSource | DataSourceOptions): Promise<Migration[]>;
+//#endregion
+//#region src/database/utils/context.d.ts
+declare function buildDatabaseCreateContext(input?: DatabaseCreateContextInput): Promise<DatabaseCreateContext>;
+declare function buildDatabaseDropContext(input?: DatabaseDropContextInput): Promise<DatabaseDropContext>;
+//#endregion
+//#region src/database/utils/type.d.ts
+type MigrationGenerateResult = {
+  up: string[];
+  down: string[];
+  content?: string;
+};
+type MigrationGenerateCommandContext = {
+  /**
+   * Directory where the migration(s) should be stored.
+   */
+  directoryPath?: string;
+  /**
+   * Name of the migration class.
+   */
+  name?: string;
+  /**
+   * DataSource used for reference of existing schema.
+   */
+  dataSource: DataSource;
+  /**
+   * Timestamp in milliseconds.
+   */
+  timestamp?: number;
+  /**
+   * Prettify sql statements.
+   */
+  prettify?: boolean;
+  /**
+   * Only return up- & down-statements instead of backing up the migration to the file system.
+   */
+  preview?: boolean;
+};
+//#endregion
+//#region src/database/utils/migration.d.ts
+declare function generateMigration(context: MigrationGenerateCommandContext): Promise<MigrationGenerateResult>;
+//#endregion
+//#region src/database/utils/query.d.ts
+declare function existsQuery<T extends ObjectLiteral = ObjectLiteral>(builder: SelectQueryBuilder<T>, inverse?: boolean): string;
+//#endregion
+//#region src/env/constants.d.ts
+declare enum EnvironmentName {
+  DEVELOPMENT = "development",
+  PRODUCTION = "production",
+  TEST = "test"
+}
+declare enum EnvironmentVariableName {
+  ENV = "NODE_ENV",
+  SEEDS = "DB_SEEDS",
+  SEEDS_ALT = "TYPEORM_SEEDING_SEEDS",
+  FACTORIES = "DB_FACTORIES",
+  FACTORIES_ALT = "TYPEORM_SEEDING_FACTORIES",
+  TYPE = "DB_TYPE",
+  TYPE_ALT = "TYPEORM_CONNECTION",
+  URL = "DB_URL",
+  URL_ALT = "TYPEORM_URL",
+  HOST = "DB_HOST",
+  HOST_ALT = "TYPEORM_HOST",
+  PORT = "DB_PORT",
+  PORT_ALT = "TYPEORM_PORT",
+  USERNAME = "DB_USERNAME",
+  USERNAME_ALT = "TYPEORM_USERNAME",
+  PASSWORD = "DB_PASSWORD",
+  PASSWORD_ALT = "TYPEORM_PASSWORD",
+  DATABASE = "DB_DATABASE",
+  DATABASE_ALT = "TYPEORM_DATABASE",
+  SID = "DB_SID",
+  SID_ALT = "TYPEORM_SID",
+  SCHEMA = "DB_SCHEMA",
+  SCHEMA_ALT = "TYPEORM_SCHEMA",
+  SCHEMA_DROP = "DB_DROP_SCHEMA",
+  SCHEMA_DROP_ALT = "TYPEORM_DROP_SCHEMA",
+  DRIVER_EXTRA = "DB_DRIVER_EXTRA",
+  DRIVER_EXTRA_ALT = "TYPEORM_DRIVER_EXTRA",
+  SYNCHRONIZE = "DB_SYNCHRONIZE",
+  SYNCHRONIZE_ALT = "TYPEORM_SYNCHRONIZE",
+  MIGRATIONS = "DB_MIGRATIONS",
+  MIGRATIONS_ALT = "TYPEORM_MIGRATIONS",
+  MIGRATIONS_RUN = "DB_MIGRATIONS_RUN",
+  MIGRATIONS_RUN_ALT = "TYPEORM_MIGRATIONS_RUN",
+  MIGRATIONS_TABLE_NAME = "DB_MIGRATIONS_TABLE_NAME",
+  MIGRATIONS_TABLE_NAME_ALT = "TYPEORM_MIGRATIONS_TABLE_NAME",
+  ENTITIES = "DB_ENTITIES",
+  ENTITIES_ALT = "TYPEORM_ENTITIES",
+  ENTITY_PREFIX = "DB_ENTITY_PREFIX",
+  ENTITY_PREFIX_ALT = "TYPEORM_ENTITY_PREFIX",
+  METADATA_TABLE_NAME = "DB_METADATA_TABLE_NAME",
+  METADATA_TABLE_NAME_ALT = "TYPEORM_METADATA_TABLE_NAME",
+  SUBSCRIBERS = "DB_SUBSCRIBERS",
+  SUBSCRIBERS_ALT = "TYPEORM_SUBSCRIBERS",
+  LOGGING = "DB_LOGGING",
+  LOGGING_ALT = "TYPEORM_LOGGING",
+  LOGGER = "DB_LOGGER",
+  LOGGER_ALT = "TYPEORM_LOGGER",
+  MAX_QUERY_EXECUTION_TIME = "DB_MAX_QUERY_EXECUTION_TIME",
+  MAX_QUERY_EXECUTION_TIME_ALT = "TYPEORM_MAX_QUERY_EXECUTION_TIME",
+  DEBUG = "DB_DEBUG",
+  DEBUG_ALT = "TYPEORM_DEBUG",
+  UUID_EXTENSION = "DB_UUID_EXTENSION",
+  UUID_EXTENSION_ALT = "TYPEORM_UUID_EXTENSION",
+  CACHE = "DB_CACHE",
+  CACHE_ALT = "TYPEORM_CACHE",
+  CACHE_ALWAYS_ENABLED = "DB_CACHE_ALWAYS_ENABLED",
+  CACHE_ALWAYS_ENABLED_ALT = "TYPEORM_CACHE_ALWAYS_ENABLED",
+  CACHE_OPTIONS = "DB_CACHE_OPTIONS",
+  CACHE_OPTIONS_ALT = "TYPEORM_CACHE_OPTIONS",
+  CACHE_DURATION = "DB_CACHE_DURATION",
+  CACHE_DURATION_ALT = "TYPEORM_CACHE_DURATION"
+}
+//#endregion
+//#region src/env/type.d.ts
+interface Environment {
+  env: `${EnvironmentName}`;
+  seeds: string[];
+  factories: string[];
+  type?: DatabaseType;
+  url?: string;
+  host?: string;
+  port?: number;
+  username?: string;
+  password?: string;
+  database?: string;
+  sid?: string;
+  schema?: string;
+  /**
+   * dropSchema
+   */
+  schemaDrop?: boolean;
+  extra?: any;
+  synchronize?: boolean;
+  migrations: string[];
+  migrationsRun?: boolean;
+  migrationsTableName?: string;
+  entities: string[];
+  entityPrefix?: string;
+  metadataTableName?: string;
+  subscribers: string[];
+  logging: string[] | boolean | string;
+  logger?: string;
+  maxQueryExecutionTime?: number;
+  debug?: string;
+  cache?: DataSourceCacheOption;
+  uuidExtension?: string;
+}
+//#endregion
+//#region src/env/module.d.ts
+declare function useEnv(): Environment;
+declare function useEnv<K extends keyof Environment>(key: K): Environment[K];
+declare function resetEnv(): void;
+//#endregion
+//#region src/helpers/entity/name.d.ts
+declare function getEntityName<O>(entity: ObjectType<O> | EntitySchema<O> | string): string;
+//#endregion
+//#region src/helpers/entity/property-names.d.ts
+/**
+ * Get (relation-) property names of a given entity.
+ *
+ * @experimental
+ * @param input
+ * @param dataSource
+ */
+declare function getEntityPropertyNames<T extends ObjectLiteral>(input: EntityTarget<T> | Repository<T>, dataSource?: DataSource): Promise<string[]>;
+//#endregion
+//#region src/helpers/entity/metadata.d.ts
+/**
+ * Receive metadata for a given repository or entity-target.
+ *
+ * @experimental
+ * @param input
+ * @param dataSource
+ */
+declare function getEntityMetadata<T extends ObjectLiteral>(input: Repository<T> | EntityTarget<T>, dataSource?: DataSource): Promise<EntityMetadata>;
+//#endregion
+//#region src/helpers/entity/join-columns.d.ts
+type EntityRelationColumnsValidateOptions<T> = {
+  dataSource?: DataSource;
+  entityTarget: EntityTarget<T>;
+};
+/**
+ * Validate join columns of a given entity.
+ * It will look up and append the referenced entities to the input entity.
+ *
+ * @experimental
+ * @param entity
+ * @param options
+ */
+declare function validateEntityJoinColumns<T extends ObjectLiteral>(entity: Partial<T>, options: EntityRelationColumnsValidateOptions<T>): Promise<Partial<T>>;
+//#endregion
+//#region src/helpers/entity/uniqueness.d.ts
+type EntityUniquenessCheckOptions<T> = {
+  /**
+   * Repository entity class.
+   */
+  entityTarget: EntityTarget<T>;
+  /**
+   * Entity to insert/update.
+   */
+  entity: Partial<T>;
+  /**
+   * Entity found.
+   */
+  entityExisting?: Partial<T> | null;
+  /**
+   * DataSource to use
+   */
+  dataSource?: DataSource;
+};
+/**
+ * Check if a given entity does not already exist.
+ * Composite unique keys on a null column can only be present once.
+ *
+ * @experimental
+ * @param options
+ */
+declare function isEntityUnique<T extends ObjectLiteral>(options: EntityUniquenessCheckOptions<T>): Promise<boolean>;
+//#endregion
+//#region src/seeder/factory/type.d.ts
+/**
+ * The meta argument is undefined, as long as SeederFactory.setMeta() was not called.
+ */
+type FactoryCallback<O, Meta = unknown> = (meta: Meta | undefined) => O | Promise<O>;
+type SeederFactoryItem = {
+  factoryFn: FactoryCallback<any, any>;
+  entity: ObjectType<any> | EntitySchema<any>;
+};
+type SeederFactoryContext<O, Meta = unknown> = {
+  name: string;
+  entity: ObjectType<O> | EntitySchema<O>;
+  factoryFn: FactoryCallback<O, Meta>;
+  dataSource?: DataSource;
+};
+type SeederFactoryManagerContext = {
+  items?: Record<string, SeederFactoryItem>;
+  dataSource?: DataSource;
+};
+//#endregion
+//#region src/seeder/factory/module.d.ts
+declare class SeederFactory<O extends Record<string, any>, Meta = unknown> {
+  readonly context: SeederFactoryContext<O, Meta>;
+  meta: Meta | undefined;
+  constructor(context: SeederFactoryContext<O, Meta>);
+  setMeta(value: Meta): this;
+  make(params?: Partial<O>, save?: boolean): Promise<O>;
+  save(params?: Partial<O>, options?: SaveOptions): Promise<O>;
+  saveMany(amount: number, params?: Partial<O>, options?: SaveOptions): Promise<O[]>;
+  private resolve;
+}
+//#endregion
+//#region src/seeder/factory/manager.d.ts
+declare class SeederFactoryManager {
+  readonly items: Record<string, SeederFactoryItem>;
+  readonly dataSource: DataSource | undefined;
+  constructor(context?: SeederFactoryManagerContext);
+  set<O extends Record<string, any>, Meta = unknown>(entity: ObjectType<O> | EntitySchema<O>, factoryFn: FactoryCallback<O, Meta>): SeederFactoryItem;
+  get<O extends Record<string, any>, Meta = unknown>(entity: ObjectType<O> | EntitySchema<O>): SeederFactory<O, Meta>;
+}
+//#endregion
+//#region src/seeder/factory/utils.d.ts
+declare function useSeederFactoryManager(): SeederFactoryManager;
+declare function resetSeederFactoryManager(): void;
+declare function setSeederFactory<O extends Record<string, any>, Meta = unknown>(entity: ObjectType<O> | EntitySchema<O>, factoryFn: FactoryCallback<O, Meta>): SeederFactoryItem;
+declare function useSeederFactory<O extends Record<string, any>, Meta = unknown>(entity: ObjectType<O> | EntitySchema<O>): SeederFactory<O, Meta>;
+declare function prepareSeederFactories(items: SeederFactoryItem[] | string[], root?: string): Promise<void>;
+//#endregion
+//#region src/seeder/type.d.ts
+interface Seeder {
+  /**
+   * Track seeder execution.
+   *
+   * Default: false
+   */
+  track?: boolean;
+  run(dataSource: DataSource, factoryManager: SeederFactoryManager): Promise<any>;
+}
+type SeederConstructor = new () => Seeder;
+type SeederOptions = {
+  seeds?: SeederConstructor[] | string[];
+  seedName?: string;
+  seedTableName?: string;
+  seedTracking?: boolean;
+  factories?: SeederFactoryItem[] | string[];
+};
+/**
+ * A fully resolved seeder configuration
+ * (explicit input ← data-source options ← environment ← built-in defaults).
+ */
+type SeederConfig = {
+  seeds: SeederConstructor[] | string[];
+  seedName?: string;
+  seedTableName: string;
+  seedTracking: boolean;
+  factories: SeederFactoryItem[] | string[];
+};
+type SeederExecutorOptions = {
+  /**
+   * Root directory of the project.
+   */
+  root?: string;
+  /**
+   * Directory path to the tsconfig.json file
+   *
+   * Default: process.cwd() + path.sep + tsconfig.json
+   */
+  tsconfig?: string | TSConfig;
+  /**
+   * This option indicates if file paths should be preserved,
+   * and treated as if the just-in-time compilation environment is detected.
+   */
+  preserveFilePaths?: boolean;
+};
+type SeederPrepareElement = {
+  constructor: SeederConstructor;
+  timestamp?: number;
+  fileName?: string;
+  filePath?: string;
+};
+//#endregion
+//#region src/seeder/config.d.ts
+declare function resolveSeederConfig(input?: SeederOptions, dataSourceOptions?: SeederOptions, env?: Pick<Environment, 'seeds' | 'factories'>): SeederConfig;
+//#endregion
+//#region src/seeder/entity.d.ts
+declare class SeederEntity {
+  /**
+   * ID of the seeder.
+   *
+   * Indicates order of the executed seeders.
+   */
+  id?: number;
+  /**
+   * Timestamp of the seeder.
+   */
+  timestamp: number;
+  /**
+   * Name of the seeder (class name).
+   */
+  name: string;
+  /**
+   * Instance of seeder constructor.
+   */
+  instance?: Seeder;
+  /**
+   * File name of the seeder.
+   */
+  fileName?: string;
+  /**
+   * File path of the seeder.
+   */
+  filePath?: string;
+  /**
+   * Result of the executed seeder.
+   */
+  result?: unknown;
+  constructor(ctx: {
+    id?: number;
+    timestamp: number;
+    name: string;
+    constructor?: SeederConstructor;
+    fileName?: string;
+    filePath?: string;
+  });
+  get trackExecution(): boolean | undefined;
+  /**
+   * Decide whether this seeder's execution should be tracked.
+   * The per-seed track property wins over the executor-level default.
+   */
+  effectiveTracking(fallback: boolean): boolean;
+  /**
+   * Execution-order comparator:
+   * by file name when both entities are file-backed, by timestamp otherwise.
+   */
+  static compare(a: SeederEntity, b: SeederEntity): number;
+}
+//#endregion
+//#region src/utils/code-transformation/constants.d.ts
+declare enum CodeTransformation {
+  JUST_IN_TIME = "jit",
+  NONE = "none"
+}
+//#endregion
+//#region src/utils/code-transformation/module.d.ts
+declare function detectCodeTransformation(): `${CodeTransformation}`;
+declare function isCodeTransformation(input: string): boolean;
+//#endregion
+//#region src/utils/file-path.d.ts
+declare function transformFilePath(input: string, dist?: string, src?: string): string;
+declare function resolveFilePath(filePath: string, root?: string): string;
+declare function parseFilePath(filePath: string, root?: string): {
+  directory: string;
+  name: string;
+};
+//#endregion
+//#region src/utils/file-system.d.ts
+declare function isDirectory(input: string): Promise<boolean>;
+//#endregion
+//#region src/utils/has-property.d.ts
+declare function hasOwnProperty<X extends Record<string, any>, Y extends PropertyKey>(obj: X, prop: Y): obj is X & Record<Y, unknown>;
+declare function hasStringProperty<X extends Record<string, any>, Y extends PropertyKey>(obj: X, prop: Y): obj is X & Record<Y, string>;
+//#endregion
+//#region src/utils/object.d.ts
+declare function pickRecord(data: Record<string, any>, keys: string[]): Record<string, any>;
+declare function extendObject<T extends Record<string, any>>(target: T, source: Partial<T>): T;
+declare function isObject(item: unknown): item is Record<string, any>;
+//#endregion
+//#region src/utils/path-resolver/constants.d.ts
+declare enum PathResolverMode {
+  AUTO = "auto",
+  PRESERVE = "preserve",
+  TRANSFORM = "transform"
+}
+//#endregion
+//#region src/utils/path-resolver/helpers/adjust-file-path.d.ts
+declare function adjustFilePath<T extends unknown | unknown[]>(input: T, tsconfig?: string | TSConfig): Promise<T>;
+//#endregion
+//#region src/utils/path-resolver/helpers/adjust-file-paths.d.ts
+declare function adjustFilePaths<T extends Record<string, any>>(input: T, keys?: (keyof T)[], tsconfig?: string | TSConfig): Promise<T>;
+//#endregion
+//#region src/utils/path-resolver/type.d.ts
+type PathResolverOptions = {
+  /**
+   * Root directory against which relative paths are absolutized.
+   *
+   * Default: process.cwd()
+   */
+  root?: string;
+  /**
+   * Tsconfig object or path to the tsconfig file,
+   * resolved against the root directory.
+   *
+   * Default: tsconfig.json
+   */
+  tsconfig?: string | TSConfig;
+  /**
+   * preserve: never rewrite paths.
+   * transform: always rewrite paths (src -> outDir, .ts -> .js).
+   * auto: rewrite unless a just-in-time environment (e.g. ts-node, tsx) is detected.
+   *
+   * Default: auto
+   */
+  mode?: `${PathResolverMode}`;
+};
+interface IPathResolver {
+  /**
+   * Absolutize a path against the root directory.
+   */
+  absolutize(input: string): string;
+  /**
+   * Rewrite a path for the runtime environment (src -> outDir, .ts -> .js),
+   * depending on the resolver mode.
+   */
+  transform(input: string): Promise<string>;
+  /**
+   * Transform the (string or string-array) values of the given keys in place.
+   */
+  transformKeys<T extends Record<string, any>>(input: T, keys?: (keyof T)[]): Promise<T>;
+  /**
+   * Absolutize and transform a path.
+   */
+  resolve(input: string): Promise<string>;
+  /**
+   * The lazily read tsconfig backing the transformation.
+   */
+  tsconfig(): Promise<TSConfig>;
+}
+//#endregion
+//#region src/utils/path-resolver/module.d.ts
+declare class PathResolver implements IPathResolver {
+  protected root?: string;
+  protected mode: `${PathResolverMode}`;
+  protected tsconfigInput?: string | TSConfig;
+  protected tsconfigPromise?: Promise<TSConfig>;
+  constructor(options?: PathResolverOptions);
+  absolutize(input: string): string;
+  resolve(input: string): Promise<string>;
+  transform(input: string): Promise<string>;
+  transformKeys<T extends Record<string, any>>(input: T, keys?: (keyof T)[]): Promise<T>;
+  tsconfig(): Promise<TSConfig>;
+  protected readTsconfig(): Promise<TSConfig>;
+  protected shouldTransform(): boolean;
+}
+declare function createPathResolver(options?: PathResolverOptions): IPathResolver;
+//#endregion
+//#region src/utils/promise.d.ts
+declare function isPromise(p: unknown): p is Promise<unknown>;
+//#endregion
+//#region src/utils/separator.d.ts
+declare function canReplaceWindowsSeparator(input: string): boolean;
+declare function replaceWindowSeparator(input: string): string;
+declare function safeReplaceWindowsSeparator(input: string): string;
+//#endregion
+//#region src/utils/slash.d.ts
+declare function hasTrailingSlash(input?: string, queryParams?: boolean): boolean;
+declare function withoutTrailingSlash(input?: string, queryParams?: boolean): string;
+//#endregion
+//#region src/seeder/executor.d.ts
+declare class SeederExecutor {
+  protected dataSource: DataSource;
+  protected options: SeederExecutorOptions;
+  protected pathResolver: IPathResolver;
+  constructor(dataSource: DataSource, options?: SeederExecutorOptions);
+  execute(input?: SeederOptions): Promise<SeederEntity[]>;
+  protected resolveConfig(input?: SeederOptions): Promise<SeederConfig>;
+  protected loadEntities(config: SeederConfig): Promise<SeederEntity[]>;
+  protected filterPending(all: SeederEntity[], existing: SeederEntity[], config: SeederConfig): SeederEntity[];
+  protected isMatch(seed: SeederEntity, config: SeederConfig): boolean;
+  protected runPending(pending: SeederEntity[], config: SeederConfig, queryRunner?: QueryRunner): Promise<SeederEntity[]>;
+  protected loadExisting(queryRunner: QueryRunner, tableName: string): Promise<SeederEntity[]>;
+  protected buildEntities(seeds?: SeederPrepareElement[]): Promise<SeederEntity[]>;
+  protected checkForDuplicates(entities: SeederEntity[]): void;
+  protected createTableIfNotExist(queryRunner: QueryRunner, tableName: string): Promise<void>;
+  protected track(queryRunner: QueryRunner, seederEntity: SeederEntity, tableName: string): Promise<void>;
+  protected get dataSourceOptions(): DataSourceOptions & SeederOptions;
+  protected get database(): string | undefined;
+  protected get schema(): string | undefined;
+  protected buildTableName(tableName: string): string;
+  protected classNameToTimestamp(className: string): number | undefined;
+}
+//#endregion
+//#region src/seeder/module.d.ts
+declare function runSeeder(dataSource: DataSource, seeder: SeederConstructor | string, options?: SeederOptions): Promise<SeederEntity | undefined>;
+declare function runSeeders(dataSource: DataSource, options?: SeederOptions): Promise<SeederEntity[]>;
+//#endregion
+//#region src/seeder/utils/file-name.d.ts
+declare function buildSeederFileName(name: string, timestamp: number, options?: {
+  javascript?: boolean;
+}): string;
+//#endregion
+//#region src/seeder/utils/file-path.d.ts
+declare function resolveFilePatterns(filesPattern: string[], root?: string): Promise<string[]>;
+declare function resolveFilePaths(filePaths: string[], root?: string): string[];
+//#endregion
+//#region src/seeder/utils/prepare.d.ts
+declare function prepareSeederSeeds(input: SeederConstructor[] | string[], root?: string): Promise<SeederPrepareElement[]>;
+//#endregion
+//#region src/seeder/utils/template.d.ts
+declare function buildSeederFileTemplate(name: string, timestamp: number): string;
+//#endregion
+export { CockroachDBDialect, CodeTransformation, ConnectionParams, DataSourceCacheOption, DataSourceFindOptions, DataSourceOptionsBuildContext, DatabaseBaseContext, DatabaseBaseContextInput, DatabaseCheckContext, DatabaseCheckResult, DatabaseCreateContext, DatabaseCreateContextInput, DatabaseCreateOperation, DatabaseDialectName, DatabaseDialectOverrides, DatabaseDialectRegistryEntry, DatabaseDropContext, DatabaseDropContextInput, DatabaseDropOperation, DriverError, EntityMetadataError, EntityRelationLookupError, Environment, EnvironmentName, EnvironmentVariableName, FactoryCallback, IDatabaseConnection, IDatabaseConnectionFactory, IDatabaseDialect, IFileSystem, IPathResolver, MYSQL_FOREIGN_KEY_CHECKS_OFF, MYSQL_FOREIGN_KEY_CHECKS_ON, MYSQL_FOREIGN_KEY_CHECKS_SELECT, MigrationGenerateCommandContext, MigrationGenerateResult, MongoDBDialect, MsSQLDialect, MySQLDialect, OptionsError, OracleDialect, PathResolver, PathResolverMode, PathResolverOptions, PostgresDialect, SQLiteDialect, SchemaAlterationError, type SchemaChangeColumnTypeInput, type SchemaColumnType, SchemaDrift, SchemaDriftError, SchemaDriftOptions, SchemaDriftStatement, type SchemaForeignKeyMeta, type SchemaRenameForeignKeyInput, type SchemaRenameIndexInput, type SchemaStrictInput, Seeder, SeederConfig, SeederConstructor, SeederEntity, SeederExecutor, SeederExecutorOptions, SeederFactory, SeederFactoryContext, SeederFactoryItem, SeederFactoryManager, SeederFactoryManagerContext, SeederOptions, SeederPrepareElement, StripEnums, TSConfig, TypeormExtensionError, adjustFilePath, adjustFilePaths, assertSchemaMatchesMetadata, buildCockroachDBCreateDatabaseQuery, buildCockroachDBDropDatabaseQuery, buildConnectionParams, buildDataSourceOptions, buildDatabaseCreateContext, buildDatabaseDropContext, buildMongoDBConnectionUri, buildMongoDBDropDatabaseCommand, buildMsSQLCreateDatabaseQuery, buildMsSQLDropDatabaseQuery, buildMySQLCreateDatabaseQuery, buildMySQLDropDatabaseQuery, buildOracleConnectString, buildOracleCreateDatabaseQuery, buildPostgresCreateDatabaseQuery, buildPostgresCreateSchemaQuery, buildPostgresDatabaseExistsQuery, buildPostgresDropDatabaseQuery, buildSeederFileName, buildSeederFileTemplate, canReplaceWindowsSeparator, changeColumnType, checkDatabase, createCockroachDBDatabase, createDatabase, createMongoDBDatabase, createMsSQLDatabase, createMySQLDatabase, createOracleDatabase, createPathResolver, createPostgresDatabase, createSQLiteDatabase, deriveMySQLCharacterSet, detectCodeTransformation, dropCockroachDBDatabase, dropDatabase, dropMongoDBDatabase, dropMsSQLDatabase, dropMySQLDatabase, dropOracleDatabase, dropPostgresDatabase, dropSQLiteDatabase, existsQuery, extendObject, findDataSource, generateMigration, getEntityMetadata, getEntityName, getEntityPropertyNames, getSchemaDrift, hasDataSource, hasDataSourceOptions, hasEnvDataSourceOptions, hasOwnProperty, hasResultRows, hasStringProperty, hasTrailingSlash, isCodeTransformation, isDirectory, isEntityUnique, isObject, isPromise, mergeDataSourceOptions, mergeDataSourceOptionsWithEnv, parseFilePath, pickRecord, prepareSeederFactories, prepareSeederSeeds, readDataSourceOptionsFromEnv, readTSConfig, renameForeignKey, renameIndex, replaceWindowSeparator, resetEnv, resetSeederFactoryManager, resolveFilePath, resolveFilePaths, resolveFilePatterns, resolveSQLiteDatabaseDirectory, resolveSQLiteDatabasePath, resolveSeederConfig, runSeeder, runSeeders, safeReplaceWindowsSeparator, setDataSource, setDataSourceOptions, setSeederFactory, synchronizeDatabaseSchema, transformFilePath, unsetDataSource, useDataSource, useDataSourceOptions, useEnv, useSeederFactory, useSeederFactoryManager, validateEntityJoinColumns, withForeignKeyChecksDisabled, withoutTrailingSlash };
+//# sourceMappingURL=index.d.mts.map