@depup/typeorm-extension 3.9.0-depup.0

package/dist/cli/commands/seed/run.d.ts

@@ -0,0 +1,24 @@
+import type { Arguments, Argv, CommandModule } from 'yargs';
+export interface SeedRunArguments extends Arguments {
+    preserveFilePaths: boolean;
+    root: string;
+    tsconfig: string;
+    dataSource: string;
+    name?: string;
+}
+export declare class SeedRunCommand implements CommandModule {
+    command: string;
+    describe: string;
+    builder(args: Argv): Argv<{
+        preserveFilePaths: boolean;
+    } & {
+        root: string;
+    } & {
+        tsconfig: string;
+    } & {
+        dataSource: string;
+    } & {
+        name: unknown;
+    }>;
+    handler(raw: Arguments): Promise<void>;
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import 'reflect-metadata';

package/dist/data-source/find/index.d.ts

@@ -0,0 +1,2 @@
+export * from './module';
+export * from './type';

package/dist/data-source/find/module.d.ts

@@ -0,0 +1,3 @@
+import type { DataSource } from 'typeorm';
+import type { DataSourceFindOptions } from './type';
+export declare function findDataSource(context?: DataSourceFindOptions): Promise<DataSource | undefined>;

package/dist/data-source/find/type.d.ts

@@ -0,0 +1,22 @@
+import type { TSConfig } from '../../utils/tsconfig';
+export 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;
+};

package/dist/data-source/index.d.ts

@@ -0,0 +1,4 @@
+export * from './find';
+export * from './options';
+export * from './singleton';
+export * from './type';

package/dist/data-source/options/index.d.ts

@@ -0,0 +1,4 @@
+export * from './module';
+export * from './singleton';
+export * from './type';
+export * from './utils';

package/dist/data-source/options/module.d.ts

@@ -0,0 +1,8 @@
+import type { DataSourceOptions } from 'typeorm';
+import type { DataSourceOptionsBuildContext } from './type';
+/**
+ * Build DataSourceOptions from DataSource or from configuration.
+ *
+ * @param context
+ */
+export declare function buildDataSourceOptions(context?: DataSourceOptionsBuildContext): Promise<DataSourceOptions>;

package/dist/data-source/options/singleton.d.ts

@@ -0,0 +1,4 @@
+import type { DataSourceOptions } from 'typeorm';
+export declare function setDataSourceOptions(options: DataSourceOptions, alias?: string): void;
+export declare function hasDataSourceOptions(alias?: string): boolean;
+export declare function useDataSourceOptions(alias?: string): Promise<DataSourceOptions>;

package/dist/data-source/options/type.d.ts

@@ -0,0 +1,26 @@
+import type { TSConfig } from '../../utils/tsconfig';
+export 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;
+};

package/dist/data-source/options/utils/env.d.ts

@@ -0,0 +1,4 @@
+import type { DataSourceOptions } from 'typeorm';
+export declare function hasEnvDataSourceOptions(): boolean;
+export declare function readDataSourceOptionsFromEnv(): DataSourceOptions | undefined;
+export declare function mergeDataSourceOptionsWithEnv(options: DataSourceOptions): DataSourceOptions;

package/dist/data-source/options/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './env';
+export * from './merge';

package/dist/data-source/options/utils/merge.d.ts

@@ -0,0 +1,2 @@
+import type { DataSourceOptions } from 'typeorm';
+export declare function mergeDataSourceOptions(target: DataSourceOptions, source: DataSourceOptions): DataSourceOptions;

package/dist/data-source/singleton.d.ts

@@ -0,0 +1,5 @@
+import { DataSource } from 'typeorm';
+export declare function setDataSource(dataSource: DataSource, alias?: string): void;
+export declare function hasDataSource(alias?: string): boolean;
+export declare function unsetDataSource(alias?: string): void;
+export declare function useDataSource(alias?: string): Promise<DataSource>;

package/dist/data-source/type.d.ts

@@ -0,0 +1,2 @@
+import type { DataSourceOptions } from 'typeorm';
+export type DataSourceCacheOption = DataSourceOptions['cache'];

package/dist/database/driver/cockroachdb.d.ts

@@ -0,0 +1,4 @@
+import type { DatabaseCreateContextInput, DatabaseDropContextInput } from '../methods';
+export declare function executeSimpleCockroachDBQuery(connection: any, query: string, endConnection?: boolean): Promise<unknown>;
+export declare function createCockroachDBDatabase(input?: DatabaseCreateContextInput): Promise<unknown>;
+export declare function dropCockroachDBDatabase(input?: DatabaseDropContextInput): Promise<unknown>;

package/dist/database/driver/index.d.ts

@@ -0,0 +1,9 @@
+export * from './cockroachdb';
+export * from './mongodb';
+export * from './mssql';
+export * from './mysql';
+export * from './oracle';
+export * from './postgres';
+export * from './sqlite';
+export * from './types';
+export * from './utils';

package/dist/database/driver/mongodb.d.ts

@@ -0,0 +1,6 @@
+import type { MongoDriver } from 'typeorm/driver/mongodb/MongoDriver';
+import type { DatabaseCreateContextInput, DatabaseDropContextInput } from '../methods';
+import type { DriverOptions } from './types';
+export declare function createSimpleMongoDBConnection(driver: MongoDriver, options: DriverOptions): Promise<any>;
+export declare function createMongoDBDatabase(input?: DatabaseCreateContextInput): Promise<void>;
+export declare function dropMongoDBDatabase(input?: DatabaseDropContextInput): Promise<any>;

package/dist/database/driver/mssql.d.ts

@@ -0,0 +1,6 @@
+import type { SqlServerDriver } from 'typeorm/driver/sqlserver/SqlServerDriver';
+import type { DatabaseCreateContextInput, DatabaseDropContextInput } from '../methods';
+import type { DriverOptions } from './types';
+export declare function createSimpleMsSQLConnection(driver: SqlServerDriver, options: DriverOptions): Promise<any>;
+export declare function createMsSQLDatabase(input?: DatabaseCreateContextInput): Promise<any>;
+export declare function dropMsSQLDatabase(input?: DatabaseDropContextInput): Promise<any>;

package/dist/database/driver/mysql.d.ts

@@ -0,0 +1,7 @@
+import type { MysqlDriver } from 'typeorm/driver/mysql/MysqlDriver';
+import type { DatabaseCreateContextInput, DatabaseDropContextInput } from '../methods';
+import type { DriverOptions } from './types';
+export declare function createSimpleMySQLConnection(driver: MysqlDriver, options: DriverOptions): Promise<any>;
+export declare function executeSimpleMysqlQuery(connection: any, query: string, endConnection?: boolean): Promise<unknown>;
+export declare function createMySQLDatabase(input?: DatabaseCreateContextInput): Promise<unknown>;
+export declare function dropMySQLDatabase(input?: DatabaseDropContextInput): Promise<unknown>;

package/dist/database/driver/oracle.d.ts

@@ -0,0 +1,6 @@
+import type { OracleDriver } from 'typeorm/driver/oracle/OracleDriver';
+import type { DatabaseCreateContextInput, DatabaseDropContextInput } from '../methods';
+import type { DriverOptions } from './types';
+export declare function createSimpleOracleConnection(driver: OracleDriver, options: DriverOptions): any;
+export declare function createOracleDatabase(input?: DatabaseCreateContextInput): Promise<any>;
+export declare function dropOracleDatabase(_context?: DatabaseDropContextInput): Promise<void>;

package/dist/database/driver/postgres.d.ts

@@ -0,0 +1,8 @@
+import type { PostgresDriver } from 'typeorm/driver/postgres/PostgresDriver';
+import type { CockroachDriver } from 'typeorm/driver/cockroachdb/CockroachDriver';
+import type { DatabaseBaseContext, DatabaseCreateContextInput, DatabaseDropContextInput } from '../methods';
+import type { DriverOptions } from './types';
+export declare function createSimplePostgresConnection(driver: PostgresDriver | CockroachDriver, options: DriverOptions, operationContext: DatabaseBaseContext): Promise<any>;
+export declare function executeSimplePostgresQuery(connection: any, query: string, endConnection?: boolean): Promise<unknown>;
+export declare function createPostgresDatabase(input?: DatabaseCreateContextInput): Promise<unknown>;
+export declare function dropPostgresDatabase(input?: DatabaseDropContextInput): Promise<unknown>;

package/dist/database/driver/sqlite.d.ts

@@ -0,0 +1,3 @@
+import type { DatabaseCreateContextInput, DatabaseDropContextInput } from '../methods';
+export declare function createSQLiteDatabase(input?: DatabaseCreateContextInput): Promise<void>;
+export declare function dropSQLiteDatabase(input?: DatabaseDropContextInput): Promise<void>;

package/dist/database/driver/types.d.ts

@@ -0,0 +1,20 @@
+export type DriverOptions = {
+    database?: string;
+    host?: string;
+    user?: string;
+    password?: string;
+    port?: number;
+    ssl?: any;
+    url?: string;
+    connectString?: string;
+    sid?: string | number;
+    serviceName?: string;
+    domain?: string;
+    charset?: string;
+    characterSet?: string;
+    schema?: string;
+    template?: string;
+    extra?: {
+        [key: string]: any;
+    };
+};

package/dist/database/driver/utils/build.d.ts

@@ -0,0 +1,3 @@
+import type { DataSourceOptions } from 'typeorm';
+import type { DriverOptions } from '../types';
+export declare function buildDriverOptions(options: DataSourceOptions): DriverOptions;

package/dist/database/driver/utils/character-set.d.ts

@@ -0,0 +1,2 @@
+import type { DataSourceOptions } from 'typeorm';
+export declare function getCharacterSetFromDataSourceOptions(options: DataSourceOptions): string | undefined;

package/dist/database/driver/utils/charset.d.ts

@@ -0,0 +1,2 @@
+import type { DataSourceOptions } from 'typeorm';
+export declare function getCharsetFromDataSourceOptions(options: DataSourceOptions): string | undefined;

package/dist/database/driver/utils/create.d.ts

@@ -0,0 +1,2 @@
+import type { DataSourceOptions } from 'typeorm';
+export declare function createDriver(connectionOptions: DataSourceOptions): import("typeorm").Driver;

package/dist/database/driver/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './build';
+export * from './character-set';
+export * from './charset';
+export * from './create';

package/dist/database/index.d.ts

@@ -0,0 +1,3 @@
+export * from './methods';
+export * from './driver';
+export * from './utils';

package/dist/database/methods/check/index.d.ts

@@ -0,0 +1,2 @@
+export * from './module';
+export * from './types';

package/dist/database/methods/check/module.d.ts

@@ -0,0 +1,7 @@
+import type { DatabaseCheckContext, DatabaseCheckResult } from './types';
+/**
+ * Check database setup progress.
+ *
+ * @param context
+ */
+export declare function checkDatabase(context?: DatabaseCheckContext): Promise<DatabaseCheckResult>;

package/dist/database/methods/check/types.d.ts

@@ -0,0 +1,51 @@
+import type { DataSource, DataSourceOptions, Migration } from 'typeorm';
+export 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;
+};
+export 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[];
+};

package/dist/database/methods/create/index.d.ts

@@ -0,0 +1 @@
+export * from './module';

package/dist/database/methods/create/module.d.ts

@@ -0,0 +1,10 @@
+import type { DatabaseCreateContextInput } from '../type';
+/**
+ * Create database for specified driver in ConnectionOptions.
+ *
+ * @throws DriverError
+ * @throws OptionsError
+ *
+ * @param input
+ */
+export declare function createDatabase(input?: DatabaseCreateContextInput): Promise<unknown>;

package/dist/database/methods/drop/index.d.ts

@@ -0,0 +1 @@
+export * from './module';

package/dist/database/methods/drop/module.d.ts

@@ -0,0 +1,10 @@
+import type { DatabaseDropContextInput } from '../type';
+/**
+ * Drop database for specified driver in ConnectionOptions.
+ *
+ * @throws DriverError
+ * @throws OptionsError
+ *
+ * @param input
+ */
+export declare function dropDatabase(input?: DatabaseDropContextInput): Promise<unknown>;

package/dist/database/methods/index.d.ts

@@ -0,0 +1,4 @@
+export * from './check';
+export * from './create';
+export * from './drop';
+export * from './type';

package/dist/database/methods/type.d.ts

@@ -0,0 +1,43 @@
+import type { DataSourceOptions } from 'typeorm';
+import type { DataSourceFindOptions } from '../../data-source';
+export 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;
+};
+export type DatabaseBaseContextInput = Partial<DatabaseBaseContext>;
+export 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;
+};
+export type DatabaseCreateContextInput = Partial<DatabaseCreateContext>;
+export type DatabaseDropContext = Omit<DatabaseBaseContext, 'findOptions'> & {
+    /**
+     * Only drop database if existed.
+     *
+     * Default: true
+     */
+    ifExist?: boolean;
+};
+export type DatabaseDropContextInput = Partial<DatabaseDropContext>;

package/dist/database/utils/context.d.ts

@@ -0,0 +1,3 @@
+import type { DatabaseCreateContext, DatabaseCreateContextInput, DatabaseDropContext, DatabaseDropContextInput } from '../methods';
+export declare function buildDatabaseCreateContext(input?: DatabaseCreateContextInput): Promise<DatabaseCreateContext>;
+export declare function buildDatabaseDropContext(input?: DatabaseDropContextInput): Promise<DatabaseDropContext>;

package/dist/database/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './context';
+export * from './migration';
+export * from './query';
+export * from './schema';
+export * from './type';

package/dist/database/utils/migration.d.ts

@@ -0,0 +1,2 @@
+import type { MigrationGenerateCommandContext, MigrationGenerateResult } from './type';
+export declare function generateMigration(context: MigrationGenerateCommandContext): Promise<MigrationGenerateResult>;

package/dist/database/utils/query.d.ts

@@ -0,0 +1,3 @@
+import type { ObjectLiteral } from 'rapiq';
+import type { SelectQueryBuilder } from 'typeorm';
+export declare function existsQuery<T extends ObjectLiteral = ObjectLiteral>(builder: SelectQueryBuilder<T>, inverse?: boolean): string;

package/dist/database/utils/schema.d.ts

@@ -0,0 +1,3 @@
+import type { DataSourceOptions, Migration } from 'typeorm';
+import { DataSource } from 'typeorm';
+export declare function synchronizeDatabaseSchema(input: DataSource | DataSourceOptions): Promise<Migration[]>;

package/dist/database/utils/type.d.ts

@@ -0,0 +1,32 @@
+import type { DataSource } from 'typeorm';
+export type MigrationGenerateResult = {
+    up: string[];
+    down: string[];
+    content?: string;
+};
+export 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;
+};

package/dist/env/constants.d.ts

@@ -0,0 +1,68 @@
+export declare enum EnvironmentName {
+    DEVELOPMENT = "development",
+    PRODUCTION = "production",
+    TEST = "test"
+}
+export 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"
+}

package/dist/env/index.d.ts

@@ -0,0 +1,3 @@
+export * from './constants';
+export * from './module';
+export * from './type';

package/dist/env/module.d.ts

@@ -0,0 +1,4 @@
+import type { Environment } from './type';
+export declare function useEnv(): Environment;
+export declare function useEnv<K extends keyof Environment>(key: K): Environment[K];
+export declare function resetEnv(): void;

package/dist/env/type.d.ts

@@ -0,0 +1,36 @@
+import type { DatabaseType } from 'typeorm/driver/types/DatabaseType';
+import type { DataSourceCacheOption } from '../data-source';
+import type { EnvironmentName } from './constants';
+export 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;
+}

package/dist/env/utils.d.ts

@@ -0,0 +1,3 @@
+import type { DataSourceCacheOption } from '../data-source';
+export declare function transformLogging(input?: string): boolean | string | string[];
+export declare function transformCache(input?: string): DataSourceCacheOption | undefined;

package/dist/errors/base.d.ts

@@ -0,0 +1,2 @@
+export declare class TypeormExtensionError extends Error {
+}

package/dist/errors/driver.d.ts

@@ -0,0 +1,6 @@
+import { TypeormExtensionError } from './base';
+export declare class DriverError extends TypeormExtensionError {
+    constructor(message?: string);
+    static undeterminable(): DriverError;
+    static notSupported(driverName: string): DriverError;
+}

package/dist/errors/index.d.ts

@@ -0,0 +1,3 @@
+export * from './base';
+export * from './driver';
+export * from './options';

package/dist/errors/options.d.ts

@@ -0,0 +1,7 @@
+import { TypeormExtensionError } from './base';
+export declare class OptionsError extends TypeormExtensionError {
+    constructor(message?: string);
+    static undeterminable(): OptionsError;
+    static notFound(): OptionsError;
+    static databaseNotDefined(): OptionsError;
+}

package/dist/helpers/entity/error.d.ts

@@ -0,0 +1,20 @@
+import { TypeormExtensionError } from '../../errors';
+type TypeormRelationLookupErrorOptions = {
+    message: string;
+    relation: string;
+    columns: string[];
+};
+export declare class EntityRelationLookupError extends TypeormExtensionError {
+    /**
+     * The property name of the relation.
+     */
+    relation: string;
+    /**
+     * The property names of the join columns.
+     */
+    columns: string[];
+    constructor(options: TypeormRelationLookupErrorOptions);
+    static notReferenced(relation: string, columns: string[]): EntityRelationLookupError;
+    static notFound(relation: string, columns: string[]): EntityRelationLookupError;
+}
+export {};

package/dist/helpers/entity/index.d.ts

@@ -0,0 +1,5 @@
+export * from './error';
+export * from './property-names';
+export * from './metadata';
+export * from './join-columns';
+export * from './uniqueness';