lakutata 2.0.65 → 2.0.66

package/orm.cjs

@@ -8,9 +8,9 @@ require("./vendor/Package.4.cjs");
 
 const e = require("./vendor/Package.5.cjs");
 
-const r = require("./vendor/Package.122.cjs");
+const t = require("./vendor/Package.122.cjs");
 
-const t = require("./vendor/Package.12.cjs");
+const r = require("./vendor/Package.12.cjs");
 
 require("./vendor/Package.13.cjs");
 
@@ -56,8 +56,6 @@ require("./vendor/Package.11.cjs");
 
 require("url");
 
-require("node:util");
-
 require("./vendor/Package.63.cjs");
 
 require("node:url");
@@ -74,272 +72,1237 @@ require("node:stream");
 
 require("node:string_decoder");
 
-var o = r.requireGlobals();
+var o = t.requireGlobals();
 
 const n = e.getDefaultExportFromCjs(o);
 
-var a = r.requireEntityManager();
+var s = {};
 
-const u = e.getDefaultExportFromCjs(a);
+"use strict";
 
-var s = r.requireAbstractRepository();
+Object.defineProperty(s, "__esModule", {
+    value: true
+});
 
-const i = e.getDefaultExportFromCjs(s);
+var i = {};
 
-var p = r.requireMongoEntityManager();
+"use strict";
 
-const l = e.getDefaultExportFromCjs(p);
+Object.defineProperty(i, "__esModule", {
+    value: true
+});
 
-Object.defineProperty(exports, "AbstractLogger", {
-    enumerable: true,
-    get: () => r.AbstractLogger_2
+var u = {};
+
+"use strict";
+
+Object.defineProperty(u, "__esModule", {
+    value: true
 });
 
-Object.defineProperty(exports, "AdvancedConsoleLogger", {
-    enumerable: true,
-    get: () => r.AdvancedConsoleLogger_2
+var a = {};
+
+"use strict";
+
+Object.defineProperty(a, "__esModule", {
+    value: true
 });
 
-exports.And = r.And_2;
+var c = {};
 
-exports.Any = r.Any_2;
+"use strict";
 
-exports.ArrayContainedBy = r.ArrayContainedBy_2;
+Object.defineProperty(c, "__esModule", {
+    value: true
+});
 
-exports.ArrayContains = r.ArrayContains_2;
+var d = {};
 
-exports.ArrayOverlap = r.ArrayOverlap_2;
+"use strict";
 
-Object.defineProperty(exports, "BaseEntity", {
-    enumerable: true,
-    get: () => r.BaseEntity_2
+Object.defineProperty(d, "__esModule", {
+    value: true
 });
 
-exports.Between = r.Between_2;
+var l = {};
 
-Object.defineProperty(exports, "Brackets", {
-    enumerable: true,
-    get: () => r.Brackets_2
+"use strict";
+
+Object.defineProperty(l, "__esModule", {
+    value: true
 });
 
-Object.defineProperty(exports, "ConnectionOptionsReader", {
-    enumerable: true,
-    get: () => r.ConnectionOptionsReader_2
+var p = {};
+
+"use strict";
+
+Object.defineProperty(p, "__esModule", {
+    value: true
 });
 
-Object.defineProperty(exports, "DefaultNamingStrategy", {
-    enumerable: true,
-    get: () => r.DefaultNamingStrategy_2
+var y = {};
+
+"use strict";
+
+Object.defineProperty(y, "__esModule", {
+    value: true
 });
 
-Object.defineProperty(exports, "DeleteQueryBuilder", {
+var O = {};
+
+"use strict";
+
+Object.defineProperty(O, "__esModule", {
+    value: true
+});
+
+var f = {};
+
+"use strict";
+
+Object.defineProperty(f, "__esModule", {
+    value: true
+});
+
+var b = {};
+
+"use strict";
+
+Object.defineProperty(b, "__esModule", {
+    value: true
+});
+
+var g = {};
+
+"use strict";
+
+Object.defineProperty(g, "__esModule", {
+    value: true
+});
+
+var v = {};
+
+"use strict";
+
+Object.defineProperty(v, "__esModule", {
+    value: true
+});
+
+var _ = v.And = j;
+
+const m = t.FindOperator;
+
+function j(...e) {
+    return new m.FindOperator("and", e, true, true);
+}
+
+var P = {};
+
+"use strict";
+
+Object.defineProperty(P, "__esModule", {
+    value: true
+});
+
+var h = P.Any = x;
+
+const M = t.FindOperator;
+
+function x(e) {
+    return new M.FindOperator("any", e);
+}
+
+var E = {};
+
+"use strict";
+
+Object.defineProperty(E, "__esModule", {
+    value: true
+});
+
+var R = E.ArrayContainedBy = S;
+
+const B = t.FindOperator;
+
+function S(e) {
+    return new B.FindOperator("arrayContainedBy", e);
+}
+
+var F = {};
+
+"use strict";
+
+Object.defineProperty(F, "__esModule", {
+    value: true
+});
+
+var I = F.ArrayContains = T;
+
+const q = t.FindOperator;
+
+function T(e) {
+    return new q.FindOperator("arrayContains", e);
+}
+
+var C = {};
+
+"use strict";
+
+Object.defineProperty(C, "__esModule", {
+    value: true
+});
+
+var N = C.ArrayOverlap = D;
+
+const k = t.FindOperator;
+
+function D(e) {
+    return new k.FindOperator("arrayOverlap", e);
+}
+
+var w = {};
+
+"use strict";
+
+Object.defineProperty(w, "__esModule", {
+    value: true
+});
+
+var L = w.Between = Q;
+
+const A = t.FindOperator;
+
+function Q(e, t) {
+    return new A.FindOperator("between", [ e, t ], true, true);
+}
+
+var U = {};
+
+var K = {};
+
+"use strict";
+
+Object.defineProperty(K, "__esModule", {
+    value: true
+});
+
+exports.EqualOperator = K.EqualOperator = void 0;
+
+const X = t.FindOperator;
+
+class EqualOperator extends X.FindOperator {
+    constructor(e) {
+        super("equal", e);
+        this["@instanceof"] = Symbol.for("EqualOperator");
+    }
+}
+
+exports.EqualOperator = K.EqualOperator = EqualOperator;
+
+"use strict";
+
+Object.defineProperty(U, "__esModule", {
+    value: true
+});
+
+var z = U.Equal = G;
+
+const Z = K;
+
+function G(e) {
+    return new Z.EqualOperator(e);
+}
+
+var J = {};
+
+"use strict";
+
+Object.defineProperty(J, "__esModule", {
+    value: true
+});
+
+var H = J.IsNull = W;
+
+const V = t.FindOperator;
+
+function W() {
+    return new V.FindOperator("isNull", undefined, false);
+}
+
+var Y = {};
+
+"use strict";
+
+Object.defineProperty(Y, "__esModule", {
+    value: true
+});
+
+var $ = Y.LessThan = te;
+
+const ee = t.FindOperator;
+
+function te(e) {
+    return new ee.FindOperator("lessThan", e);
+}
+
+var re = {};
+
+"use strict";
+
+Object.defineProperty(re, "__esModule", {
+    value: true
+});
+
+var oe = re.LessThanOrEqual = se;
+
+const ne = t.FindOperator;
+
+function se(e) {
+    return new ne.FindOperator("lessThanOrEqual", e);
+}
+
+var ie = {};
+
+"use strict";
+
+Object.defineProperty(ie, "__esModule", {
+    value: true
+});
+
+var ue = ie.ILike = ce;
+
+const ae = t.FindOperator;
+
+function ce(e) {
+    return new ae.FindOperator("ilike", e);
+}
+
+var de = {};
+
+"use strict";
+
+Object.defineProperty(de, "__esModule", {
+    value: true
+});
+
+var le = de.Like = ye;
+
+const pe = t.FindOperator;
+
+function ye(e) {
+    return new pe.FindOperator("like", e);
+}
+
+var Oe = {};
+
+"use strict";
+
+Object.defineProperty(Oe, "__esModule", {
+    value: true
+});
+
+var fe = Oe.MoreThan = ge;
+
+const be = t.FindOperator;
+
+function ge(e) {
+    return new be.FindOperator("moreThan", e);
+}
+
+var ve = {};
+
+"use strict";
+
+Object.defineProperty(ve, "__esModule", {
+    value: true
+});
+
+var _e = ve.MoreThanOrEqual = je;
+
+const me = t.FindOperator;
+
+function je(e) {
+    return new me.FindOperator("moreThanOrEqual", e);
+}
+
+var Pe = {};
+
+"use strict";
+
+Object.defineProperty(Pe, "__esModule", {
+    value: true
+});
+
+var he = Pe.Not = xe;
+
+const Me = t.FindOperator;
+
+function xe(e) {
+    return new Me.FindOperator("not", e);
+}
+
+var Ee = {};
+
+"use strict";
+
+Object.defineProperty(Ee, "__esModule", {
+    value: true
+});
+
+var Re = Ee.Raw = Se;
+
+const Be = t.FindOperator;
+
+function Se(e, t) {
+    if (typeof e !== "function") {
+        return new Be.FindOperator("raw", e, false);
+    }
+    return new Be.FindOperator("raw", [], true, true, e, t);
+}
+
+var Fe = {};
+
+"use strict";
+
+Object.defineProperty(Fe, "__esModule", {
+    value: true
+});
+
+var Ie = Fe.JsonContains = Te;
+
+const qe = t.FindOperator;
+
+function Te(e) {
+    return new qe.FindOperator("jsonContains", e);
+}
+
+var Ce = {};
+
+"use strict";
+
+Object.defineProperty(Ce, "__esModule", {
+    value: true
+});
+
+var Ne = {};
+
+"use strict";
+
+Object.defineProperty(Ne, "__esModule", {
+    value: true
+});
+
+var ke = {};
+
+"use strict";
+
+Object.defineProperty(ke, "__esModule", {
+    value: true
+});
+
+var De = {};
+
+"use strict";
+
+Object.defineProperty(De, "__esModule", {
+    value: true
+});
+
+var we = {};
+
+"use strict";
+
+Object.defineProperty(we, "__esModule", {
+    value: true
+});
+
+var Le = {};
+
+"use strict";
+
+Object.defineProperty(Le, "__esModule", {
+    value: true
+});
+
+var Ae = {};
+
+"use strict";
+
+Object.defineProperty(Ae, "__esModule", {
+    value: true
+});
+
+var Qe = {};
+
+"use strict";
+
+Object.defineProperty(Qe, "__esModule", {
+    value: true
+});
+
+var Ue = {};
+
+"use strict";
+
+Object.defineProperty(Ue, "__esModule", {
+    value: true
+});
+
+var Ke = {};
+
+"use strict";
+
+Object.defineProperty(Ke, "__esModule", {
+    value: true
+});
+
+var Xe = {};
+
+"use strict";
+
+Object.defineProperty(Xe, "__esModule", {
+    value: true
+});
+
+var ze = {};
+
+"use strict";
+
+Object.defineProperty(ze, "__esModule", {
+    value: true
+});
+
+var Ze = t.requireEntityManager();
+
+const Ge = e.getDefaultExportFromCjs(Ze);
+
+var Je = t.requireAbstractRepository();
+
+const He = e.getDefaultExportFromCjs(Je);
+
+var Ve = {};
+
+"use strict";
+
+Object.defineProperty(Ve, "__esModule", {
+    value: true
+});
+
+exports.BaseEntity = Ve.BaseEntity = void 0;
+
+const We = t.ObjectUtils;
+
+class BaseEntity {
+    hasId() {
+        const e = this.constructor;
+        return e.getRepository().hasId(this);
+    }
+    save(e) {
+        const t = this.constructor;
+        return t.getRepository().save(this, e);
+    }
+    remove(e) {
+        const t = this.constructor;
+        return t.getRepository().remove(this, e);
+    }
+    softRemove(e) {
+        const t = this.constructor;
+        return t.getRepository().softRemove(this, e);
+    }
+    recover(e) {
+        const t = this.constructor;
+        return t.getRepository().recover(this, e);
+    }
+    async reload() {
+        const e = this.constructor;
+        const t = e.getRepository().metadata.getEntityIdMap(this);
+        if (!t) {
+            throw new Error(`Entity doesn't have id-s set, cannot reload entity`);
+        }
+        const r = await e.getRepository().findOneByOrFail(t);
+        We.ObjectUtils.assign(this, r);
+    }
+    static useDataSource(e) {
+        this.dataSource = e;
+    }
+    static getRepository() {
+        const e = this.dataSource;
+        if (!e) throw new Error(`DataSource is not set for this entity.`);
+        return e.getRepository(this);
+    }
+    static get target() {
+        return this.getRepository().target;
+    }
+    static hasId(e) {
+        return this.getRepository().hasId(e);
+    }
+    static getId(e) {
+        return this.getRepository().getId(e);
+    }
+    static createQueryBuilder(e) {
+        return this.getRepository().createQueryBuilder(e);
+    }
+    static create(e) {
+        return this.getRepository().create(e);
+    }
+    static merge(e, ...t) {
+        return this.getRepository().merge(e, ...t);
+    }
+    static preload(e) {
+        const t = this.getRepository();
+        return t.preload(e);
+    }
+    static save(e, t) {
+        return this.getRepository().save(e, t);
+    }
+    static remove(e, t) {
+        return this.getRepository().remove(e, t);
+    }
+    static softRemove(e, t) {
+        return this.getRepository().softRemove(e, t);
+    }
+    static insert(e) {
+        return this.getRepository().insert(e);
+    }
+    static update(e, t) {
+        return this.getRepository().update(e, t);
+    }
+    static upsert(e, t) {
+        return this.getRepository().upsert(e, t);
+    }
+    static delete(e) {
+        return this.getRepository().delete(e);
+    }
+    static exists(e) {
+        return this.getRepository().exists(e);
+    }
+    static existsBy(e) {
+        return this.getRepository().existsBy(e);
+    }
+    static count(e) {
+        return this.getRepository().count(e);
+    }
+    static countBy(e) {
+        return this.getRepository().countBy(e);
+    }
+    static sum(e, t) {
+        return this.getRepository().sum(e, t);
+    }
+    static average(e, t) {
+        return this.getRepository().average(e, t);
+    }
+    static minimum(e, t) {
+        return this.getRepository().minimum(e, t);
+    }
+    static maximum(e, t) {
+        return this.getRepository().maximum(e, t);
+    }
+    static find(e) {
+        return this.getRepository().find(e);
+    }
+    static findBy(e) {
+        return this.getRepository().findBy(e);
+    }
+    static findAndCount(e) {
+        return this.getRepository().findAndCount(e);
+    }
+    static findAndCountBy(e) {
+        return this.getRepository().findAndCountBy(e);
+    }
+    static findByIds(e) {
+        return this.getRepository().findByIds(e);
+    }
+    static findOne(e) {
+        return this.getRepository().findOne(e);
+    }
+    static findOneBy(e) {
+        return this.getRepository().findOneBy(e);
+    }
+    static findOneById(e) {
+        return this.getRepository().findOneById(e);
+    }
+    static findOneOrFail(e) {
+        return this.getRepository().findOneOrFail(e);
+    }
+    static findOneByOrFail(e) {
+        return this.getRepository().findOneByOrFail(e);
+    }
+    static query(e, t) {
+        return this.getRepository().query(e, t);
+    }
+    static clear() {
+        return this.getRepository().clear();
+    }
+}
+
+exports.BaseEntity = Ve.BaseEntity = BaseEntity;
+
+var Ye = {};
+
+"use strict";
+
+Object.defineProperty(Ye, "__esModule", {
+    value: true
+});
+
+var $e = {};
+
+"use strict";
+
+Object.defineProperty($e, "__esModule", {
+    value: true
+});
+
+var et = {};
+
+"use strict";
+
+Object.defineProperty(et, "__esModule", {
+    value: true
+});
+
+var tt = {};
+
+"use strict";
+
+Object.defineProperty(tt, "__esModule", {
+    value: true
+});
+
+var rt = {};
+
+"use strict";
+
+Object.defineProperty(rt, "__esModule", {
+    value: true
+});
+
+var ot = {};
+
+"use strict";
+
+Object.defineProperty(ot, "__esModule", {
+    value: true
+});
+
+var nt = {};
+
+"use strict";
+
+Object.defineProperty(nt, "__esModule", {
+    value: true
+});
+
+var st = {};
+
+"use strict";
+
+Object.defineProperty(st, "__esModule", {
+    value: true
+});
+
+var it = {};
+
+"use strict";
+
+Object.defineProperty(it, "__esModule", {
+    value: true
+});
+
+var ut = {};
+
+"use strict";
+
+Object.defineProperty(ut, "__esModule", {
+    value: true
+});
+
+var at = {};
+
+var ct = {};
+
+"use strict";
+
+Object.defineProperty(ct, "__esModule", {
+    value: true
+});
+
+var dt = ct.BSON = void 0;
+
+(function(e) {
+    "use strict";
+    Object.defineProperty(e, "__esModule", {
+        value: true
+    });
+    e.Timestamp = e.serialize = e.ObjectId = e.MinKey = e.MaxKey = e.Long = e.Int32 = e.Double = e.deserialize = e.Decimal128 = e.DBRef = e.Code = e.BSONType = e.BSONSymbol = e.BSONRegExp = e.BSON = e.Binary = void 0;
+    const t = ct;
+    Object.defineProperty(e, "BSON", {
+        enumerable: true,
+        get: function() {
+            return t.BSON;
+        }
+    });
+    Object.defineProperty(e, "BSONRegExp", {
+        enumerable: true,
+        get: function() {
+            return t.BSONRegExp;
+        }
+    });
+    Object.defineProperty(e, "BSONSymbol", {
+        enumerable: true,
+        get: function() {
+            return t.BSONSymbol;
+        }
+    });
+    Object.defineProperty(e, "BSONType", {
+        enumerable: true,
+        get: function() {
+            return t.BSONType;
+        }
+    });
+    Object.defineProperty(e, "Binary", {
+        enumerable: true,
+        get: function() {
+            return t.Binary;
+        }
+    });
+    Object.defineProperty(e, "Code", {
+        enumerable: true,
+        get: function() {
+            return t.Code;
+        }
+    });
+    Object.defineProperty(e, "DBRef", {
+        enumerable: true,
+        get: function() {
+            return t.DBRef;
+        }
+    });
+    Object.defineProperty(e, "Decimal128", {
+        enumerable: true,
+        get: function() {
+            return t.Decimal128;
+        }
+    });
+    Object.defineProperty(e, "Double", {
+        enumerable: true,
+        get: function() {
+            return t.Double;
+        }
+    });
+    Object.defineProperty(e, "Int32", {
+        enumerable: true,
+        get: function() {
+            return t.Int32;
+        }
+    });
+    Object.defineProperty(e, "Long", {
+        enumerable: true,
+        get: function() {
+            return t.Long;
+        }
+    });
+    Object.defineProperty(e, "MaxKey", {
+        enumerable: true,
+        get: function() {
+            return t.MaxKey;
+        }
+    });
+    Object.defineProperty(e, "MinKey", {
+        enumerable: true,
+        get: function() {
+            return t.MinKey;
+        }
+    });
+    Object.defineProperty(e, "ObjectId", {
+        enumerable: true,
+        get: function() {
+            return t.ObjectId;
+        }
+    });
+    Object.defineProperty(e, "Timestamp", {
+        enumerable: true,
+        get: function() {
+            return t.Timestamp;
+        }
+    });
+    Object.defineProperty(e, "deserialize", {
+        enumerable: true,
+        get: function() {
+            return t.deserialize;
+        }
+    });
+    Object.defineProperty(e, "serialize", {
+        enumerable: true,
+        get: function() {
+            return t.serialize;
+        }
+    });
+})(at);
+
+const lt = e.getDefaultExportFromCjs(at);
+
+var pt = {};
+
+"use strict";
+
+Object.defineProperty(pt, "__esModule", {
+    value: true
+});
+
+var yt = {};
+
+"use strict";
+
+Object.defineProperty(yt, "__esModule", {
+    value: true
+});
+
+var Ot = {};
+
+"use strict";
+
+Object.defineProperty(Ot, "__esModule", {
+    value: true
+});
+
+var ft = {};
+
+"use strict";
+
+Object.defineProperty(ft, "__esModule", {
+    value: true
+});
+
+exports.NotBrackets = ft.NotBrackets = void 0;
+
+const bt = t.Brackets;
+
+class NotBrackets extends bt.Brackets {
+    constructor() {
+        super(...arguments);
+        this["@instanceof"] = Symbol.for("NotBrackets");
+    }
+}
+
+exports.NotBrackets = ft.NotBrackets = NotBrackets;
+
+var gt = t.requireMongoEntityManager();
+
+const vt = e.getDefaultExportFromCjs(gt);
+
+var _t = {};
+
+"use strict";
+
+Object.defineProperty(_t, "__esModule", {
+    value: true
+});
+
+exports.LegacyOracleNamingStrategy = _t.LegacyOracleNamingStrategy = void 0;
+
+const mt = t.RandomGenerator;
+
+const jt = t.DefaultNamingStrategy;
+
+const Pt = t.error;
+
+class LegacyOracleNamingStrategy extends jt.DefaultNamingStrategy {
+    constructor(e = "hash") {
+        super();
+        this.IDENTIFIER_MAX_SIZE = 30;
+        this.DEFAULT_COLUMN_PREFIX = "COL_";
+        this.shortenStrategy = e;
+    }
+    columnName(e, t, r) {
+        const o = super.columnName(e, t, r);
+        if (this.shortenStrategy === "truncate") {
+            return this.truncateIdentifier(o);
+        } else if (this.shortenStrategy === "hash") {
+            return this.hashIdentifier(o, this.DEFAULT_COLUMN_PREFIX);
+        } else {
+            throw new Pt.TypeORMError(`Invalid shortenStrategy`);
+        }
+    }
+    hashIdentifier(e, t) {
+        if (t.length >= this.IDENTIFIER_MAX_SIZE) {
+            throw new Pt.TypeORMError(`Prefix must be shorter than IDENTIFIER_MAX_SIZE`);
+        }
+        return t + mt.RandomGenerator.sha1(e).substring(0, this.IDENTIFIER_MAX_SIZE - t.length);
+    }
+    truncateIdentifier(e) {
+        if (e.length > this.IDENTIFIER_MAX_SIZE) {
+            return e.substring(0, this.IDENTIFIER_MAX_SIZE);
+        } else {
+            return e;
+        }
+    }
+}
+
+exports.LegacyOracleNamingStrategy = _t.LegacyOracleNamingStrategy = LegacyOracleNamingStrategy;
+
+var ht = {};
+
+"use strict";
+
+Object.defineProperty(ht, "__esModule", {
+    value: true
+});
+
+exports.EntitySchema = ht.EntitySchema = void 0;
+
+class EntitySchema {
+    constructor(e) {
+        this.options = e;
+        this["@instanceof"] = Symbol.for("EntitySchema");
+    }
+}
+
+exports.EntitySchema = ht.EntitySchema = EntitySchema;
+
+var Mt = {};
+
+"use strict";
+
+Object.defineProperty(Mt, "__esModule", {
+    value: true
+});
+
+exports.EntitySchemaEmbeddedColumnOptions = Mt.EntitySchemaEmbeddedColumnOptions = void 0;
+
+class EntitySchemaEmbeddedColumnOptions {}
+
+exports.EntitySchemaEmbeddedColumnOptions = Mt.EntitySchemaEmbeddedColumnOptions = EntitySchemaEmbeddedColumnOptions;
+
+var xt = {};
+
+"use strict";
+
+Object.defineProperty(xt, "__esModule", {
+    value: true
+});
+
+exports.EntitySchemaOptions = xt.EntitySchemaOptions = void 0;
+
+class EntitySchemaOptions {}
+
+exports.EntitySchemaOptions = xt.EntitySchemaOptions = EntitySchemaOptions;
+
+Object.defineProperty(exports, "AbstractLogger", {
     enumerable: true,
-    get: () => r.DeleteQueryBuilder_2
+    get: () => t.AbstractLogger_2
 });
 
-Object.defineProperty(exports, "DeleteResult", {
+Object.defineProperty(exports, "AdvancedConsoleLogger", {
     enumerable: true,
-    get: () => r.DeleteResult_2
+    get: () => t.AdvancedConsoleLogger_2
 });
 
-Object.defineProperty(exports, "EntityMetadata", {
+Object.defineProperty(exports, "Brackets", {
     enumerable: true,
-    get: () => r.EntityMetadata_2
+    get: () => t.Brackets_2
 });
 
-Object.defineProperty(exports, "EntitySchema", {
+Object.defineProperty(exports, "ConnectionOptionsReader", {
     enumerable: true,
-    get: () => r.EntitySchema_2
+    get: () => t.ConnectionOptionsReader_2
 });
 
-Object.defineProperty(exports, "EntitySchemaEmbeddedColumnOptions", {
+Object.defineProperty(exports, "DefaultNamingStrategy", {
     enumerable: true,
-    get: () => r.EntitySchemaEmbeddedColumnOptions_2
+    get: () => t.DefaultNamingStrategy_2
 });
 
-Object.defineProperty(exports, "EntitySchemaOptions", {
+Object.defineProperty(exports, "DeleteQueryBuilder", {
     enumerable: true,
-    get: () => r.EntitySchemaOptions_2
+    get: () => t.DeleteQueryBuilder_2
 });
 
-exports.Equal = r.Equal_2;
+Object.defineProperty(exports, "DeleteResult", {
+    enumerable: true,
+    get: () => t.DeleteResult_2
+});
 
-Object.defineProperty(exports, "EqualOperator", {
+Object.defineProperty(exports, "EntityMetadata", {
     enumerable: true,
-    get: () => r.EqualOperator_2
+    get: () => t.EntityMetadata_2
 });
 
 Object.defineProperty(exports, "FileLogger", {
     enumerable: true,
-    get: () => r.FileLogger_2
+    get: () => t.FileLogger_2
 });
 
 Object.defineProperty(exports, "FindOperator", {
     enumerable: true,
-    get: () => r.FindOperator_2
+    get: () => t.FindOperator_2
 });
 
 Object.defineProperty(exports, "FindOptionsUtils", {
     enumerable: true,
-    get: () => r.FindOptionsUtils_2
+    get: () => t.FindOptionsUtils_2
 });
 
-exports.ILike = r.ILike_2;
-
-exports.In = r.In_2;
+exports.In = t.In_2;
 
 Object.defineProperty(exports, "InsertQueryBuilder", {
     enumerable: true,
-    get: () => r.InsertQueryBuilder_2
+    get: () => t.InsertQueryBuilder_2
 });
 
 Object.defineProperty(exports, "InsertResult", {
     enumerable: true,
-    get: () => r.InsertResult_2
+    get: () => t.InsertResult_2
 });
 
 Object.defineProperty(exports, "InstanceChecker", {
     enumerable: true,
-    get: () => r.InstanceChecker_2
+    get: () => t.InstanceChecker_2
 });
 
-exports.IsNull = r.IsNull_2;
-
-exports.JsonContains = r.JsonContains_2;
-
-Object.defineProperty(exports, "LegacyOracleNamingStrategy", {
-    enumerable: true,
-    get: () => r.LegacyOracleNamingStrategy_2
-});
-
-exports.LessThan = r.LessThan_2;
-
-exports.LessThanOrEqual = r.LessThanOrEqual_2;
-
-exports.Like = r.Like_2;
-
 Object.defineProperty(exports, "Migration", {
     enumerable: true,
-    get: () => r.Migration_2
+    get: () => t.Migration_2
 });
 
 Object.defineProperty(exports, "MigrationExecutor", {
     enumerable: true,
-    get: () => r.MigrationExecutor_2
+    get: () => t.MigrationExecutor_2
 });
 
 Object.defineProperty(exports, "MongoRepository", {
     enumerable: true,
-    get: () => r.MongoRepository_2
+    get: () => t.MongoRepository_2
 });
 
-exports.MoreThan = r.MoreThan_2;
-
-exports.MoreThanOrEqual = r.MoreThanOrEqual_2;
-
 Object.defineProperty(exports, "MssqlParameter", {
     enumerable: true,
-    get: () => r.MssqlParameter_2
-});
-
-exports.Not = r.Not_2;
-
-Object.defineProperty(exports, "NotBrackets", {
-    enumerable: true,
-    get: () => r.NotBrackets_2
+    get: () => t.MssqlParameter_2
 });
 
 Object.defineProperty(exports, "QueryBuilder", {
     enumerable: true,
-    get: () => r.QueryBuilder_2
+    get: () => t.QueryBuilder_2
 });
 
 Object.defineProperty(exports, "QueryResult", {
     enumerable: true,
-    get: () => r.QueryResult_2
+    get: () => t.QueryResult_2
 });
 
-exports.Raw = r.Raw_2;
-
 Object.defineProperty(exports, "RelationQueryBuilder", {
     enumerable: true,
-    get: () => r.RelationQueryBuilder_2
+    get: () => t.RelationQueryBuilder_2
 });
 
 Object.defineProperty(exports, "Repository", {
     enumerable: true,
-    get: () => r.Repository_2
+    get: () => t.Repository_2
 });
 
 Object.defineProperty(exports, "SelectQueryBuilder", {
     enumerable: true,
-    get: () => r.SelectQueryBuilder_2
+    get: () => t.SelectQueryBuilder_2
 });
 
 Object.defineProperty(exports, "SimpleConsoleLogger", {
     enumerable: true,
-    get: () => r.SimpleConsoleLogger_2
+    get: () => t.SimpleConsoleLogger_2
 });
 
 Object.defineProperty(exports, "Table", {
     enumerable: true,
-    get: () => r.Table_2
+    get: () => t.Table_2
 });
 
 Object.defineProperty(exports, "TableCheck", {
     enumerable: true,
-    get: () => r.TableCheck_2
+    get: () => t.TableCheck_2
 });
 
 Object.defineProperty(exports, "TableColumn", {
     enumerable: true,
-    get: () => r.TableColumn_2
+    get: () => t.TableColumn_2
 });
 
 Object.defineProperty(exports, "TableExclusion", {
     enumerable: true,
-    get: () => r.TableExclusion_2
+    get: () => t.TableExclusion_2
 });
 
 Object.defineProperty(exports, "TableForeignKey", {
     enumerable: true,
-    get: () => r.TableForeignKey_2
+    get: () => t.TableForeignKey_2
 });
 
 Object.defineProperty(exports, "TableIndex", {
     enumerable: true,
-    get: () => r.TableIndex_2
+    get: () => t.TableIndex_2
 });
 
 Object.defineProperty(exports, "TableUnique", {
     enumerable: true,
-    get: () => r.TableUnique_2
+    get: () => t.TableUnique_2
 });
 
 Object.defineProperty(exports, "TreeRepository", {
     enumerable: true,
-    get: () => r.TreeRepository_2
+    get: () => t.TreeRepository_2
 });
 
 Object.defineProperty(exports, "TreeRepositoryUtils", {
     enumerable: true,
-    get: () => r.TreeRepositoryUtils_2
+    get: () => t.TreeRepositoryUtils_2
 });
 
 Object.defineProperty(exports, "UpdateQueryBuilder", {
     enumerable: true,
-    get: () => r.UpdateQueryBuilder_2
+    get: () => t.UpdateQueryBuilder_2
 });
 
 Object.defineProperty(exports, "UpdateResult", {
     enumerable: true,
-    get: () => r.UpdateResult_2
+    get: () => t.UpdateResult_2
 });
 
-exports.getFromContainer = r.getFromContainer_1;
+exports.getFromContainer = t.getFromContainer_1;
+
+exports.useContainer = t.useContainer_1;
+
+exports.And = _;
+
+exports.Any = h;
+
+exports.ArrayContainedBy = R;
+
+exports.ArrayContains = I;
+
+exports.ArrayOverlap = N;
+
+exports.Between = L;
+
+exports.DataSource = r.DataSourceExports.DataSource;
+
+exports.Equal = z;
+
+exports.ILike = ue;
+
+exports.IsNull = H;
+
+exports.JsonContains = Ie;
+
+exports.LessThan = $;
+
+exports.LessThanOrEqual = oe;
+
+exports.Like = le;
+
+exports.MongoEntityManager = gt.MongoEntityManager;
+
+exports.MoreThan = fe;
 
-exports.useContainer = r.useContainer_1;
+exports.MoreThanOrEqual = _e;
 
-exports.DataSource = t.DataSourceExports.DataSource;
+exports.Not = he;
 
-exports.MongoEntityManager = p.MongoEntityManager;
+exports.Raw = Re;