lakutata 2.0.80 → 2.0.81

package/orm.cjs

@@ -8,19 +8,21 @@ require("./vendor/Package.4.cjs");
 
 const e = require("./vendor/Package.5.cjs");
 
-const t = require("./vendor/Package.102.cjs");
+const r = require("./vendor/Package.112.cjs");
 
-const r = require("./vendor/Package.10.cjs");
+const t = require("./vendor/Package.11.cjs");
 
 require("./vendor/Package.12.cjs");
 
 require("./vendor/Package.1.cjs");
 
+require("fs/promises");
+
 require("./vendor/Package.62.cjs");
 
-require("./vendor/Package.11.cjs");
+require("./vendor/Package.13.cjs");
 
-require("./vendor/Package.122.cjs");
+require("./vendor/Package.14.cjs");
 
 require("buffer");
 
@@ -30,30 +32,28 @@ require("url");
 
 require("tty");
 
+require("./vendor/Package.10.cjs");
+
+require("util");
+
+require("stream");
+
+require("./vendor/Package.7.cjs");
+
 require("./vendor/Package.8.cjs");
 
 require("os");
 
 require("path");
 
-require("util");
-
-require("stream");
-
 require("events");
 
 require("fs");
 
-require("./vendor/Package.7.cjs");
-
-require("./vendor/Package.13.cjs");
+require("./vendor/Package.15.cjs");
 
 require("crypto");
 
-require("fs/promises");
-
-require("./vendor/Package.63.cjs");
-
 require("node:url");
 
 require("node:path");
@@ -68,1237 +68,1774 @@ require("node:stream");
 
 require("node:string_decoder");
 
-var o = t.requireGlobals();
+var o = r.requireGlobals();
 
 const n = e.getDefaultExportFromCjs(o);
 
-var s = {};
+var u = r.requireContainer();
 
-"use strict";
-
-Object.defineProperty(s, "__esModule", {
-    value: true
-});
+const s = e.getDefaultExportFromCjs(u);
 
 var i = {};
 
-"use strict";
-
-Object.defineProperty(i, "__esModule", {
-    value: true
-});
-
-var u = {};
+var a;
 
-"use strict";
+function c() {
+    if (a) return i;
+    a = 1;
+    "use strict";
+    Object.defineProperty(i, "__esModule", {
+        value: true
+    });
+    return i;
+}
 
-Object.defineProperty(u, "__esModule", {
-    value: true
-});
+var f = c();
 
-var a = {};
+const l = e.getDefaultExportFromCjs(f);
 
-"use strict";
+var p = {};
 
-Object.defineProperty(a, "__esModule", {
-    value: true
-});
+var v;
 
-var c = {};
+function d() {
+    if (v) return p;
+    v = 1;
+    "use strict";
+    Object.defineProperty(p, "__esModule", {
+        value: true
+    });
+    return p;
+}
 
-"use strict";
+var y = d();
 
-Object.defineProperty(c, "__esModule", {
-    value: true
-});
+const g = e.getDefaultExportFromCjs(y);
 
-var d = {};
+var m = {};
 
-"use strict";
+var j;
 
-Object.defineProperty(d, "__esModule", {
-    value: true
-});
+function O() {
+    if (j) return m;
+    j = 1;
+    "use strict";
+    Object.defineProperty(m, "__esModule", {
+        value: true
+    });
+    return m;
+}
 
-var l = {};
+var E = O();
 
-"use strict";
+const F = e.getDefaultExportFromCjs(E);
 
-Object.defineProperty(l, "__esModule", {
-    value: true
-});
+var x = {};
 
-var p = {};
+var _;
 
-"use strict";
+function C() {
+    if (_) return x;
+    _ = 1;
+    "use strict";
+    Object.defineProperty(x, "__esModule", {
+        value: true
+    });
+    return x;
+}
 
-Object.defineProperty(p, "__esModule", {
-    value: true
-});
+var D = C();
 
-var y = {};
+const b = e.getDefaultExportFromCjs(D);
 
-"use strict";
+var h = {};
 
-Object.defineProperty(y, "__esModule", {
-    value: true
-});
+var q;
 
-var O = {};
+function M() {
+    if (q) return h;
+    q = 1;
+    "use strict";
+    Object.defineProperty(h, "__esModule", {
+        value: true
+    });
+    return h;
+}
 
-"use strict";
+var P = M();
 
-Object.defineProperty(O, "__esModule", {
-    value: true
-});
+const R = e.getDefaultExportFromCjs(P);
 
-var f = {};
+var B = {};
 
-"use strict";
+var S;
 
-Object.defineProperty(f, "__esModule", {
-    value: true
-});
+function I() {
+    if (S) return B;
+    S = 1;
+    "use strict";
+    Object.defineProperty(B, "__esModule", {
+        value: true
+    });
+    return B;
+}
 
-var b = {};
+var N = I();
 
-"use strict";
+const T = e.getDefaultExportFromCjs(N);
 
-Object.defineProperty(b, "__esModule", {
-    value: true
-});
+var k = r.requireError();
 
-var g = {};
+const w = e.getDefaultExportFromCjs(k);
 
-"use strict";
+var Q = {};
 
-Object.defineProperty(g, "__esModule", {
-    value: true
-});
+var L;
 
-var v = {};
+function A() {
+    if (L) return Q;
+    L = 1;
+    "use strict";
+    Object.defineProperty(Q, "__esModule", {
+        value: true
+    });
+    return Q;
+}
 
-"use strict";
+var U = A();
 
-Object.defineProperty(v, "__esModule", {
-    value: true
-});
+const X = e.getDefaultExportFromCjs(U);
 
-var _ = v.And = j;
+var K = {};
 
-const m = t.FindOperator;
+var z;
 
-function j(...e) {
-    return new m.FindOperator("and", e, true, true);
+function Z() {
+    if (z) return K;
+    z = 1;
+    "use strict";
+    Object.defineProperty(K, "__esModule", {
+        value: true
+    });
+    return K;
 }
 
-var P = {};
-
-"use strict";
+var G = Z();
 
-Object.defineProperty(P, "__esModule", {
-    value: true
-});
+const J = e.getDefaultExportFromCjs(G);
 
-var h = P.Any = x;
+var H = {};
 
-const M = t.FindOperator;
+var V;
 
-function x(e) {
-    return new M.FindOperator("any", e);
+function W() {
+    if (V) return H;
+    V = 1;
+    "use strict";
+    Object.defineProperty(H, "__esModule", {
+        value: true
+    });
+    return H;
 }
 
-var E = {};
+var Y = W();
 
-"use strict";
-
-Object.defineProperty(E, "__esModule", {
-    value: true
-});
+const $ = e.getDefaultExportFromCjs(Y);
 
-var R = E.ArrayContainedBy = S;
+var ee = {};
 
-const B = t.FindOperator;
+var re;
 
-function S(e) {
-    return new B.FindOperator("arrayContainedBy", e);
+function te() {
+    if (re) return ee;
+    re = 1;
+    "use strict";
+    Object.defineProperty(ee, "__esModule", {
+        value: true
+    });
+    return ee;
 }
 
-var F = {};
-
-"use strict";
+var oe = te();
 
-Object.defineProperty(F, "__esModule", {
-    value: true
-});
+const ne = e.getDefaultExportFromCjs(oe);
 
-var I = F.ArrayContains = T;
+var ue = {};
 
-const q = t.FindOperator;
+var se;
 
-function T(e) {
-    return new q.FindOperator("arrayContains", e);
+function ie() {
+    if (se) return ue;
+    se = 1;
+    "use strict";
+    Object.defineProperty(ue, "__esModule", {
+        value: true
+    });
+    return ue;
 }
 
-var C = {};
+var ae = ie();
 
-"use strict";
-
-Object.defineProperty(C, "__esModule", {
-    value: true
-});
+const ce = e.getDefaultExportFromCjs(ae);
 
-var N = C.ArrayOverlap = k;
+var fe = {};
 
-const D = t.FindOperator;
+var le;
 
-function k(e) {
-    return new D.FindOperator("arrayOverlap", e);
+function pe() {
+    if (le) return fe;
+    le = 1;
+    "use strict";
+    Object.defineProperty(fe, "__esModule", {
+        value: true
+    });
+    return fe;
 }
 
-var w = {};
-
-"use strict";
+var ve = pe();
 
-Object.defineProperty(w, "__esModule", {
-    value: true
-});
+const de = e.getDefaultExportFromCjs(ve);
 
-var L = w.Between = Q;
+var ye = {};
 
-const A = t.FindOperator;
+var ge;
 
-function Q(e, t) {
-    return new A.FindOperator("between", [ e, t ], true, true);
+function me() {
+    if (ge) return ye;
+    ge = 1;
+    "use strict";
+    Object.defineProperty(ye, "__esModule", {
+        value: true
+    });
+    return ye;
 }
 
-var U = {};
-
-var K = {};
-
-"use strict";
+var je = me();
 
-Object.defineProperty(K, "__esModule", {
-    value: true
-});
+const Oe = e.getDefaultExportFromCjs(je);
 
-exports.EqualOperator = K.EqualOperator = void 0;
+var Ee = {};
 
-const X = t.FindOperator;
+var Fe;
 
-class EqualOperator extends X.FindOperator {
-    constructor(e) {
-        super("equal", e);
-        this["@instanceof"] = Symbol.for("EqualOperator");
+function xe() {
+    if (Fe) return Ee;
+    Fe = 1;
+    "use strict";
+    Object.defineProperty(Ee, "__esModule", {
+        value: true
+    });
+    Ee.And = t;
+    const e = r.requireFindOperator();
+    function t(...r) {
+        return new e.FindOperator("and", r, true, true);
     }
+    return Ee;
 }
 
-exports.EqualOperator = K.EqualOperator = EqualOperator;
-
-"use strict";
+var _e = xe();
 
-Object.defineProperty(U, "__esModule", {
-    value: true
-});
+const Ce = e.getDefaultExportFromCjs(_e);
 
-var z = U.Equal = G;
+var De = {};
 
-const Z = K;
+var be;
 
-function G(e) {
-    return new Z.EqualOperator(e);
+function he() {
+    if (be) return De;
+    be = 1;
+    "use strict";
+    Object.defineProperty(De, "__esModule", {
+        value: true
+    });
+    De.Any = t;
+    const e = r.requireFindOperator();
+    function t(r) {
+        return new e.FindOperator("any", r);
+    }
+    return De;
 }
 
-var J = {};
-
-"use strict";
+var qe = he();
 
-Object.defineProperty(J, "__esModule", {
-    value: true
-});
+const Me = e.getDefaultExportFromCjs(qe);
 
-var H = J.IsNull = W;
+var Pe = {};
 
-const V = t.FindOperator;
+var Re;
 
-function W() {
-    return new V.FindOperator("isNull", undefined, false);
+function Be() {
+    if (Re) return Pe;
+    Re = 1;
+    "use strict";
+    Object.defineProperty(Pe, "__esModule", {
+        value: true
+    });
+    Pe.ArrayContainedBy = t;
+    const e = r.requireFindOperator();
+    function t(r) {
+        return new e.FindOperator("arrayContainedBy", r);
+    }
+    return Pe;
 }
 
-var Y = {};
-
-"use strict";
+var Se = Be();
 
-Object.defineProperty(Y, "__esModule", {
-    value: true
-});
+const Ie = e.getDefaultExportFromCjs(Se);
 
-var $ = Y.LessThan = te;
+var Ne = {};
 
-const ee = t.FindOperator;
+var Te;
 
-function te(e) {
-    return new ee.FindOperator("lessThan", e);
+function ke() {
+    if (Te) return Ne;
+    Te = 1;
+    "use strict";
+    Object.defineProperty(Ne, "__esModule", {
+        value: true
+    });
+    Ne.ArrayContains = t;
+    const e = r.requireFindOperator();
+    function t(r) {
+        return new e.FindOperator("arrayContains", r);
+    }
+    return Ne;
 }
 
-var re = {};
-
-"use strict";
+var we = ke();
 
-Object.defineProperty(re, "__esModule", {
-    value: true
-});
+const Qe = e.getDefaultExportFromCjs(we);
 
-var oe = re.LessThanOrEqual = se;
+var Le = {};
 
-const ne = t.FindOperator;
+var Ae;
 
-function se(e) {
-    return new ne.FindOperator("lessThanOrEqual", e);
+function Ue() {
+    if (Ae) return Le;
+    Ae = 1;
+    "use strict";
+    Object.defineProperty(Le, "__esModule", {
+        value: true
+    });
+    Le.ArrayOverlap = t;
+    const e = r.requireFindOperator();
+    function t(r) {
+        return new e.FindOperator("arrayOverlap", r);
+    }
+    return Le;
 }
 
-var ie = {};
-
-"use strict";
+var Xe = Ue();
 
-Object.defineProperty(ie, "__esModule", {
-    value: true
-});
+const Ke = e.getDefaultExportFromCjs(Xe);
 
-var ue = ie.ILike = ce;
+var ze = {};
 
-const ae = t.FindOperator;
+var Ze;
 
-function ce(e) {
-    return new ae.FindOperator("ilike", e);
+function Ge() {
+    if (Ze) return ze;
+    Ze = 1;
+    "use strict";
+    Object.defineProperty(ze, "__esModule", {
+        value: true
+    });
+    ze.Between = t;
+    const e = r.requireFindOperator();
+    function t(r, t) {
+        return new e.FindOperator("between", [ r, t ], true, true);
+    }
+    return ze;
 }
 
-var de = {};
+var Je = Ge();
 
-"use strict";
+const He = e.getDefaultExportFromCjs(Je);
 
-Object.defineProperty(de, "__esModule", {
-    value: true
-});
+var Ve = {};
 
-var le = de.Like = ye;
+var We = {};
 
-const pe = t.FindOperator;
+var Ye;
 
-function ye(e) {
-    return new pe.FindOperator("like", e);
+function $e() {
+    if (Ye) return We;
+    Ye = 1;
+    "use strict";
+    Object.defineProperty(We, "__esModule", {
+        value: true
+    });
+    We.EqualOperator = void 0;
+    const e = r.requireFindOperator();
+    class EqualOperator extends e.FindOperator {
+        constructor(e) {
+            super("equal", e);
+            this["@instanceof"] = Symbol.for("EqualOperator");
+        }
+    }
+    We.EqualOperator = EqualOperator;
+    return We;
 }
 
-var Oe = {};
+var er;
 
-"use strict";
+function rr() {
+    if (er) return Ve;
+    er = 1;
+    "use strict";
+    Object.defineProperty(Ve, "__esModule", {
+        value: true
+    });
+    Ve.Equal = r;
+    const e = $e();
+    function r(r) {
+        return new e.EqualOperator(r);
+    }
+    return Ve;
+}
 
-Object.defineProperty(Oe, "__esModule", {
-    value: true
-});
+var tr = rr();
 
-var fe = Oe.MoreThan = ge;
+const or = e.getDefaultExportFromCjs(tr);
 
-const be = t.FindOperator;
+var nr = r.requireIn();
 
-function ge(e) {
-    return new be.FindOperator("moreThan", e);
-}
+const ur = e.getDefaultExportFromCjs(nr);
 
-var ve = {};
+var sr = {};
 
-"use strict";
+var ir;
 
-Object.defineProperty(ve, "__esModule", {
-    value: true
-});
+function ar() {
+    if (ir) return sr;
+    ir = 1;
+    "use strict";
+    Object.defineProperty(sr, "__esModule", {
+        value: true
+    });
+    sr.IsNull = t;
+    const e = r.requireFindOperator();
+    function t() {
+        return new e.FindOperator("isNull", undefined, false);
+    }
+    return sr;
+}
 
-var _e = ve.MoreThanOrEqual = je;
+var cr = ar();
 
-const me = t.FindOperator;
+const fr = e.getDefaultExportFromCjs(cr);
 
-function je(e) {
-    return new me.FindOperator("moreThanOrEqual", e);
-}
+var lr = {};
 
-var Pe = {};
+var pr;
 
-"use strict";
+function vr() {
+    if (pr) return lr;
+    pr = 1;
+    "use strict";
+    Object.defineProperty(lr, "__esModule", {
+        value: true
+    });
+    lr.LessThan = t;
+    const e = r.requireFindOperator();
+    function t(r) {
+        return new e.FindOperator("lessThan", r);
+    }
+    return lr;
+}
 
-Object.defineProperty(Pe, "__esModule", {
-    value: true
-});
+var dr = vr();
 
-var he = Pe.Not = xe;
+const yr = e.getDefaultExportFromCjs(dr);
 
-const Me = t.FindOperator;
+var gr = {};
 
-function xe(e) {
-    return new Me.FindOperator("not", e);
-}
+var mr;
 
-var Ee = {};
+function jr() {
+    if (mr) return gr;
+    mr = 1;
+    "use strict";
+    Object.defineProperty(gr, "__esModule", {
+        value: true
+    });
+    gr.LessThanOrEqual = t;
+    const e = r.requireFindOperator();
+    function t(r) {
+        return new e.FindOperator("lessThanOrEqual", r);
+    }
+    return gr;
+}
 
-"use strict";
+var Or = jr();
 
-Object.defineProperty(Ee, "__esModule", {
-    value: true
-});
+const Er = e.getDefaultExportFromCjs(Or);
 
-var Re = Ee.Raw = Se;
+var Fr = {};
 
-const Be = t.FindOperator;
+var xr;
 
-function Se(e, t) {
-    if (typeof e !== "function") {
-        return new Be.FindOperator("raw", e, false);
+function _r() {
+    if (xr) return Fr;
+    xr = 1;
+    "use strict";
+    Object.defineProperty(Fr, "__esModule", {
+        value: true
+    });
+    Fr.ILike = t;
+    const e = r.requireFindOperator();
+    function t(r) {
+        return new e.FindOperator("ilike", r);
     }
-    return new Be.FindOperator("raw", [], true, true, e, t);
+    return Fr;
 }
 
-var Fe = {};
-
-"use strict";
+var Cr = _r();
 
-Object.defineProperty(Fe, "__esModule", {
-    value: true
-});
+const Dr = e.getDefaultExportFromCjs(Cr);
 
-var Ie = Fe.JsonContains = Te;
+var br = {};
 
-const qe = t.FindOperator;
+var hr;
 
-function Te(e) {
-    return new qe.FindOperator("jsonContains", e);
+function qr() {
+    if (hr) return br;
+    hr = 1;
+    "use strict";
+    Object.defineProperty(br, "__esModule", {
+        value: true
+    });
+    br.Like = t;
+    const e = r.requireFindOperator();
+    function t(r) {
+        return new e.FindOperator("like", r);
+    }
+    return br;
 }
 
-var Ce = {};
+var Mr = qr();
 
-"use strict";
+const Pr = e.getDefaultExportFromCjs(Mr);
 
-Object.defineProperty(Ce, "__esModule", {
-    value: true
-});
+var Rr = {};
 
-var Ne = {};
+var Br;
 
-"use strict";
+function Sr() {
+    if (Br) return Rr;
+    Br = 1;
+    "use strict";
+    Object.defineProperty(Rr, "__esModule", {
+        value: true
+    });
+    Rr.MoreThan = t;
+    const e = r.requireFindOperator();
+    function t(r) {
+        return new e.FindOperator("moreThan", r);
+    }
+    return Rr;
+}
 
-Object.defineProperty(Ne, "__esModule", {
-    value: true
-});
+var Ir = Sr();
 
-var De = {};
+const Nr = e.getDefaultExportFromCjs(Ir);
 
-"use strict";
+var Tr = {};
 
-Object.defineProperty(De, "__esModule", {
-    value: true
-});
+var kr;
 
-var ke = {};
+function wr() {
+    if (kr) return Tr;
+    kr = 1;
+    "use strict";
+    Object.defineProperty(Tr, "__esModule", {
+        value: true
+    });
+    Tr.MoreThanOrEqual = t;
+    const e = r.requireFindOperator();
+    function t(r) {
+        return new e.FindOperator("moreThanOrEqual", r);
+    }
+    return Tr;
+}
 
-"use strict";
+var Qr = wr();
 
-Object.defineProperty(ke, "__esModule", {
-    value: true
-});
+const Lr = e.getDefaultExportFromCjs(Qr);
 
-var we = {};
+var Ar = {};
 
-"use strict";
+var Ur;
 
-Object.defineProperty(we, "__esModule", {
-    value: true
-});
+function Xr() {
+    if (Ur) return Ar;
+    Ur = 1;
+    "use strict";
+    Object.defineProperty(Ar, "__esModule", {
+        value: true
+    });
+    Ar.Not = t;
+    const e = r.requireFindOperator();
+    function t(r) {
+        return new e.FindOperator("not", r);
+    }
+    return Ar;
+}
 
-var Le = {};
+var Kr = Xr();
 
-"use strict";
+const zr = e.getDefaultExportFromCjs(Kr);
 
-Object.defineProperty(Le, "__esModule", {
-    value: true
-});
+var Zr = {};
 
-var Ae = {};
+var Gr;
 
-"use strict";
+function Jr() {
+    if (Gr) return Zr;
+    Gr = 1;
+    "use strict";
+    Object.defineProperty(Zr, "__esModule", {
+        value: true
+    });
+    Zr.Raw = t;
+    const e = r.requireFindOperator();
+    function t(r, t) {
+        if (typeof r !== "function") {
+            return new e.FindOperator("raw", r, false);
+        }
+        return new e.FindOperator("raw", [], true, true, r, t);
+    }
+    return Zr;
+}
 
-Object.defineProperty(Ae, "__esModule", {
-    value: true
-});
+var Hr = Jr();
 
-var Qe = {};
+const Vr = e.getDefaultExportFromCjs(Hr);
 
-"use strict";
+var Wr = {};
 
-Object.defineProperty(Qe, "__esModule", {
-    value: true
-});
+var Yr;
 
-var Ue = {};
+function $r() {
+    if (Yr) return Wr;
+    Yr = 1;
+    "use strict";
+    Object.defineProperty(Wr, "__esModule", {
+        value: true
+    });
+    Wr.JsonContains = t;
+    const e = r.requireFindOperator();
+    function t(r) {
+        return new e.FindOperator("jsonContains", r);
+    }
+    return Wr;
+}
 
-"use strict";
+var et = $r();
 
-Object.defineProperty(Ue, "__esModule", {
-    value: true
-});
+const rt = e.getDefaultExportFromCjs(et);
 
-var Ke = {};
+var tt = $e();
 
-"use strict";
+const ot = e.getDefaultExportFromCjs(tt);
 
-Object.defineProperty(Ke, "__esModule", {
-    value: true
-});
+var nt = {};
 
-var Xe = {};
+var ut;
 
-"use strict";
+function st() {
+    if (ut) return nt;
+    ut = 1;
+    "use strict";
+    Object.defineProperty(nt, "__esModule", {
+        value: true
+    });
+    return nt;
+}
 
-Object.defineProperty(Xe, "__esModule", {
-    value: true
-});
+var it = st();
 
-var ze = {};
+const at = e.getDefaultExportFromCjs(it);
 
-"use strict";
+var ct = {};
 
-Object.defineProperty(ze, "__esModule", {
-    value: true
-});
+var ft;
 
-var Ze = t.requireEntityManager();
+function lt() {
+    if (ft) return ct;
+    ft = 1;
+    "use strict";
+    Object.defineProperty(ct, "__esModule", {
+        value: true
+    });
+    return ct;
+}
 
-const Ge = e.getDefaultExportFromCjs(Ze);
+var pt = lt();
 
-var Je = t.requireAbstractRepository();
+const vt = e.getDefaultExportFromCjs(pt);
 
-const He = e.getDefaultExportFromCjs(Je);
+var dt = r.requireFindOperator();
 
-var Ve = {};
+const yt = e.getDefaultExportFromCjs(dt);
 
-"use strict";
+var gt = {};
 
-Object.defineProperty(Ve, "__esModule", {
-    value: true
-});
+var mt;
 
-exports.BaseEntity = Ve.BaseEntity = void 0;
+function jt() {
+    if (mt) return gt;
+    mt = 1;
+    "use strict";
+    Object.defineProperty(gt, "__esModule", {
+        value: true
+    });
+    return gt;
+}
 
-const We = t.ObjectUtils;
+var Ot = jt();
 
-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();
-    }
+const Et = e.getDefaultExportFromCjs(Ot);
+
+var Ft = {};
+
+var xt;
+
+function _t() {
+    if (xt) return Ft;
+    xt = 1;
+    "use strict";
+    Object.defineProperty(Ft, "__esModule", {
+        value: true
+    });
+    return Ft;
 }
 
-exports.BaseEntity = Ve.BaseEntity = BaseEntity;
+var Ct = _t();
 
-var Ye = {};
+const Dt = e.getDefaultExportFromCjs(Ct);
 
-"use strict";
+var bt = {};
 
-Object.defineProperty(Ye, "__esModule", {
-    value: true
-});
+var ht;
 
-var $e = {};
+function qt() {
+    if (ht) return bt;
+    ht = 1;
+    "use strict";
+    Object.defineProperty(bt, "__esModule", {
+        value: true
+    });
+    return bt;
+}
 
-"use strict";
+var Mt = qt();
 
-Object.defineProperty($e, "__esModule", {
-    value: true
-});
+const Pt = e.getDefaultExportFromCjs(Mt);
 
-var et = {};
+var Rt = {};
 
-"use strict";
+var Bt;
 
-Object.defineProperty(et, "__esModule", {
-    value: true
-});
+function St() {
+    if (Bt) return Rt;
+    Bt = 1;
+    "use strict";
+    Object.defineProperty(Rt, "__esModule", {
+        value: true
+    });
+    return Rt;
+}
 
-var tt = {};
+var It = St();
 
-"use strict";
+const Nt = e.getDefaultExportFromCjs(It);
 
-Object.defineProperty(tt, "__esModule", {
-    value: true
-});
+var Tt = r.requireFindOptionsUtils();
 
-var rt = {};
+const kt = e.getDefaultExportFromCjs(Tt);
 
-"use strict";
+var wt = {};
 
-Object.defineProperty(rt, "__esModule", {
-    value: true
-});
+var Qt;
 
-var ot = {};
+function Lt() {
+    if (Qt) return wt;
+    Qt = 1;
+    "use strict";
+    Object.defineProperty(wt, "__esModule", {
+        value: true
+    });
+    return wt;
+}
 
-"use strict";
+var At = Lt();
 
-Object.defineProperty(ot, "__esModule", {
-    value: true
-});
+const Ut = e.getDefaultExportFromCjs(At);
 
-var nt = {};
+var Xt = {};
 
-"use strict";
+var Kt;
 
-Object.defineProperty(nt, "__esModule", {
-    value: true
-});
+function zt() {
+    if (Kt) return Xt;
+    Kt = 1;
+    "use strict";
+    Object.defineProperty(Xt, "__esModule", {
+        value: true
+    });
+    return Xt;
+}
 
-var st = {};
+var Zt = zt();
 
-"use strict";
+const Gt = e.getDefaultExportFromCjs(Zt);
 
-Object.defineProperty(st, "__esModule", {
-    value: true
-});
+var Jt = {};
 
-var it = {};
+var Ht;
 
-"use strict";
+function Vt() {
+    if (Ht) return Jt;
+    Ht = 1;
+    "use strict";
+    Object.defineProperty(Jt, "__esModule", {
+        value: true
+    });
+    return Jt;
+}
 
-Object.defineProperty(it, "__esModule", {
-    value: true
-});
+var Wt = Vt();
 
-var ut = {};
+const Yt = e.getDefaultExportFromCjs(Wt);
 
-"use strict";
+var $t = {};
 
-Object.defineProperty(ut, "__esModule", {
-    value: true
-});
+var eo;
 
-var at = {};
+function ro() {
+    if (eo) return $t;
+    eo = 1;
+    "use strict";
+    Object.defineProperty($t, "__esModule", {
+        value: true
+    });
+    return $t;
+}
 
-var ct = {};
+var to = ro();
 
-"use strict";
+const oo = e.getDefaultExportFromCjs(to);
 
-Object.defineProperty(ct, "__esModule", {
-    value: true
-});
+var no = r.requireAbstractLogger();
 
-var dt = ct.BSON = void 0;
+const uo = e.getDefaultExportFromCjs(no);
 
-(function(e) {
+var so = {};
+
+var io;
+
+function ao() {
+    if (io) return so;
+    io = 1;
     "use strict";
-    Object.defineProperty(e, "__esModule", {
+    Object.defineProperty(so, "__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;
-        }
+    return so;
+}
+
+var co = ao();
+
+const fo = e.getDefaultExportFromCjs(co);
+
+var lo = {};
+
+var po;
+
+function vo() {
+    if (po) return lo;
+    po = 1;
+    "use strict";
+    Object.defineProperty(lo, "__esModule", {
+        value: true
     });
-    Object.defineProperty(e, "BSONRegExp", {
-        enumerable: true,
-        get: function() {
-            return t.BSONRegExp;
-        }
+    return lo;
+}
+
+var yo = vo();
+
+const go = e.getDefaultExportFromCjs(yo);
+
+var mo = r.requireAdvancedConsoleLogger();
+
+const jo = e.getDefaultExportFromCjs(mo);
+
+var Oo = r.requireSimpleConsoleLogger();
+
+const Eo = e.getDefaultExportFromCjs(Oo);
+
+var Fo = r.requireFileLogger();
+
+const xo = e.getDefaultExportFromCjs(Fo);
+
+var _o = r.requireEntityMetadata();
+
+const Co = e.getDefaultExportFromCjs(_o);
+
+var Do = r.requireEntityManager();
+
+const bo = e.getDefaultExportFromCjs(Do);
+
+var ho = r.requireAbstractRepository();
+
+const qo = e.getDefaultExportFromCjs(ho);
+
+var Mo = r.requireRepository();
+
+const Po = e.getDefaultExportFromCjs(Mo);
+
+var Ro = {};
+
+var Bo;
+
+function So() {
+    if (Bo) return Ro;
+    Bo = 1;
+    "use strict";
+    Object.defineProperty(Ro, "__esModule", {
+        value: true
     });
-    Object.defineProperty(e, "BSONSymbol", {
-        enumerable: true,
-        get: function() {
-            return t.BSONSymbol;
+    Ro.BaseEntity = void 0;
+    const e = r.requireObjectUtils();
+    class BaseEntity {
+        hasId() {
+            const e = this.constructor;
+            return e.getRepository().hasId(this);
         }
-    });
-    Object.defineProperty(e, "BSONType", {
-        enumerable: true,
-        get: function() {
-            return t.BSONType;
+        save(e) {
+            const r = this.constructor;
+            return r.getRepository().save(this, e);
         }
-    });
-    Object.defineProperty(e, "Binary", {
-        enumerable: true,
-        get: function() {
-            return t.Binary;
+        remove(e) {
+            const r = this.constructor;
+            return r.getRepository().remove(this, e);
         }
-    });
-    Object.defineProperty(e, "Code", {
-        enumerable: true,
-        get: function() {
-            return t.Code;
+        softRemove(e) {
+            const r = this.constructor;
+            return r.getRepository().softRemove(this, e);
         }
-    });
-    Object.defineProperty(e, "DBRef", {
-        enumerable: true,
-        get: function() {
-            return t.DBRef;
+        recover(e) {
+            const r = this.constructor;
+            return r.getRepository().recover(this, e);
         }
-    });
-    Object.defineProperty(e, "Decimal128", {
-        enumerable: true,
-        get: function() {
-            return t.Decimal128;
+        async reload() {
+            const r = this.constructor;
+            const t = r.getRepository().metadata.getEntityIdMap(this);
+            if (!t) {
+                throw new Error(`Entity doesn't have id-s set, cannot reload entity`);
+            }
+            const o = await r.getRepository().findOneByOrFail(t);
+            e.ObjectUtils.assign(this, o);
         }
-    });
-    Object.defineProperty(e, "Double", {
-        enumerable: true,
-        get: function() {
-            return t.Double;
+        static useDataSource(e) {
+            this.dataSource = e;
         }
-    });
-    Object.defineProperty(e, "Int32", {
-        enumerable: true,
-        get: function() {
-            return t.Int32;
+        static getRepository() {
+            const e = this.dataSource;
+            if (!e) throw new Error(`DataSource is not set for this entity.`);
+            return e.getRepository(this);
         }
-    });
-    Object.defineProperty(e, "Long", {
-        enumerable: true,
-        get: function() {
-            return t.Long;
+        static get target() {
+            return this.getRepository().target;
         }
-    });
-    Object.defineProperty(e, "MaxKey", {
-        enumerable: true,
-        get: function() {
-            return t.MaxKey;
+        static hasId(e) {
+            return this.getRepository().hasId(e);
         }
-    });
-    Object.defineProperty(e, "MinKey", {
-        enumerable: true,
-        get: function() {
-            return t.MinKey;
+        static getId(e) {
+            return this.getRepository().getId(e);
         }
-    });
-    Object.defineProperty(e, "ObjectId", {
-        enumerable: true,
-        get: function() {
-            return t.ObjectId;
+        static createQueryBuilder(e) {
+            return this.getRepository().createQueryBuilder(e);
         }
-    });
-    Object.defineProperty(e, "Timestamp", {
-        enumerable: true,
-        get: function() {
-            return t.Timestamp;
+        static create(e) {
+            return this.getRepository().create(e);
         }
-    });
-    Object.defineProperty(e, "deserialize", {
-        enumerable: true,
-        get: function() {
-            return t.deserialize;
+        static merge(e, ...r) {
+            return this.getRepository().merge(e, ...r);
         }
-    });
-    Object.defineProperty(e, "serialize", {
-        enumerable: true,
-        get: function() {
-            return t.serialize;
+        static preload(e) {
+            const r = this.getRepository();
+            return r.preload(e);
+        }
+        static save(e, r) {
+            return this.getRepository().save(e, r);
+        }
+        static remove(e, r) {
+            return this.getRepository().remove(e, r);
+        }
+        static softRemove(e, r) {
+            return this.getRepository().softRemove(e, r);
+        }
+        static insert(e) {
+            return this.getRepository().insert(e);
+        }
+        static update(e, r) {
+            return this.getRepository().update(e, r);
+        }
+        static upsert(e, r) {
+            return this.getRepository().upsert(e, r);
+        }
+        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, r) {
+            return this.getRepository().sum(e, r);
+        }
+        static average(e, r) {
+            return this.getRepository().average(e, r);
+        }
+        static minimum(e, r) {
+            return this.getRepository().minimum(e, r);
+        }
+        static maximum(e, r) {
+            return this.getRepository().maximum(e, r);
+        }
+        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, r) {
+            return this.getRepository().query(e, r);
+        }
+        static clear() {
+            return this.getRepository().clear();
+        }
+    }
+    Ro.BaseEntity = BaseEntity;
+    return Ro;
+}
+
+var Io = So();
+
+const No = e.getDefaultExportFromCjs(Io);
+
+var To = r.requireTreeRepository();
+
+const ko = e.getDefaultExportFromCjs(To);
+
+var wo = r.requireMongoRepository();
+
+const Qo = e.getDefaultExportFromCjs(wo);
+
+var Lo = {};
+
+var Ao;
+
+function Uo() {
+    if (Ao) return Lo;
+    Ao = 1;
+    "use strict";
+    Object.defineProperty(Lo, "__esModule", {
+        value: true
     });
-})(at);
+    return Lo;
+}
 
-const lt = e.getDefaultExportFromCjs(at);
+var Xo = Uo();
 
-var pt = {};
+const Ko = e.getDefaultExportFromCjs(Xo);
 
-"use strict";
+var zo = {};
 
-Object.defineProperty(pt, "__esModule", {
-    value: true
-});
+var Zo;
 
-var yt = {};
+function Go() {
+    if (Zo) return zo;
+    Zo = 1;
+    "use strict";
+    Object.defineProperty(zo, "__esModule", {
+        value: true
+    });
+    return zo;
+}
 
-"use strict";
+var Jo = Go();
 
-Object.defineProperty(yt, "__esModule", {
-    value: true
-});
+const Ho = e.getDefaultExportFromCjs(Jo);
 
-var Ot = {};
+var Vo = r.requireTableCheck();
 
-"use strict";
+const Wo = e.getDefaultExportFromCjs(Vo);
 
-Object.defineProperty(Ot, "__esModule", {
-    value: true
-});
+var Yo = r.requireTableColumn();
 
-var ft = {};
+const $o = e.getDefaultExportFromCjs(Yo);
 
-"use strict";
+var en = r.requireTableExclusion();
 
-Object.defineProperty(ft, "__esModule", {
-    value: true
-});
+const rn = e.getDefaultExportFromCjs(en);
 
-exports.NotBrackets = ft.NotBrackets = void 0;
+var tn = r.requireTableForeignKey();
 
-const bt = t.Brackets;
+const on = e.getDefaultExportFromCjs(tn);
 
-class NotBrackets extends bt.Brackets {
-    constructor() {
-        super(...arguments);
-        this["@instanceof"] = Symbol.for("NotBrackets");
-    }
+var nn = r.requireTableIndex();
+
+const un = e.getDefaultExportFromCjs(nn);
+
+var sn = r.requireTableUnique();
+
+const an = e.getDefaultExportFromCjs(sn);
+
+var cn = r.requireTable();
+
+const fn = e.getDefaultExportFromCjs(cn);
+
+var ln = {};
+
+var pn;
+
+function vn() {
+    if (pn) return ln;
+    pn = 1;
+    "use strict";
+    Object.defineProperty(ln, "__esModule", {
+        value: true
+    });
+    return ln;
 }
 
-exports.NotBrackets = ft.NotBrackets = NotBrackets;
+var dn = vn();
 
-var gt = t.requireMongoEntityManager();
+const yn = e.getDefaultExportFromCjs(dn);
 
-const vt = e.getDefaultExportFromCjs(gt);
+var gn = {};
 
-var _t = {};
+var mn;
 
-"use strict";
+function jn() {
+    if (mn) return gn;
+    mn = 1;
+    "use strict";
+    Object.defineProperty(gn, "__esModule", {
+        value: true
+    });
+    return gn;
+}
 
-Object.defineProperty(_t, "__esModule", {
-    value: true
-});
+var On = jn();
 
-exports.LegacyOracleNamingStrategy = _t.LegacyOracleNamingStrategy = void 0;
+const En = e.getDefaultExportFromCjs(On);
 
-const mt = t.RandomGenerator;
+var Fn = {};
 
-const jt = t.DefaultNamingStrategy;
+var xn;
 
-const Pt = t.error;
+function _n() {
+    if (xn) return Fn;
+    xn = 1;
+    "use strict";
+    Object.defineProperty(Fn, "__esModule", {
+        value: true
+    });
+    return Fn;
+}
 
-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;
-        }
-    }
+var Cn = _n();
+
+const Dn = e.getDefaultExportFromCjs(Cn);
+
+var bn = {};
+
+var hn;
+
+function qn() {
+    if (hn) return bn;
+    hn = 1;
+    "use strict";
+    Object.defineProperty(bn, "__esModule", {
+        value: true
+    });
+    return bn;
 }
 
-exports.LegacyOracleNamingStrategy = _t.LegacyOracleNamingStrategy = LegacyOracleNamingStrategy;
+var Mn = qn();
 
-var ht = {};
+const Pn = e.getDefaultExportFromCjs(Mn);
 
-"use strict";
+var Rn = {};
 
-Object.defineProperty(ht, "__esModule", {
-    value: true
-});
+var Bn;
+
+function Sn() {
+    if (Bn) return Rn;
+    Bn = 1;
+    "use strict";
+    Object.defineProperty(Rn, "__esModule", {
+        value: true
+    });
+    return Rn;
+}
 
-exports.EntitySchema = ht.EntitySchema = void 0;
+var In = Sn();
 
-class EntitySchema {
-    constructor(e) {
-        this.options = e;
-        this["@instanceof"] = Symbol.for("EntitySchema");
-    }
+const Nn = e.getDefaultExportFromCjs(In);
+
+var Tn = {};
+
+var kn;
+
+function wn() {
+    if (kn) return Tn;
+    kn = 1;
+    "use strict";
+    Object.defineProperty(Tn, "__esModule", {
+        value: true
+    });
+    return Tn;
 }
 
-exports.EntitySchema = ht.EntitySchema = EntitySchema;
+var Qn = wn();
 
-var Mt = {};
+const Ln = e.getDefaultExportFromCjs(Qn);
 
-"use strict";
+var An = {};
 
-Object.defineProperty(Mt, "__esModule", {
-    value: true
-});
+var Un;
 
-exports.EntitySchemaEmbeddedColumnOptions = Mt.EntitySchemaEmbeddedColumnOptions = void 0;
+function Xn() {
+    if (Un) return An;
+    Un = 1;
+    "use strict";
+    Object.defineProperty(An, "__esModule", {
+        value: true
+    });
+    return An;
+}
 
-class EntitySchemaEmbeddedColumnOptions {}
+var Kn = Xn();
 
-exports.EntitySchemaEmbeddedColumnOptions = Mt.EntitySchemaEmbeddedColumnOptions = EntitySchemaEmbeddedColumnOptions;
+const zn = e.getDefaultExportFromCjs(Kn);
 
-var xt = {};
+var Zn = {};
 
-"use strict";
+var Gn;
 
-Object.defineProperty(xt, "__esModule", {
-    value: true
-});
+function Jn() {
+    if (Gn) return Zn;
+    Gn = 1;
+    "use strict";
+    Object.defineProperty(Zn, "__esModule", {
+        value: true
+    });
+    return Zn;
+}
 
-exports.EntitySchemaOptions = xt.EntitySchemaOptions = void 0;
+var Hn = Jn();
 
-class EntitySchemaOptions {}
+const Vn = e.getDefaultExportFromCjs(Hn);
 
-exports.EntitySchemaOptions = xt.EntitySchemaOptions = EntitySchemaOptions;
+var Wn = {};
 
-Object.defineProperty(exports, "AbstractLogger", {
-    enumerable: true,
-    get: () => t.AbstractLogger_2
-});
+var Yn = {};
 
-Object.defineProperty(exports, "AdvancedConsoleLogger", {
-    enumerable: true,
-    get: () => t.AdvancedConsoleLogger_2
-});
+var $n;
 
-Object.defineProperty(exports, "Brackets", {
-    enumerable: true,
-    get: () => t.Brackets_2
-});
+function eu() {
+    if ($n) return Yn;
+    $n = 1;
+    "use strict";
+    Object.defineProperty(Yn, "__esModule", {
+        value: true
+    });
+    Yn.BSON = void 0;
+    return Yn;
+}
 
-Object.defineProperty(exports, "ConnectionOptionsReader", {
-    enumerable: true,
-    get: () => t.ConnectionOptionsReader_2
-});
+var ru;
+
+function tu() {
+    if (ru) return Wn;
+    ru = 1;
+    (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 r = eu();
+        Object.defineProperty(e, "BSON", {
+            enumerable: true,
+            get: function() {
+                return r.BSON;
+            }
+        });
+        Object.defineProperty(e, "BSONRegExp", {
+            enumerable: true,
+            get: function() {
+                return r.BSONRegExp;
+            }
+        });
+        Object.defineProperty(e, "BSONSymbol", {
+            enumerable: true,
+            get: function() {
+                return r.BSONSymbol;
+            }
+        });
+        Object.defineProperty(e, "BSONType", {
+            enumerable: true,
+            get: function() {
+                return r.BSONType;
+            }
+        });
+        Object.defineProperty(e, "Binary", {
+            enumerable: true,
+            get: function() {
+                return r.Binary;
+            }
+        });
+        Object.defineProperty(e, "Code", {
+            enumerable: true,
+            get: function() {
+                return r.Code;
+            }
+        });
+        Object.defineProperty(e, "DBRef", {
+            enumerable: true,
+            get: function() {
+                return r.DBRef;
+            }
+        });
+        Object.defineProperty(e, "Decimal128", {
+            enumerable: true,
+            get: function() {
+                return r.Decimal128;
+            }
+        });
+        Object.defineProperty(e, "Double", {
+            enumerable: true,
+            get: function() {
+                return r.Double;
+            }
+        });
+        Object.defineProperty(e, "Int32", {
+            enumerable: true,
+            get: function() {
+                return r.Int32;
+            }
+        });
+        Object.defineProperty(e, "Long", {
+            enumerable: true,
+            get: function() {
+                return r.Long;
+            }
+        });
+        Object.defineProperty(e, "MaxKey", {
+            enumerable: true,
+            get: function() {
+                return r.MaxKey;
+            }
+        });
+        Object.defineProperty(e, "MinKey", {
+            enumerable: true,
+            get: function() {
+                return r.MinKey;
+            }
+        });
+        Object.defineProperty(e, "ObjectId", {
+            enumerable: true,
+            get: function() {
+                return r.ObjectId;
+            }
+        });
+        Object.defineProperty(e, "Timestamp", {
+            enumerable: true,
+            get: function() {
+                return r.Timestamp;
+            }
+        });
+        Object.defineProperty(e, "deserialize", {
+            enumerable: true,
+            get: function() {
+                return r.deserialize;
+            }
+        });
+        Object.defineProperty(e, "serialize", {
+            enumerable: true,
+            get: function() {
+                return r.serialize;
+            }
+        });
+    })(Wn);
+    return Wn;
+}
 
-Object.defineProperty(exports, "DefaultNamingStrategy", {
-    enumerable: true,
-    get: () => t.DefaultNamingStrategy_2
-});
+var ou = tu();
 
-Object.defineProperty(exports, "DeleteQueryBuilder", {
-    enumerable: true,
-    get: () => t.DeleteQueryBuilder_2
-});
+const nu = e.getDefaultExportFromCjs(ou);
 
-Object.defineProperty(exports, "DeleteResult", {
-    enumerable: true,
-    get: () => t.DeleteResult_2
-});
+var uu = {};
 
-Object.defineProperty(exports, "EntityMetadata", {
-    enumerable: true,
-    get: () => t.EntityMetadata_2
-});
+var su;
 
-Object.defineProperty(exports, "FileLogger", {
-    enumerable: true,
-    get: () => t.FileLogger_2
-});
+function iu() {
+    if (su) return uu;
+    su = 1;
+    "use strict";
+    Object.defineProperty(uu, "__esModule", {
+        value: true
+    });
+    return uu;
+}
 
-Object.defineProperty(exports, "FindOperator", {
-    enumerable: true,
-    get: () => t.FindOperator_2
-});
+var au = iu();
 
-Object.defineProperty(exports, "FindOptionsUtils", {
-    enumerable: true,
-    get: () => t.FindOptionsUtils_2
-});
+const cu = e.getDefaultExportFromCjs(au);
 
-exports.In = t.In_2;
+var fu = {};
 
-Object.defineProperty(exports, "InsertQueryBuilder", {
-    enumerable: true,
-    get: () => t.InsertQueryBuilder_2
-});
+var lu;
 
-Object.defineProperty(exports, "InsertResult", {
-    enumerable: true,
-    get: () => t.InsertResult_2
-});
+function pu() {
+    if (lu) return fu;
+    lu = 1;
+    "use strict";
+    Object.defineProperty(fu, "__esModule", {
+        value: true
+    });
+    return fu;
+}
 
-Object.defineProperty(exports, "InstanceChecker", {
-    enumerable: true,
-    get: () => t.InstanceChecker_2
-});
+var vu = pu();
 
-Object.defineProperty(exports, "Migration", {
-    enumerable: true,
-    get: () => t.Migration_2
-});
+const du = e.getDefaultExportFromCjs(vu);
 
-Object.defineProperty(exports, "MigrationExecutor", {
-    enumerable: true,
-    get: () => t.MigrationExecutor_2
-});
+var yu = {};
 
-Object.defineProperty(exports, "MongoRepository", {
-    enumerable: true,
-    get: () => t.MongoRepository_2
-});
+var gu;
 
-Object.defineProperty(exports, "MssqlParameter", {
-    enumerable: true,
-    get: () => t.MssqlParameter_2
-});
+function mu() {
+    if (gu) return yu;
+    gu = 1;
+    "use strict";
+    Object.defineProperty(yu, "__esModule", {
+        value: true
+    });
+    return yu;
+}
 
-Object.defineProperty(exports, "QueryBuilder", {
-    enumerable: true,
-    get: () => t.QueryBuilder_2
-});
+var ju = mu();
 
-Object.defineProperty(exports, "QueryResult", {
-    enumerable: true,
-    get: () => t.QueryResult_2
-});
+const Ou = e.getDefaultExportFromCjs(ju);
 
-Object.defineProperty(exports, "RelationQueryBuilder", {
-    enumerable: true,
-    get: () => t.RelationQueryBuilder_2
-});
+var Eu = r.requireMssqlParameter();
 
-Object.defineProperty(exports, "Repository", {
-    enumerable: true,
-    get: () => t.Repository_2
-});
+const Fu = e.getDefaultExportFromCjs(Eu);
 
-Object.defineProperty(exports, "SelectQueryBuilder", {
-    enumerable: true,
-    get: () => t.SelectQueryBuilder_2
-});
+var xu = r.requireConnectionOptionsReader();
 
-Object.defineProperty(exports, "SimpleConsoleLogger", {
-    enumerable: true,
-    get: () => t.SimpleConsoleLogger_2
-});
+const _u = e.getDefaultExportFromCjs(xu);
 
-Object.defineProperty(exports, "Table", {
-    enumerable: true,
-    get: () => t.Table_2
-});
+var Cu = r.requireQueryBuilder();
 
-Object.defineProperty(exports, "TableCheck", {
-    enumerable: true,
-    get: () => t.TableCheck_2
-});
+const Du = e.getDefaultExportFromCjs(Cu);
 
-Object.defineProperty(exports, "TableColumn", {
-    enumerable: true,
-    get: () => t.TableColumn_2
-});
+var bu = r.requireSelectQueryBuilder();
 
-Object.defineProperty(exports, "TableExclusion", {
-    enumerable: true,
-    get: () => t.TableExclusion_2
-});
+const hu = e.getDefaultExportFromCjs(bu);
 
-Object.defineProperty(exports, "TableForeignKey", {
-    enumerable: true,
-    get: () => t.TableForeignKey_2
-});
+var qu = r.requireDeleteQueryBuilder();
 
-Object.defineProperty(exports, "TableIndex", {
-    enumerable: true,
-    get: () => t.TableIndex_2
-});
+const Mu = e.getDefaultExportFromCjs(qu);
 
-Object.defineProperty(exports, "TableUnique", {
-    enumerable: true,
-    get: () => t.TableUnique_2
-});
+var Pu = r.requireInsertQueryBuilder();
 
-Object.defineProperty(exports, "TreeRepository", {
-    enumerable: true,
-    get: () => t.TreeRepository_2
-});
+const Ru = e.getDefaultExportFromCjs(Pu);
 
-Object.defineProperty(exports, "TreeRepositoryUtils", {
-    enumerable: true,
-    get: () => t.TreeRepositoryUtils_2
-});
+var Bu = r.requireUpdateQueryBuilder();
 
-Object.defineProperty(exports, "UpdateQueryBuilder", {
-    enumerable: true,
-    get: () => t.UpdateQueryBuilder_2
-});
+const Su = e.getDefaultExportFromCjs(Bu);
 
-Object.defineProperty(exports, "UpdateResult", {
-    enumerable: true,
-    get: () => t.UpdateResult_2
-});
+var Iu = r.requireRelationQueryBuilder();
+
+const Nu = e.getDefaultExportFromCjs(Iu);
+
+var Tu = r.requireBrackets();
+
+const ku = e.getDefaultExportFromCjs(Tu);
+
+var wu = {};
+
+var Qu;
+
+function Lu() {
+    if (Qu) return wu;
+    Qu = 1;
+    "use strict";
+    Object.defineProperty(wu, "__esModule", {
+        value: true
+    });
+    wu.NotBrackets = void 0;
+    const e = r.requireBrackets();
+    class NotBrackets extends e.Brackets {
+        constructor() {
+            super(...arguments);
+            this["@instanceof"] = Symbol.for("NotBrackets");
+        }
+    }
+    wu.NotBrackets = NotBrackets;
+    return wu;
+}
+
+var Au = Lu();
+
+const Uu = e.getDefaultExportFromCjs(Au);
+
+var Xu = r.requireInsertResult();
+
+const Ku = e.getDefaultExportFromCjs(Xu);
+
+var zu = r.requireUpdateResult();
+
+const Zu = e.getDefaultExportFromCjs(zu);
+
+var Gu = r.requireDeleteResult();
+
+const Ju = e.getDefaultExportFromCjs(Gu);
+
+var Hu = r.requireQueryResult();
+
+const Vu = e.getDefaultExportFromCjs(Hu);
+
+var Wu = r.requireMongoEntityManager();
+
+const Yu = e.getDefaultExportFromCjs(Wu);
+
+var $u = r.requireMigration();
+
+const es = e.getDefaultExportFromCjs($u);
+
+var rs = r.requireMigrationExecutor();
+
+const ts = e.getDefaultExportFromCjs(rs);
+
+var os = r.requireDefaultNamingStrategy();
+
+const ns = e.getDefaultExportFromCjs(os);
+
+var us = {};
+
+var ss;
+
+function is() {
+    if (ss) return us;
+    ss = 1;
+    "use strict";
+    Object.defineProperty(us, "__esModule", {
+        value: true
+    });
+    us.LegacyOracleNamingStrategy = void 0;
+    const e = r.requireRandomGenerator();
+    const t = r.requireDefaultNamingStrategy();
+    const o = r.requireError();
+    class LegacyOracleNamingStrategy extends t.DefaultNamingStrategy {
+        constructor(e = "hash") {
+            super();
+            this.IDENTIFIER_MAX_SIZE = 30;
+            this.DEFAULT_COLUMN_PREFIX = "COL_";
+            this.shortenStrategy = e;
+        }
+        columnName(e, r, t) {
+            const n = super.columnName(e, r, t);
+            if (this.shortenStrategy === "truncate") {
+                return this.truncateIdentifier(n);
+            } else if (this.shortenStrategy === "hash") {
+                return this.hashIdentifier(n, this.DEFAULT_COLUMN_PREFIX);
+            } else {
+                throw new o.TypeORMError(`Invalid shortenStrategy`);
+            }
+        }
+        hashIdentifier(r, t) {
+            if (t.length >= this.IDENTIFIER_MAX_SIZE) {
+                throw new o.TypeORMError(`Prefix must be shorter than IDENTIFIER_MAX_SIZE`);
+            }
+            return t + e.RandomGenerator.sha1(r).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;
+            }
+        }
+    }
+    us.LegacyOracleNamingStrategy = LegacyOracleNamingStrategy;
+    return us;
+}
+
+var as = is();
+
+const cs = e.getDefaultExportFromCjs(as);
+
+var fs = {};
+
+var ls;
+
+function ps() {
+    if (ls) return fs;
+    ls = 1;
+    "use strict";
+    Object.defineProperty(fs, "__esModule", {
+        value: true
+    });
+    fs.EntitySchema = void 0;
+    class EntitySchema {
+        constructor(e) {
+            this.options = e;
+            this["@instanceof"] = Symbol.for("EntitySchema");
+        }
+    }
+    fs.EntitySchema = EntitySchema;
+    return fs;
+}
+
+var vs = ps();
+
+const ds = e.getDefaultExportFromCjs(vs);
+
+var ys = {};
+
+var gs;
+
+function ms() {
+    if (gs) return ys;
+    gs = 1;
+    "use strict";
+    Object.defineProperty(ys, "__esModule", {
+        value: true
+    });
+    ys.EntitySchemaEmbeddedColumnOptions = void 0;
+    class EntitySchemaEmbeddedColumnOptions {}
+    ys.EntitySchemaEmbeddedColumnOptions = EntitySchemaEmbeddedColumnOptions;
+    return ys;
+}
+
+var js = ms();
+
+const Os = e.getDefaultExportFromCjs(js);
+
+var Es = {};
+
+var Fs;
+
+function xs() {
+    if (Fs) return Es;
+    Fs = 1;
+    "use strict";
+    Object.defineProperty(Es, "__esModule", {
+        value: true
+    });
+    Es.EntitySchemaOptions = void 0;
+    class EntitySchemaOptions {}
+    Es.EntitySchemaOptions = EntitySchemaOptions;
+    return Es;
+}
+
+var _s = xs();
+
+const Cs = e.getDefaultExportFromCjs(_s);
+
+var Ds = r.requireInstanceChecker();
+
+const bs = e.getDefaultExportFromCjs(Ds);
+
+var hs = r.requireTreeRepositoryUtils();
+
+const qs = e.getDefaultExportFromCjs(hs);
+
+exports.Brackets = Tu.Brackets;
+
+exports.ConnectionOptionsReader = xu.ConnectionOptionsReader;
+
+exports.DataSource = t.DataSourceExports.DataSource;
 
-exports.getFromContainer = t.getFromContainer_1;
+exports.DefaultNamingStrategy = os.DefaultNamingStrategy;
 
-exports.useContainer = t.useContainer_1;
+exports.DeleteQueryBuilder = qu.DeleteQueryBuilder;
 
-exports.And = _;
+exports.DeleteResult = Gu.DeleteResult;
 
-exports.Any = h;
+exports.EntitySchema = vs.EntitySchema;
 
-exports.ArrayContainedBy = R;
+exports.EntitySchemaEmbeddedColumnOptions = js.EntitySchemaEmbeddedColumnOptions;
 
-exports.ArrayContains = I;
+exports.EntitySchemaOptions = _s.EntitySchemaOptions;
 
-exports.ArrayOverlap = N;
+exports.InsertQueryBuilder = Pu.InsertQueryBuilder;
 
-exports.Between = L;
+exports.InsertResult = Xu.InsertResult;
 
-exports.DataSource = r.DataSourceExports.DataSource;
+exports.InstanceChecker = Ds.InstanceChecker;
 
-exports.Equal = z;
+exports.LegacyOracleNamingStrategy = as.LegacyOracleNamingStrategy;
 
-exports.ILike = ue;
+exports.Migration = $u.Migration;
 
-exports.IsNull = H;
+exports.MigrationExecutor = rs.MigrationExecutor;
 
-exports.JsonContains = Ie;
+exports.MongoEntityManager = Wu.MongoEntityManager;
 
-exports.LessThan = $;
+exports.NotBrackets = Au.NotBrackets;
 
-exports.LessThanOrEqual = oe;
+exports.QueryBuilder = Cu.QueryBuilder;
 
-exports.Like = le;
+exports.QueryResult = Hu.QueryResult;
 
-exports.MongoEntityManager = gt.MongoEntityManager;
+exports.RelationQueryBuilder = Iu.RelationQueryBuilder;
 
-exports.MoreThan = fe;
+exports.SelectQueryBuilder = bu.SelectQueryBuilder;
 
-exports.MoreThanOrEqual = _e;
+exports.TreeRepositoryUtils = hs.TreeRepositoryUtils;
 
-exports.Not = he;
+exports.UpdateQueryBuilder = Bu.UpdateQueryBuilder;
 
-exports.Raw = Re;
+exports.UpdateResult = zu.UpdateResult;