@mikro-orm/knex 6.0.0-dev.6 → 6.0.0-dev.8

package/AbstractSqlPlatform.d.ts

@@ -1,7 +1,7 @@
 import type { Constructor, EntityManager, EntityRepository, IDatabaseDriver, MikroORM } from '@mikro-orm/core';
 import { Platform } from '@mikro-orm/core';
 import type { SchemaHelper } from './schema';
-import { SchemaGenerator } from './schema';
+import { SqlSchemaGenerator } from './schema';
 export declare abstract class AbstractSqlPlatform extends Platform {
     protected readonly schemaHelper?: SchemaHelper;
     usesPivotTable(): boolean;
@@ -10,7 +10,7 @@ export declare abstract class AbstractSqlPlatform extends Platform {
     getSchemaHelper(): SchemaHelper | undefined;
     /** @inheritDoc */
     lookupExtensions(orm: MikroORM): void;
-    getSchemaGenerator(driver: IDatabaseDriver, em?: EntityManager): SchemaGenerator;
+    getSchemaGenerator(driver: IDatabaseDriver, em?: EntityManager): SqlSchemaGenerator;
     quoteValue(value: any): string;
     formatQuery(sql: string, params: readonly any[]): string;
     getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string;

package/AbstractSqlPlatform.js

@@ -20,11 +20,11 @@ class AbstractSqlPlatform extends core_1.Platform {
     }
     /** @inheritDoc */
     lookupExtensions(orm) {
-        schema_1.SchemaGenerator.register(orm);
+        schema_1.SqlSchemaGenerator.register(orm);
     }
     /* istanbul ignore next: kept for type inference only */
     getSchemaGenerator(driver, em) {
-        return new schema_1.SchemaGenerator(em ?? driver);
+        return new schema_1.SqlSchemaGenerator(em ?? driver);
     }
     quoteValue(value) {
         if (this.isRaw(value)) {

package/index.d.ts

@@ -15,3 +15,4 @@ export { SqlEntityManager as EntityManager } from './SqlEntityManager';
 export { SqlEntityRepository as EntityRepository } from './SqlEntityRepository';
 /** @ignore */
 export { Knex, knex } from 'knex';
+export * from '@mikro-orm/core';

package/index.js

@@ -37,3 +37,4 @@ Object.defineProperty(exports, "EntityRepository", { enumerable: true, get: func
 var knex_1 = require("knex");
 Object.defineProperty(exports, "Knex", { enumerable: true, get: function () { return knex_1.Knex; } });
 Object.defineProperty(exports, "knex", { enumerable: true, get: function () { return knex_1.knex; } });
+__exportStar(require("@mikro-orm/core"), exports);

package/index.mjs

@@ -1,26 +1,192 @@
 import mod from "./index.js";
 
 export default mod;
+export const ARRAY_OPERATORS = mod.ARRAY_OPERATORS;
+export const AbstractNamingStrategy = mod.AbstractNamingStrategy;
+export const AbstractSchemaGenerator = mod.AbstractSchemaGenerator;
 export const AbstractSqlConnection = mod.AbstractSqlConnection;
 export const AbstractSqlDriver = mod.AbstractSqlDriver;
 export const AbstractSqlPlatform = mod.AbstractSqlPlatform;
+export const AfterCreate = mod.AfterCreate;
+export const AfterDelete = mod.AfterDelete;
+export const AfterUpdate = mod.AfterUpdate;
+export const ArrayCollection = mod.ArrayCollection;
 export const ArrayCriteriaNode = mod.ArrayCriteriaNode;
+export const ArrayType = mod.ArrayType;
+export const BaseEntity = mod.BaseEntity;
+export const BeforeCreate = mod.BeforeCreate;
+export const BeforeDelete = mod.BeforeDelete;
+export const BeforeUpdate = mod.BeforeUpdate;
+export const BigIntType = mod.BigIntType;
+export const BlobType = mod.BlobType;
+export const BooleanType = mod.BooleanType;
+export const Cascade = mod.Cascade;
+export const ChangeSet = mod.ChangeSet;
+export const ChangeSetComputer = mod.ChangeSetComputer;
+export const ChangeSetPersister = mod.ChangeSetPersister;
+export const ChangeSetType = mod.ChangeSetType;
+export const Check = mod.Check;
+export const CheckConstraintViolationException = mod.CheckConstraintViolationException;
+export const Collection = mod.Collection;
+export const CommitOrderCalculator = mod.CommitOrderCalculator;
+export const Configuration = mod.Configuration;
+export const ConfigurationLoader = mod.ConfigurationLoader;
+export const Connection = mod.Connection;
+export const ConnectionException = mod.ConnectionException;
+export const ConstraintViolationException = mod.ConstraintViolationException;
 export const CriteriaNode = mod.CriteriaNode;
 export const CriteriaNodeFactory = mod.CriteriaNodeFactory;
+export const DatabaseDriver = mod.DatabaseDriver;
+export const DatabaseObjectExistsException = mod.DatabaseObjectExistsException;
+export const DatabaseObjectNotFoundException = mod.DatabaseObjectNotFoundException;
 export const DatabaseSchema = mod.DatabaseSchema;
 export const DatabaseTable = mod.DatabaseTable;
+export const DateTimeType = mod.DateTimeType;
+export const DateType = mod.DateType;
+export const DeadlockException = mod.DeadlockException;
+export const DecimalType = mod.DecimalType;
+export const DefaultLogger = mod.DefaultLogger;
+export const DoubleType = mod.DoubleType;
+export const DriverException = mod.DriverException;
+export const Embeddable = mod.Embeddable;
+export const Embedded = mod.Embedded;
+export const Entity = mod.Entity;
+export const EntityAssigner = mod.EntityAssigner;
+export const EntityCaseNamingStrategy = mod.EntityCaseNamingStrategy;
+export const EntityComparator = mod.EntityComparator;
+export const EntityFactory = mod.EntityFactory;
+export const EntityHelper = mod.EntityHelper;
+export const EntityIdentifier = mod.EntityIdentifier;
+export const EntityLoader = mod.EntityLoader;
 export const EntityManager = mod.EntityManager;
+export const EntityManagerType = mod.EntityManagerType;
+export const EntityMetadata = mod.EntityMetadata;
 export const EntityRepository = mod.EntityRepository;
+export const EntityRepositoryType = mod.EntityRepositoryType;
+export const EntitySchema = mod.EntitySchema;
+export const EntitySerializer = mod.EntitySerializer;
+export const EntityTransformer = mod.EntityTransformer;
+export const EntityValidator = mod.EntityValidator;
+export const Enum = mod.Enum;
+export const EnumArrayType = mod.EnumArrayType;
+export const EnumType = mod.EnumType;
+export const EventManager = mod.EventManager;
+export const EventType = mod.EventType;
+export const ExceptionConverter = mod.ExceptionConverter;
+export const FileCacheAdapter = mod.FileCacheAdapter;
+export const Filter = mod.Filter;
+export const FloatType = mod.FloatType;
+export const FlushMode = mod.FlushMode;
+export const ForeignKeyConstraintViolationException = mod.ForeignKeyConstraintViolationException;
+export const Formula = mod.Formula;
+export const GroupOperator = mod.GroupOperator;
+export const Hydrator = mod.Hydrator;
+export const IdentityMap = mod.IdentityMap;
+export const Index = mod.Index;
+export const IntegerType = mod.IntegerType;
+export const InvalidFieldNameException = mod.InvalidFieldNameException;
+export const IsolationLevel = mod.IsolationLevel;
+export const JavaScriptMetadataProvider = mod.JavaScriptMetadataProvider;
+export const JsonProperty = mod.JsonProperty;
+export const JsonType = mod.JsonType;
 export const Knex = mod.Knex;
+export const LoadStrategy = mod.LoadStrategy;
+export const LockMode = mod.LockMode;
+export const LockWaitTimeoutException = mod.LockWaitTimeoutException;
+export const ManyToMany = mod.ManyToMany;
+export const ManyToOne = mod.ManyToOne;
+export const MediumIntType = mod.MediumIntType;
+export const MemoryCacheAdapter = mod.MemoryCacheAdapter;
+export const MetadataDiscovery = mod.MetadataDiscovery;
+export const MetadataError = mod.MetadataError;
+export const MetadataProvider = mod.MetadataProvider;
+export const MetadataStorage = mod.MetadataStorage;
+export const MetadataValidator = mod.MetadataValidator;
+export const MikroORM = mod.MikroORM;
+export const MongoNamingStrategy = mod.MongoNamingStrategy;
 export const MonkeyPatchable = mod.MonkeyPatchable;
+export const NodeState = mod.NodeState;
+export const NonUniqueFieldNameException = mod.NonUniqueFieldNameException;
+export const NotFoundError = mod.NotFoundError;
+export const NotNullConstraintViolationException = mod.NotNullConstraintViolationException;
+export const NullCacheAdapter = mod.NullCacheAdapter;
+export const NullHighlighter = mod.NullHighlighter;
+export const ObjectBindingPattern = mod.ObjectBindingPattern;
 export const ObjectCriteriaNode = mod.ObjectCriteriaNode;
+export const ObjectHydrator = mod.ObjectHydrator;
+export const OnInit = mod.OnInit;
+export const OnLoad = mod.OnLoad;
+export const OneToMany = mod.OneToMany;
+export const OneToOne = mod.OneToOne;
+export const OptimisticLockError = mod.OptimisticLockError;
+export const OptionalProps = mod.OptionalProps;
+export const PlainObject = mod.PlainObject;
+export const Platform = mod.Platform;
+export const PopulateHint = mod.PopulateHint;
+export const PrimaryKey = mod.PrimaryKey;
+export const PrimaryKeyProp = mod.PrimaryKeyProp;
+export const PrimaryKeyType = mod.PrimaryKeyType;
+export const Property = mod.Property;
 export const QueryBuilder = mod.QueryBuilder;
 export const QueryBuilderHelper = mod.QueryBuilderHelper;
+export const QueryFlag = mod.QueryFlag;
+export const QueryHelper = mod.QueryHelper;
+export const QueryOperator = mod.QueryOperator;
+export const QueryOrder = mod.QueryOrder;
+export const QueryOrderNumeric = mod.QueryOrderNumeric;
 export const QueryType = mod.QueryType;
+export const ReadOnlyException = mod.ReadOnlyException;
+export const Reference = mod.Reference;
+export const ReferenceType = mod.ReferenceType;
+export const ReflectMetadataProvider = mod.ReflectMetadataProvider;
+export const RequestContext = mod.RequestContext;
+export const SCALAR_TYPES = mod.SCALAR_TYPES;
 export const ScalarCriteriaNode = mod.ScalarCriteriaNode;
 export const SchemaComparator = mod.SchemaComparator;
 export const SchemaGenerator = mod.SchemaGenerator;
 export const SchemaHelper = mod.SchemaHelper;
+export const SerializationContext = mod.SerializationContext;
+export const SerializedPrimaryKey = mod.SerializedPrimaryKey;
+export const ServerException = mod.ServerException;
+export const SimpleLogger = mod.SimpleLogger;
+export const SmallIntType = mod.SmallIntType;
 export const SqlEntityManager = mod.SqlEntityManager;
 export const SqlEntityRepository = mod.SqlEntityRepository;
+export const SqlSchemaGenerator = mod.SqlSchemaGenerator;
+export const StringType = mod.StringType;
+export const Subscriber = mod.Subscriber;
+export const SyntaxErrorException = mod.SyntaxErrorException;
+export const TableExistsException = mod.TableExistsException;
+export const TableNotFoundException = mod.TableNotFoundException;
+export const TextType = mod.TextType;
+export const TimeType = mod.TimeType;
+export const TinyIntType = mod.TinyIntType;
+export const TransactionContext = mod.TransactionContext;
+export const TransactionEventBroadcaster = mod.TransactionEventBroadcaster;
+export const Type = mod.Type;
+export const UnderscoreNamingStrategy = mod.UnderscoreNamingStrategy;
+export const Unique = mod.Unique;
+export const UniqueConstraintViolationException = mod.UniqueConstraintViolationException;
+export const UnitOfWork = mod.UnitOfWork;
+export const UnknownType = mod.UnknownType;
+export const UseRequestContext = mod.UseRequestContext;
+export const Utils = mod.Utils;
+export const UuidType = mod.UuidType;
+export const ValidationError = mod.ValidationError;
+export const WrappedEntity = mod.WrappedEntity;
+export const assign = mod.assign;
+export const colors = mod.colors;
+export const compareArrays = mod.compareArrays;
+export const compareBooleans = mod.compareBooleans;
+export const compareBuffers = mod.compareBuffers;
+export const compareObjects = mod.compareObjects;
+export const defineConfig = mod.defineConfig;
+export const equals = mod.equals;
+export const expr = mod.expr;
+export const helper = mod.helper;
 export const knex = mod.knex;
+export const ref = mod.ref;
+export const serialize = mod.serialize;
+export const t = mod.t;
+export const types = mod.types;
+export const wrap = mod.wrap;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.0-dev.6",
+  "version": "6.0.0-dev.8",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "main": "index.js",
   "module": "index.mjs",
@@ -66,6 +66,6 @@
     "@mikro-orm/core": "^5.5.3"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "~6.0.0-dev.6"
+    "@mikro-orm/core": "~6.0.0-dev.8"
   }
 }

package/schema/DatabaseTable.d.ts

@@ -1,6 +1,6 @@
 import type { Dictionary, EntityMetadata, EntityProperty, NamingStrategy } from '@mikro-orm/core';
 import type { SchemaHelper } from './SchemaHelper';
-import type { Check, Column, ForeignKey, Index } from '../typings';
+import type { CheckDef, Column, ForeignKey, IndexDef } from '../typings';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
 /**
  * @internal
@@ -17,9 +17,9 @@ export declare class DatabaseTable {
     constructor(platform: AbstractSqlPlatform, name: string, schema?: string | undefined);
     getColumns(): Column[];
     getColumn(name: string): Column | undefined;
-    getIndexes(): Index[];
-    getChecks(): Check[];
-    init(cols: Column[], indexes: Index[] | undefined, checks: Check<unknown>[] | undefined, pks: string[], fks?: Dictionary<ForeignKey>, enums?: Dictionary<string[]>): void;
+    getIndexes(): IndexDef[];
+    getChecks(): CheckDef[];
+    init(cols: Column[], indexes: IndexDef[] | undefined, checks: CheckDef<unknown>[] | undefined, pks: string[], fks?: Dictionary<ForeignKey>, enums?: Dictionary<string[]>): void;
     addColumn(column: Column): void;
     addColumnFromProperty(prop: EntityProperty, meta: EntityMetadata): void;
     private getIndexName;
@@ -30,11 +30,11 @@ export declare class DatabaseTable {
     getShortestName(): string;
     getForeignKeys(): Dictionary<ForeignKey>;
     hasColumn(columnName: string): boolean;
-    getIndex(indexName: string): Index | undefined;
+    getIndex(indexName: string): IndexDef | undefined;
     hasIndex(indexName: string): boolean;
-    getCheck(checkName: string): Check<unknown> | undefined;
+    getCheck(checkName: string): CheckDef<unknown> | undefined;
     hasCheck(checkName: string): boolean;
-    getPrimaryKey(): Index | undefined;
+    getPrimaryKey(): IndexDef | undefined;
     hasPrimaryKey(): boolean;
     private getPropertyDeclaration;
     private getReferenceType;
@@ -48,6 +48,6 @@ export declare class DatabaseTable {
         expression?: string;
         options?: Dictionary;
     }, type: 'index' | 'unique' | 'primary'): void;
-    addCheck(check: Check): void;
+    addCheck(check: CheckDef): void;
     toJSON(): Dictionary;
 }

package/schema/SchemaComparator.d.ts

@@ -1,4 +1,4 @@
-import type { Check, Column, ForeignKey, Index, SchemaDifference, TableDifference } from '../typings';
+import type { CheckDef, Column, ForeignKey, IndexDef, SchemaDifference, TableDifference } from '../typings';
 import type { DatabaseSchema } from './DatabaseSchema';
 import type { DatabaseTable } from './DatabaseTable';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
@@ -45,12 +45,12 @@ export declare class SchemaComparator {
      * Finds the difference between the indexes index1 and index2.
      * Compares index1 with index2 and returns index2 if there are any differences or false in case there are no differences.
      */
-    diffIndex(index1: Index, index2: Index): boolean;
+    diffIndex(index1: IndexDef, index2: IndexDef): boolean;
     /**
      * Checks if the other index already fulfills all the indexing and constraint needs of the current one.
      */
-    isIndexFulfilledBy(index1: Index, index2: Index): boolean;
-    diffCheck(check1: Check, check2: Check): boolean;
+    isIndexFulfilledBy(index1: IndexDef, index2: IndexDef): boolean;
+    diffCheck(check1: CheckDef, check2: CheckDef): boolean;
     hasSameDefaultValue(from: Column, to: Column): boolean;
     private mapColumnToProperty;
     private log;

package/schema/SchemaHelper.d.ts

@@ -2,7 +2,7 @@ import type { Knex } from 'knex';
 import type { Connection, Dictionary } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
-import type { Check, Column, Index, Table, TableDifference } from '../typings';
+import type { CheckDef, Column, IndexDef, Table, TableDifference } from '../typings';
 import type { DatabaseTable } from './DatabaseTable';
 import type { DatabaseSchema } from './DatabaseSchema';
 export declare abstract class SchemaHelper {
@@ -14,16 +14,16 @@ export declare abstract class SchemaHelper {
     getSchemaEnd(): string;
     finalizeTable(table: Knex.TableBuilder, charset: string, collate?: string): void;
     supportsSchemaConstraints(): boolean;
-    getPrimaryKeys(connection: AbstractSqlConnection, indexes: Index[] | undefined, tableName: string, schemaName?: string): Promise<string[]>;
+    getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[] | undefined, tableName: string, schemaName?: string): Promise<string[]>;
     getForeignKeys(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Dictionary>;
     protected getTableKey(t: Table): string;
-    getEnumDefinitions(connection: AbstractSqlConnection, checks: Check[], tableName: string, schemaName?: string): Promise<Dictionary<string[]>>;
+    getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName: string, schemaName?: string): Promise<Dictionary<string[]>>;
     loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[]): Promise<void>;
     getListTablesSQL(schemaName?: string): string;
     getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column, schemaName?: string): string;
-    getCreateIndexSQL(tableName: string, index: Index): string;
-    getDropIndexSQL(tableName: string, index: Index): string;
-    getRenameIndexSQL(tableName: string, index: Index, oldIndexName: string): string;
+    getCreateIndexSQL(tableName: string, index: IndexDef): string;
+    getDropIndexSQL(tableName: string, index: IndexDef): string;
+    getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string;
     hasNonDefaultPrimaryKeyName(table: DatabaseTable): boolean;
     createTableColumn(table: Knex.TableBuilder, column: Column, fromTable: DatabaseTable, changedProperties?: Set<string>): Knex.ColumnBuilder;
     configureColumn(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
@@ -33,9 +33,9 @@ export declare abstract class SchemaHelper {
     getChangeColumnCommentSQL(tableName: string, to: Column): string;
     getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
     getColumns(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Column[]>;
-    getIndexes(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Index[]>;
-    getChecks(connection: AbstractSqlConnection, tableName: string, schemaName?: string, columns?: Column[]): Promise<Check[]>;
-    protected mapIndexes(indexes: Index[]): Promise<Index[]>;
+    getIndexes(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<IndexDef[]>;
+    getChecks(connection: AbstractSqlConnection, tableName: string, schemaName?: string, columns?: Column[]): Promise<CheckDef[]>;
+    protected mapIndexes(indexes: IndexDef[]): Promise<IndexDef[]>;
     getForeignKeysSQL(tableName: string, schemaName?: string): string;
     mapForeignKeys(fks: any[], tableName: string, schemaName?: string): Dictionary;
     normalizeDefaultValue(defaultValue: string, length?: number, defaultValues?: Dictionary<string[]>): string | number;

package/schema/{SchemaGenerator.d.ts → SqlSchemaGenerator.d.ts}

@@ -3,10 +3,7 @@ import { AbstractSchemaGenerator } from '@mikro-orm/core';
 import type { SchemaDifference } from '../typings';
 import { DatabaseSchema } from './DatabaseSchema';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
-/**
- * Should be renamed to `SqlSchemaGenerator` in v6
- */
-export declare class SchemaGenerator extends AbstractSchemaGenerator<AbstractSqlDriver> implements ISchemaGenerator {
+export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<AbstractSqlDriver> implements ISchemaGenerator {
     private readonly helper;
     private readonly options;
     protected lastEnsuredDatabase?: string;
@@ -101,3 +98,4 @@ export declare class SchemaGenerator extends AbstractSchemaGenerator<AbstractSql
     private dump;
     private get knex();
 }
+export { SqlSchemaGenerator as SchemaGenerator };

package/schema/{SchemaGenerator.js → SqlSchemaGenerator.js}

@@ -1,20 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaGenerator = void 0;
+exports.SchemaGenerator = exports.SqlSchemaGenerator = void 0;
 const core_1 = require("@mikro-orm/core");
 const DatabaseSchema_1 = require("./DatabaseSchema");
 const SchemaComparator_1 = require("./SchemaComparator");
-/**
- * Should be renamed to `SqlSchemaGenerator` in v6
- */
-class SchemaGenerator extends core_1.AbstractSchemaGenerator {
+class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
     constructor() {
         super(...arguments);
         this.helper = this.platform.getSchemaHelper();
         this.options = this.config.get('schemaGenerator');
     }
     static register(orm) {
-        orm.config.registerExtension('@mikro-orm/schema-generator', () => new SchemaGenerator(orm.em));
+        orm.config.registerExtension('@mikro-orm/schema-generator', () => new SqlSchemaGenerator(orm.em));
     }
     /** @deprecated use `dropSchema` and `createSchema` commands respectively */
     async generate() {
@@ -487,4 +484,5 @@ class SchemaGenerator extends core_1.AbstractSchemaGenerator {
         return this.connection.getKnex();
     }
 }
-exports.SchemaGenerator = SchemaGenerator;
+exports.SqlSchemaGenerator = SqlSchemaGenerator;
+exports.SchemaGenerator = SqlSchemaGenerator;

package/schema/index.d.ts

@@ -1,5 +1,5 @@
 export * from './DatabaseSchema';
 export * from './DatabaseTable';
-export * from './SchemaGenerator';
+export * from './SqlSchemaGenerator';
 export * from './SchemaHelper';
 export * from './SchemaComparator';

package/schema/index.js

@@ -16,6 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./DatabaseSchema"), exports);
 __exportStar(require("./DatabaseTable"), exports);
-__exportStar(require("./SchemaGenerator"), exports);
+__exportStar(require("./SqlSchemaGenerator"), exports);
 __exportStar(require("./SchemaHelper"), exports);
 __exportStar(require("./SchemaComparator"), exports);

package/typings.d.ts

@@ -54,7 +54,7 @@ export interface ForeignKey {
     updateRule?: string;
     deleteRule?: string;
 }
-export interface Index {
+export interface IndexDef {
     columnNames: string[];
     keyName: string;
     unique: boolean;
@@ -67,7 +67,7 @@ export interface Index {
         predicate?: Knex.QueryBuilder;
     }>;
 }
-export interface Check<T = unknown> {
+export interface CheckDef<T = unknown> {
     name: string;
     expression: string | CheckCallback<T>;
     definition?: string;
@@ -88,13 +88,13 @@ export interface TableDifference {
     changedColumns: Dictionary<ColumnDifference>;
     removedColumns: Dictionary<Column>;
     renamedColumns: Dictionary<Column>;
-    addedIndexes: Dictionary<Index>;
-    changedIndexes: Dictionary<Index>;
-    removedIndexes: Dictionary<Index>;
-    renamedIndexes: Dictionary<Index>;
-    addedChecks: Dictionary<Check>;
-    changedChecks: Dictionary<Check>;
-    removedChecks: Dictionary<Check>;
+    addedIndexes: Dictionary<IndexDef>;
+    changedIndexes: Dictionary<IndexDef>;
+    removedIndexes: Dictionary<IndexDef>;
+    renamedIndexes: Dictionary<IndexDef>;
+    addedChecks: Dictionary<CheckDef>;
+    changedChecks: Dictionary<CheckDef>;
+    removedChecks: Dictionary<CheckDef>;
     addedForeignKeys: Dictionary<ForeignKey>;
     changedForeignKeys: Dictionary<ForeignKey>;
     removedForeignKeys: Dictionary<ForeignKey>;