lakutata 2.0.80 → 2.0.81

package/orm.mjs

@@ -2,21 +2,21 @@ import "./vendor/Package.4.mjs";
 
 import { g as e } from "./vendor/Package.5.mjs";
 
-import { d as r, F as s, g as a, h as i, O as c, B as d, i as f, R as O, D as g, e as b } from "./vendor/Package.102.mjs";
+import { h as t, m as r, d as n, n as s, o, p as u, q as i, s as a, t as c, u as v, v as f, w as d, x as l, y, k as p, z as O, A as m, B as _, C as g, D as h, E as b, F as j, G as P, H as M, I as R, J as E, K as B, L as S, M as I, N, O as F, P as w, Q as k, R as D, S as C, T, U as x, V as L, W as A, X as Q, Y as q, Z as U, e as X, _ as z } from "./vendor/Package.112.mjs";
 
-export { H as AbstractLogger, J as AdvancedConsoleLogger, n as Brackets, j as ConnectionOptionsReader, v as DefaultNamingStrategy, k as DeleteQueryBuilder, q as DeleteResult, N as EntityMetadata, L as FileLogger, A as FindOperator, G as FindOptionsUtils, z as In, l as InsertQueryBuilder, o as InsertResult, w as InstanceChecker, M as Migration, u as MigrationExecutor, X as MongoRepository, a3 as MssqlParameter, Q as QueryBuilder, t as QueryResult, m as RelationQueryBuilder, V as Repository, S as SelectQueryBuilder, K as SimpleConsoleLogger, a2 as Table, Y as TableCheck, Z as TableColumn, _ as TableExclusion, $ as TableForeignKey, a0 as TableIndex, a1 as TableUnique, W as TreeRepository, T as TreeRepositoryUtils, U as UpdateQueryBuilder, p as UpdateResult, y as getFromContainer, x as useContainer } from "./vendor/Package.102.mjs";
-
-import { D as h } from "./vendor/Package.10.mjs";
+import { D as K } from "./vendor/Package.11.mjs";
 
 import "./vendor/Package.12.mjs";
 
 import "./vendor/Package.1.mjs";
 
+import "fs/promises";
+
 import "./vendor/Package.62.mjs";
 
-import "./vendor/Package.11.mjs";
+import "./vendor/Package.13.mjs";
 
-import "./vendor/Package.122.mjs";
+import "./vendor/Package.14.mjs";
 
 import "buffer";
 
@@ -26,30 +26,28 @@ import "url";
 
 import "tty";
 
+import "./vendor/Package.10.mjs";
+
+import "util";
+
+import "stream";
+
+import "./vendor/Package.7.mjs";
+
 import "./vendor/Package.8.mjs";
 
 import "os";
 
 import "path";
 
-import "util";
-
-import "stream";
-
 import "events";
 
 import "fs";
 
-import "./vendor/Package.7.mjs";
-
-import "./vendor/Package.13.mjs";
+import "./vendor/Package.15.mjs";
 
 import "crypto";
 
-import "fs/promises";
-
-import "./vendor/Package.63.mjs";
-
 import "node:url";
 
 import "node:path";
@@ -64,1024 +62,1776 @@ import "node:stream";
 
 import "node:string_decoder";
 
-var P = r();
+var Z = t();
 
-const E = e(P);
+const G = e(Z);
 
-var R = {};
+var J = r();
 
-"use strict";
+const H = e(J);
 
-Object.defineProperty(R, "__esModule", {
-    value: true
-});
+var V = {};
 
-var B = {};
+var W;
 
-"use strict";
+function Y() {
+    if (W) return V;
+    W = 1;
+    "use strict";
+    Object.defineProperty(V, "__esModule", {
+        value: true
+    });
+    return V;
+}
 
-Object.defineProperty(B, "__esModule", {
-    value: true
-});
+var $ = Y();
 
-var I = {};
+const ee = e($);
 
-"use strict";
+var te = {};
 
-Object.defineProperty(I, "__esModule", {
-    value: true
-});
+var re;
 
-var F = {};
+function ne() {
+    if (re) return te;
+    re = 1;
+    "use strict";
+    Object.defineProperty(te, "__esModule", {
+        value: true
+    });
+    return te;
+}
 
-"use strict";
+var se = ne();
 
-Object.defineProperty(F, "__esModule", {
-    value: true
-});
+const oe = e(se);
 
-var C = {};
+var ue = {};
 
-"use strict";
+var ie;
 
-Object.defineProperty(C, "__esModule", {
-    value: true
-});
+function ae() {
+    if (ie) return ue;
+    ie = 1;
+    "use strict";
+    Object.defineProperty(ue, "__esModule", {
+        value: true
+    });
+    return ue;
+}
 
-var D = {};
+var ce = ae();
 
-"use strict";
+const ve = e(ce);
 
-Object.defineProperty(D, "__esModule", {
-    value: true
-});
+var fe = {};
 
-var ee = {};
+var de;
 
-"use strict";
+function le() {
+    if (de) return fe;
+    de = 1;
+    "use strict";
+    Object.defineProperty(fe, "__esModule", {
+        value: true
+    });
+    return fe;
+}
 
-Object.defineProperty(ee, "__esModule", {
-    value: true
-});
+var ye = le();
 
-var te = {};
+const pe = e(ye);
 
-"use strict";
+var Oe = {};
 
-Object.defineProperty(te, "__esModule", {
-    value: true
-});
+var me;
 
-var re = {};
+function _e() {
+    if (me) return Oe;
+    me = 1;
+    "use strict";
+    Object.defineProperty(Oe, "__esModule", {
+        value: true
+    });
+    return Oe;
+}
 
-"use strict";
+var ge = _e();
 
-Object.defineProperty(re, "__esModule", {
-    value: true
-});
+const he = e(ge);
 
-var se = {};
+var be = {};
 
-"use strict";
+var je;
 
-Object.defineProperty(se, "__esModule", {
-    value: true
-});
+function Pe() {
+    if (je) return be;
+    je = 1;
+    "use strict";
+    Object.defineProperty(be, "__esModule", {
+        value: true
+    });
+    return be;
+}
 
-var ne = {};
+var Me = Pe();
 
-"use strict";
+const Re = e(Me);
 
-Object.defineProperty(ne, "__esModule", {
-    value: true
-});
+var Ee = n();
 
-var ae = {};
+const Be = e(Ee);
 
-"use strict";
+var Se = {};
 
-Object.defineProperty(ae, "__esModule", {
-    value: true
-});
+var Ie;
 
-var oe = {};
+function Ne() {
+    if (Ie) return Se;
+    Ie = 1;
+    "use strict";
+    Object.defineProperty(Se, "__esModule", {
+        value: true
+    });
+    return Se;
+}
 
-"use strict";
+var Fe = Ne();
 
-Object.defineProperty(oe, "__esModule", {
-    value: true
-});
+const we = e(Fe);
 
-var ie = {};
+var ke = {};
 
-"use strict";
+var De;
 
-Object.defineProperty(ie, "__esModule", {
-    value: true
-});
+function Ce() {
+    if (De) return ke;
+    De = 1;
+    "use strict";
+    Object.defineProperty(ke, "__esModule", {
+        value: true
+    });
+    return ke;
+}
 
-var ue = ie.And = de;
+var Te = Ce();
 
-const ce = s;
+const xe = e(Te);
 
-function de(...e) {
-    return new ce.FindOperator("and", e, true, true);
-}
+var Le = {};
 
-var le = {};
+var Ae;
 
-"use strict";
+function Qe() {
+    if (Ae) return Le;
+    Ae = 1;
+    "use strict";
+    Object.defineProperty(Le, "__esModule", {
+        value: true
+    });
+    return Le;
+}
 
-Object.defineProperty(le, "__esModule", {
-    value: true
-});
+var qe = Qe();
 
-var ye = le.Any = ve;
+const Ue = e(qe);
 
-const pe = s;
+var Xe = {};
 
-function ve(e) {
-    return new pe.FindOperator("any", e);
-}
+var ze;
 
-var fe = {};
+function Ke() {
+    if (ze) return Xe;
+    ze = 1;
+    "use strict";
+    Object.defineProperty(Xe, "__esModule", {
+        value: true
+    });
+    return Xe;
+}
 
-"use strict";
+var Ze = Ke();
 
-Object.defineProperty(fe, "__esModule", {
-    value: true
-});
+const Ge = e(Ze);
 
-var Oe = fe.ArrayContainedBy = _e;
+var Je = {};
 
-const me = s;
+var He;
 
-function _e(e) {
-    return new me.FindOperator("arrayContainedBy", e);
+function Ve() {
+    if (He) return Je;
+    He = 1;
+    "use strict";
+    Object.defineProperty(Je, "__esModule", {
+        value: true
+    });
+    return Je;
 }
 
-var ge = {};
+var We = Ve();
 
-"use strict";
+const Ye = e(We);
 
-Object.defineProperty(ge, "__esModule", {
-    value: true
-});
+var $e = {};
 
-var be = ge.ArrayContains = je;
+var et;
 
-const he = s;
-
-function je(e) {
-    return new he.FindOperator("arrayContains", e);
+function tt() {
+    if (et) return $e;
+    et = 1;
+    "use strict";
+    Object.defineProperty($e, "__esModule", {
+        value: true
+    });
+    return $e;
 }
 
-var Pe = {};
+var rt = tt();
 
-"use strict";
+const nt = e(rt);
 
-Object.defineProperty(Pe, "__esModule", {
-    value: true
-});
+var st = {};
 
-var Me = Pe.ArrayOverlap = Re;
+var ot;
 
-const Ee = s;
-
-function Re(e) {
-    return new Ee.FindOperator("arrayOverlap", e);
+function ut() {
+    if (ot) return st;
+    ot = 1;
+    "use strict";
+    Object.defineProperty(st, "__esModule", {
+        value: true
+    });
+    return st;
 }
 
-var Be = {};
+var it = ut();
 
-"use strict";
+const at = e(it);
 
-Object.defineProperty(Be, "__esModule", {
-    value: true
-});
+var ct = {};
 
-var Se = Be.Between = Ne;
+var vt;
 
-const Ie = s;
-
-function Ne(e, t) {
-    return new Ie.FindOperator("between", [ e, t ], true, true);
+function ft() {
+    if (vt) return ct;
+    vt = 1;
+    "use strict";
+    Object.defineProperty(ct, "__esModule", {
+        value: true
+    });
+    ct.And = t;
+    const e = s();
+    function t(...t) {
+        return new e.FindOperator("and", t, true, true);
+    }
+    return ct;
 }
 
-var Fe = {};
-
-var Te = {};
+var dt = ft();
 
-"use strict";
+const lt = e(dt);
 
-Object.defineProperty(Te, "__esModule", {
-    value: true
-});
-
-var we = Te.EqualOperator = void 0;
+var yt = {};
 
-const Ce = s;
+var pt;
 
-class EqualOperator extends Ce.FindOperator {
-    constructor(e) {
-        super("equal", e);
-        this["@instanceof"] = Symbol.for("EqualOperator");
+function Ot() {
+    if (pt) return yt;
+    pt = 1;
+    "use strict";
+    Object.defineProperty(yt, "__esModule", {
+        value: true
+    });
+    yt.Any = t;
+    const e = s();
+    function t(t) {
+        return new e.FindOperator("any", t);
     }
+    return yt;
 }
 
-we = Te.EqualOperator = EqualOperator;
-
-"use strict";
+var mt = Ot();
 
-Object.defineProperty(Fe, "__esModule", {
-    value: true
-});
+const _t = e(mt);
 
-var ke = Fe.Equal = Le;
+var gt = {};
 
-const De = Te;
+var ht;
 
-function Le(e) {
-    return new De.EqualOperator(e);
+function bt() {
+    if (ht) return gt;
+    ht = 1;
+    "use strict";
+    Object.defineProperty(gt, "__esModule", {
+        value: true
+    });
+    gt.ArrayContainedBy = t;
+    const e = s();
+    function t(t) {
+        return new e.FindOperator("arrayContainedBy", t);
+    }
+    return gt;
 }
 
-var Ae = {};
+var jt = bt();
 
-"use strict";
+const Pt = e(jt);
 
-Object.defineProperty(Ae, "__esModule", {
-    value: true
-});
-
-var xe = Ae.IsNull = Ue;
+var Mt = {};
 
-const qe = s;
+var Rt;
 
-function Ue() {
-    return new qe.FindOperator("isNull", undefined, false);
+function Et() {
+    if (Rt) return Mt;
+    Rt = 1;
+    "use strict";
+    Object.defineProperty(Mt, "__esModule", {
+        value: true
+    });
+    Mt.ArrayContains = t;
+    const e = s();
+    function t(t) {
+        return new e.FindOperator("arrayContains", t);
+    }
+    return Mt;
 }
 
-var Qe = {};
+var Bt = Et();
 
-"use strict";
+const St = e(Bt);
 
-Object.defineProperty(Qe, "__esModule", {
-    value: true
-});
-
-var Xe = Qe.LessThan = ze;
+var It = {};
 
-const Ke = s;
+var Nt;
 
-function ze(e) {
-    return new Ke.FindOperator("lessThan", e);
+function Ft() {
+    if (Nt) return It;
+    Nt = 1;
+    "use strict";
+    Object.defineProperty(It, "__esModule", {
+        value: true
+    });
+    It.ArrayOverlap = t;
+    const e = s();
+    function t(t) {
+        return new e.FindOperator("arrayOverlap", t);
+    }
+    return It;
 }
 
-var Ze = {};
+var wt = Ft();
 
-"use strict";
+const kt = e(wt);
 
-Object.defineProperty(Ze, "__esModule", {
-    value: true
-});
+var Dt = {};
 
-var Je = Ze.LessThanOrEqual = He;
+var Ct;
 
-const Ge = s;
-
-function He(e) {
-    return new Ge.FindOperator("lessThanOrEqual", e);
+function Tt() {
+    if (Ct) return Dt;
+    Ct = 1;
+    "use strict";
+    Object.defineProperty(Dt, "__esModule", {
+        value: true
+    });
+    Dt.Between = t;
+    const e = s();
+    function t(t, r) {
+        return new e.FindOperator("between", [ t, r ], true, true);
+    }
+    return Dt;
 }
 
-var Ve = {};
+var xt = Tt();
+
+const Lt = e(xt);
 
-"use strict";
+var At = {};
 
-Object.defineProperty(Ve, "__esModule", {
-    value: true
-});
+var Qt = {};
 
-var We = Ve.ILike = $e;
+var qt;
 
-const Ye = s;
+function Ut() {
+    if (qt) return Qt;
+    qt = 1;
+    "use strict";
+    Object.defineProperty(Qt, "__esModule", {
+        value: true
+    });
+    Qt.EqualOperator = void 0;
+    const e = s();
+    class EqualOperator extends e.FindOperator {
+        constructor(e) {
+            super("equal", e);
+            this["@instanceof"] = Symbol.for("EqualOperator");
+        }
+    }
+    Qt.EqualOperator = EqualOperator;
+    return Qt;
+}
 
-function $e(e) {
-    return new Ye.FindOperator("ilike", e);
+var Xt;
+
+function zt() {
+    if (Xt) return At;
+    Xt = 1;
+    "use strict";
+    Object.defineProperty(At, "__esModule", {
+        value: true
+    });
+    At.Equal = t;
+    const e = Ut();
+    function t(t) {
+        return new e.EqualOperator(t);
+    }
+    return At;
 }
 
-var et = {};
+var Kt = zt();
 
-"use strict";
+const Zt = e(Kt);
 
-Object.defineProperty(et, "__esModule", {
-    value: true
-});
+var Gt = o();
 
-var tt = et.Like = st;
+const Jt = e(Gt);
 
-const rt = s;
+var Ht = {};
 
-function st(e) {
-    return new rt.FindOperator("like", e);
-}
+var Vt;
 
-var nt = {};
+function Wt() {
+    if (Vt) return Ht;
+    Vt = 1;
+    "use strict";
+    Object.defineProperty(Ht, "__esModule", {
+        value: true
+    });
+    Ht.IsNull = t;
+    const e = s();
+    function t() {
+        return new e.FindOperator("isNull", undefined, false);
+    }
+    return Ht;
+}
 
-"use strict";
+var Yt = Wt();
 
-Object.defineProperty(nt, "__esModule", {
-    value: true
-});
+const $t = e(Yt);
 
-var at = nt.MoreThan = it;
+var er = {};
 
-const ot = s;
+var tr;
 
-function it(e) {
-    return new ot.FindOperator("moreThan", e);
+function rr() {
+    if (tr) return er;
+    tr = 1;
+    "use strict";
+    Object.defineProperty(er, "__esModule", {
+        value: true
+    });
+    er.LessThan = t;
+    const e = s();
+    function t(t) {
+        return new e.FindOperator("lessThan", t);
+    }
+    return er;
 }
 
-var ut = {};
-
-"use strict";
+var nr = rr();
 
-Object.defineProperty(ut, "__esModule", {
-    value: true
-});
+const sr = e(nr);
 
-var ct = ut.MoreThanOrEqual = lt;
+var or = {};
 
-const dt = s;
+var ur;
 
-function lt(e) {
-    return new dt.FindOperator("moreThanOrEqual", e);
+function ir() {
+    if (ur) return or;
+    ur = 1;
+    "use strict";
+    Object.defineProperty(or, "__esModule", {
+        value: true
+    });
+    or.LessThanOrEqual = t;
+    const e = s();
+    function t(t) {
+        return new e.FindOperator("lessThanOrEqual", t);
+    }
+    return or;
 }
 
-var yt = {};
-
-"use strict";
+var ar = ir();
 
-Object.defineProperty(yt, "__esModule", {
-    value: true
-});
+const cr = e(ar);
 
-var pt = yt.Not = ft;
+var vr = {};
 
-const vt = s;
+var fr;
 
-function ft(e) {
-    return new vt.FindOperator("not", e);
+function dr() {
+    if (fr) return vr;
+    fr = 1;
+    "use strict";
+    Object.defineProperty(vr, "__esModule", {
+        value: true
+    });
+    vr.ILike = t;
+    const e = s();
+    function t(t) {
+        return new e.FindOperator("ilike", t);
+    }
+    return vr;
 }
 
-var Ot = {};
-
-"use strict";
+var lr = dr();
 
-Object.defineProperty(Ot, "__esModule", {
-    value: true
-});
+const yr = e(lr);
 
-var mt = Ot.Raw = gt;
+var pr = {};
 
-const _t = s;
+var Or;
 
-function gt(e, t) {
-    if (typeof e !== "function") {
-        return new _t.FindOperator("raw", e, false);
+function mr() {
+    if (Or) return pr;
+    Or = 1;
+    "use strict";
+    Object.defineProperty(pr, "__esModule", {
+        value: true
+    });
+    pr.Like = t;
+    const e = s();
+    function t(t) {
+        return new e.FindOperator("like", t);
     }
-    return new _t.FindOperator("raw", [], true, true, e, t);
+    return pr;
 }
 
-var bt = {};
-
-"use strict";
+var _r = mr();
 
-Object.defineProperty(bt, "__esModule", {
-    value: true
-});
+const gr = e(_r);
 
-var ht = bt.JsonContains = Pt;
+var hr = {};
 
-const jt = s;
+var br;
 
-function Pt(e) {
-    return new jt.FindOperator("jsonContains", e);
+function jr() {
+    if (br) return hr;
+    br = 1;
+    "use strict";
+    Object.defineProperty(hr, "__esModule", {
+        value: true
+    });
+    hr.MoreThan = t;
+    const e = s();
+    function t(t) {
+        return new e.FindOperator("moreThan", t);
+    }
+    return hr;
 }
 
-var Mt = {};
-
-"use strict";
+var Pr = jr();
 
-Object.defineProperty(Mt, "__esModule", {
-    value: true
-});
+const Mr = e(Pr);
 
-var Et = {};
+var Rr = {};
 
-"use strict";
+var Er;
 
-Object.defineProperty(Et, "__esModule", {
-    value: true
-});
-
-var Rt = {};
+function Br() {
+    if (Er) return Rr;
+    Er = 1;
+    "use strict";
+    Object.defineProperty(Rr, "__esModule", {
+        value: true
+    });
+    Rr.MoreThanOrEqual = t;
+    const e = s();
+    function t(t) {
+        return new e.FindOperator("moreThanOrEqual", t);
+    }
+    return Rr;
+}
 
-"use strict";
+var Sr = Br();
 
-Object.defineProperty(Rt, "__esModule", {
-    value: true
-});
+const Ir = e(Sr);
 
-var Bt = {};
+var Nr = {};
 
-"use strict";
+var Fr;
 
-Object.defineProperty(Bt, "__esModule", {
-    value: true
-});
+function wr() {
+    if (Fr) return Nr;
+    Fr = 1;
+    "use strict";
+    Object.defineProperty(Nr, "__esModule", {
+        value: true
+    });
+    Nr.Not = t;
+    const e = s();
+    function t(t) {
+        return new e.FindOperator("not", t);
+    }
+    return Nr;
+}
 
-var St = {};
+var kr = wr();
 
-"use strict";
+const Dr = e(kr);
 
-Object.defineProperty(St, "__esModule", {
-    value: true
-});
+var Cr = {};
 
-var It = {};
+var Tr;
 
-"use strict";
+function xr() {
+    if (Tr) return Cr;
+    Tr = 1;
+    "use strict";
+    Object.defineProperty(Cr, "__esModule", {
+        value: true
+    });
+    Cr.Raw = t;
+    const e = s();
+    function t(t, r) {
+        if (typeof t !== "function") {
+            return new e.FindOperator("raw", t, false);
+        }
+        return new e.FindOperator("raw", [], true, true, t, r);
+    }
+    return Cr;
+}
 
-Object.defineProperty(It, "__esModule", {
-    value: true
-});
+var Lr = xr();
 
-var Nt = {};
+const Ar = e(Lr);
 
-"use strict";
+var Qr = {};
 
-Object.defineProperty(Nt, "__esModule", {
-    value: true
-});
+var qr;
 
-var Ft = {};
+function Ur() {
+    if (qr) return Qr;
+    qr = 1;
+    "use strict";
+    Object.defineProperty(Qr, "__esModule", {
+        value: true
+    });
+    Qr.JsonContains = t;
+    const e = s();
+    function t(t) {
+        return new e.FindOperator("jsonContains", t);
+    }
+    return Qr;
+}
 
-"use strict";
+var Xr = Ur();
 
-Object.defineProperty(Ft, "__esModule", {
-    value: true
-});
+const zr = e(Xr);
 
-var Tt = {};
+var Kr = Ut();
 
-"use strict";
+const Zr = e(Kr);
 
-Object.defineProperty(Tt, "__esModule", {
-    value: true
-});
+var Gr = {};
 
-var wt = {};
+var Jr;
 
-"use strict";
+function Hr() {
+    if (Jr) return Gr;
+    Jr = 1;
+    "use strict";
+    Object.defineProperty(Gr, "__esModule", {
+        value: true
+    });
+    return Gr;
+}
 
-Object.defineProperty(wt, "__esModule", {
-    value: true
-});
+var Vr = Hr();
 
-var Ct = {};
+const Wr = e(Vr);
 
-"use strict";
+var Yr = {};
 
-Object.defineProperty(Ct, "__esModule", {
-    value: true
-});
+var $r;
 
-var kt = {};
+function en() {
+    if ($r) return Yr;
+    $r = 1;
+    "use strict";
+    Object.defineProperty(Yr, "__esModule", {
+        value: true
+    });
+    return Yr;
+}
 
-"use strict";
+var tn = en();
 
-Object.defineProperty(kt, "__esModule", {
-    value: true
-});
+const rn = e(tn);
 
-var Dt = a();
+var nn = s();
 
-const Lt = e(Dt);
+const sn = e(nn);
 
-var At = i();
+var on = {};
 
-const xt = e(At);
+var un;
 
-var qt = {};
+function an() {
+    if (un) return on;
+    un = 1;
+    "use strict";
+    Object.defineProperty(on, "__esModule", {
+        value: true
+    });
+    return on;
+}
 
-"use strict";
+var cn = an();
 
-Object.defineProperty(qt, "__esModule", {
-    value: true
-});
+const vn = e(cn);
 
-var Ut = qt.BaseEntity = void 0;
+var fn = {};
 
-const Qt = c;
+var dn;
 
-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);
-        Qt.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();
-    }
+function ln() {
+    if (dn) return fn;
+    dn = 1;
+    "use strict";
+    Object.defineProperty(fn, "__esModule", {
+        value: true
+    });
+    return fn;
 }
 
-Ut = qt.BaseEntity = BaseEntity;
+var yn = ln();
 
-var Xt = {};
+const pn = e(yn);
 
-"use strict";
+var On = {};
 
-Object.defineProperty(Xt, "__esModule", {
-    value: true
-});
+var mn;
 
-var Kt = {};
+function _n() {
+    if (mn) return On;
+    mn = 1;
+    "use strict";
+    Object.defineProperty(On, "__esModule", {
+        value: true
+    });
+    return On;
+}
 
-"use strict";
+var gn = _n();
 
-Object.defineProperty(Kt, "__esModule", {
-    value: true
-});
+const hn = e(gn);
 
-var zt = {};
+var bn = {};
 
-"use strict";
+var jn;
 
-Object.defineProperty(zt, "__esModule", {
-    value: true
-});
+function Pn() {
+    if (jn) return bn;
+    jn = 1;
+    "use strict";
+    Object.defineProperty(bn, "__esModule", {
+        value: true
+    });
+    return bn;
+}
 
-var Zt = {};
+var Mn = Pn();
 
-"use strict";
+const Rn = e(Mn);
 
-Object.defineProperty(Zt, "__esModule", {
-    value: true
-});
+var En = u();
 
-var Jt = {};
+const Bn = e(En);
 
-"use strict";
+var Sn = {};
 
-Object.defineProperty(Jt, "__esModule", {
-    value: true
-});
+var In;
 
-var Gt = {};
+function Nn() {
+    if (In) return Sn;
+    In = 1;
+    "use strict";
+    Object.defineProperty(Sn, "__esModule", {
+        value: true
+    });
+    return Sn;
+}
 
-"use strict";
+var Fn = Nn();
 
-Object.defineProperty(Gt, "__esModule", {
-    value: true
-});
+const wn = e(Fn);
 
-var Ht = {};
+var kn = {};
 
-"use strict";
+var Dn;
 
-Object.defineProperty(Ht, "__esModule", {
-    value: true
-});
+function Cn() {
+    if (Dn) return kn;
+    Dn = 1;
+    "use strict";
+    Object.defineProperty(kn, "__esModule", {
+        value: true
+    });
+    return kn;
+}
 
-var Vt = {};
+var Tn = Cn();
 
-"use strict";
+const xn = e(Tn);
 
-Object.defineProperty(Vt, "__esModule", {
-    value: true
-});
+var Ln = {};
 
-var Wt = {};
+var An;
 
-"use strict";
+function Qn() {
+    if (An) return Ln;
+    An = 1;
+    "use strict";
+    Object.defineProperty(Ln, "__esModule", {
+        value: true
+    });
+    return Ln;
+}
+
+var qn = Qn();
 
-Object.defineProperty(Wt, "__esModule", {
-    value: true
-});
+const Un = e(qn);
 
-var Yt = {};
+var Xn = {};
 
-"use strict";
+var zn;
 
-Object.defineProperty(Yt, "__esModule", {
-    value: true
-});
+function Kn() {
+    if (zn) return Xn;
+    zn = 1;
+    "use strict";
+    Object.defineProperty(Xn, "__esModule", {
+        value: true
+    });
+    return Xn;
+}
 
-var $t = {};
+var Zn = Kn();
 
-var er = {};
+const Gn = e(Zn);
 
-"use strict";
+var Jn = i();
 
-Object.defineProperty(er, "__esModule", {
-    value: true
-});
+const Hn = e(Jn);
 
-var tr = er.BSON = void 0;
+var Vn = {};
 
-(function(e) {
+var Wn;
+
+function Yn() {
+    if (Wn) return Vn;
+    Wn = 1;
     "use strict";
-    Object.defineProperty(e, "__esModule", {
+    Object.defineProperty(Vn, "__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 = er;
-    Object.defineProperty(e, "BSON", {
-        enumerable: true,
-        get: function() {
-            return t.BSON;
-        }
+    return Vn;
+}
+
+var $n = Yn();
+
+const es = e($n);
+
+var ts = {};
+
+var rs;
+
+function ns() {
+    if (rs) return ts;
+    rs = 1;
+    "use strict";
+    Object.defineProperty(ts, "__esModule", {
+        value: true
     });
-    Object.defineProperty(e, "BSONRegExp", {
-        enumerable: true,
-        get: function() {
-            return t.BSONRegExp;
-        }
+    return ts;
+}
+
+var ss = ns();
+
+const os = e(ss);
+
+var us = a();
+
+const is = e(us);
+
+var as = c();
+
+const cs = e(as);
+
+var vs = v();
+
+const fs = e(vs);
+
+var ds = f();
+
+const ls = e(ds);
+
+var ys = d();
+
+const ps = e(ys);
+
+var Os = l();
+
+const ms = e(Os);
+
+var _s = y();
+
+const gs = e(_s);
+
+var hs = {};
+
+var bs;
+
+function js() {
+    if (bs) return hs;
+    bs = 1;
+    "use strict";
+    Object.defineProperty(hs, "__esModule", {
+        value: true
     });
-    Object.defineProperty(e, "BSONSymbol", {
-        enumerable: true,
-        get: function() {
-            return t.BSONSymbol;
+    hs.BaseEntity = void 0;
+    const e = p();
+    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 t = this.constructor;
+            return t.getRepository().save(this, e);
         }
-    });
-    Object.defineProperty(e, "Binary", {
-        enumerable: true,
-        get: function() {
-            return t.Binary;
+        remove(e) {
+            const t = this.constructor;
+            return t.getRepository().remove(this, e);
         }
-    });
-    Object.defineProperty(e, "Code", {
-        enumerable: true,
-        get: function() {
-            return t.Code;
+        softRemove(e) {
+            const t = this.constructor;
+            return t.getRepository().softRemove(this, e);
         }
-    });
-    Object.defineProperty(e, "DBRef", {
-        enumerable: true,
-        get: function() {
-            return t.DBRef;
+        recover(e) {
+            const t = this.constructor;
+            return t.getRepository().recover(this, e);
         }
-    });
-    Object.defineProperty(e, "Decimal128", {
-        enumerable: true,
-        get: function() {
-            return t.Decimal128;
+        async reload() {
+            const t = this.constructor;
+            const r = t.getRepository().metadata.getEntityIdMap(this);
+            if (!r) {
+                throw new Error(`Entity doesn't have id-s set, cannot reload entity`);
+            }
+            const n = await t.getRepository().findOneByOrFail(r);
+            e.ObjectUtils.assign(this, n);
         }
-    });
-    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, ...t) {
+            return this.getRepository().merge(e, ...t);
         }
-    });
-    Object.defineProperty(e, "serialize", {
-        enumerable: true,
-        get: function() {
-            return t.serialize;
+        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();
+        }
+    }
+    hs.BaseEntity = BaseEntity;
+    return hs;
+}
+
+var Ps = js();
+
+const Ms = e(Ps);
+
+var Rs = O();
+
+const Es = e(Rs);
+
+var Bs = m();
+
+const Ss = e(Bs);
+
+var Is = {};
+
+var Ns;
+
+function Fs() {
+    if (Ns) return Is;
+    Ns = 1;
+    "use strict";
+    Object.defineProperty(Is, "__esModule", {
+        value: true
     });
-})($t);
+    return Is;
+}
 
-const rr = e($t);
+var ws = Fs();
 
-var sr = {};
+const ks = e(ws);
 
-"use strict";
+var Ds = {};
 
-Object.defineProperty(sr, "__esModule", {
-    value: true
-});
+var Cs;
 
-var nr = {};
+function Ts() {
+    if (Cs) return Ds;
+    Cs = 1;
+    "use strict";
+    Object.defineProperty(Ds, "__esModule", {
+        value: true
+    });
+    return Ds;
+}
 
-"use strict";
+var xs = Ts();
 
-Object.defineProperty(nr, "__esModule", {
-    value: true
-});
+const Ls = e(xs);
 
-var ar = {};
+var As = _();
 
-"use strict";
+const Qs = e(As);
 
-Object.defineProperty(ar, "__esModule", {
-    value: true
-});
+var qs = g();
 
-var or = {};
+const Us = e(qs);
 
-"use strict";
+var Xs = h();
 
-Object.defineProperty(or, "__esModule", {
-    value: true
-});
+const zs = e(Xs);
 
-var ir = or.NotBrackets = void 0;
+var Ks = b();
 
-const ur = d;
+const Zs = e(Ks);
 
-class NotBrackets extends ur.Brackets {
-    constructor() {
-        super(...arguments);
-        this["@instanceof"] = Symbol.for("NotBrackets");
-    }
+var Gs = j();
+
+const Js = e(Gs);
+
+var Hs = P();
+
+const Vs = e(Hs);
+
+var Ws = M();
+
+const Ys = e(Ws);
+
+var $s = {};
+
+var eo;
+
+function to() {
+    if (eo) return $s;
+    eo = 1;
+    "use strict";
+    Object.defineProperty($s, "__esModule", {
+        value: true
+    });
+    return $s;
 }
 
-ir = or.NotBrackets = NotBrackets;
+var ro = to();
 
-var cr = f();
+const no = e(ro);
 
-const dr = e(cr);
+var so = {};
 
-var lr = {};
+var oo;
 
-"use strict";
+function uo() {
+    if (oo) return so;
+    oo = 1;
+    "use strict";
+    Object.defineProperty(so, "__esModule", {
+        value: true
+    });
+    return so;
+}
 
-Object.defineProperty(lr, "__esModule", {
-    value: true
-});
+var io = uo();
 
-var yr = lr.LegacyOracleNamingStrategy = void 0;
+const ao = e(io);
 
-const pr = O;
+var co = {};
 
-const vr = g;
+var vo;
 
-const fr = b;
+function fo() {
+    if (vo) return co;
+    vo = 1;
+    "use strict";
+    Object.defineProperty(co, "__esModule", {
+        value: true
+    });
+    return co;
+}
 
-class LegacyOracleNamingStrategy extends vr.DefaultNamingStrategy {
-    constructor(e = "hash") {
-        super();
-        this.IDENTIFIER_MAX_SIZE = 30;
-        this.DEFAULT_COLUMN_PREFIX = "COL_";
-        this.shortenStrategy = e;
-    }
-    columnName(e, t, r) {
-        const s = super.columnName(e, t, r);
-        if (this.shortenStrategy === "truncate") {
-            return this.truncateIdentifier(s);
-        } else if (this.shortenStrategy === "hash") {
-            return this.hashIdentifier(s, this.DEFAULT_COLUMN_PREFIX);
-        } else {
-            throw new fr.TypeORMError(`Invalid shortenStrategy`);
+var lo = fo();
+
+const yo = e(lo);
+
+var po = {};
+
+var Oo;
+
+function mo() {
+    if (Oo) return po;
+    Oo = 1;
+    "use strict";
+    Object.defineProperty(po, "__esModule", {
+        value: true
+    });
+    return po;
+}
+
+var _o = mo();
+
+const go = e(_o);
+
+var ho = {};
+
+var bo;
+
+function jo() {
+    if (bo) return ho;
+    bo = 1;
+    "use strict";
+    Object.defineProperty(ho, "__esModule", {
+        value: true
+    });
+    return ho;
+}
+
+var Po = jo();
+
+const Mo = e(Po);
+
+var Ro = {};
+
+var Eo;
+
+function Bo() {
+    if (Eo) return Ro;
+    Eo = 1;
+    "use strict";
+    Object.defineProperty(Ro, "__esModule", {
+        value: true
+    });
+    return Ro;
+}
+
+var So = Bo();
+
+const Io = e(So);
+
+var No = {};
+
+var Fo;
+
+function wo() {
+    if (Fo) return No;
+    Fo = 1;
+    "use strict";
+    Object.defineProperty(No, "__esModule", {
+        value: true
+    });
+    return No;
+}
+
+var ko = wo();
+
+const Do = e(ko);
+
+var Co = {};
+
+var To;
+
+function xo() {
+    if (To) return Co;
+    To = 1;
+    "use strict";
+    Object.defineProperty(Co, "__esModule", {
+        value: true
+    });
+    return Co;
+}
+
+var Lo = xo();
+
+const Ao = e(Lo);
+
+var Qo = {};
+
+var qo = {};
+
+var Uo;
+
+function Xo() {
+    if (Uo) return qo;
+    Uo = 1;
+    "use strict";
+    Object.defineProperty(qo, "__esModule", {
+        value: true
+    });
+    qo.BSON = void 0;
+    return qo;
+}
+
+var zo;
+
+function Ko() {
+    if (zo) return Qo;
+    zo = 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 t = Xo();
+        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;
+            }
+        });
+    })(Qo);
+    return Qo;
+}
+
+var Zo = Ko();
+
+const Go = e(Zo);
+
+var Jo = {};
+
+var Ho;
+
+function Vo() {
+    if (Ho) return Jo;
+    Ho = 1;
+    "use strict";
+    Object.defineProperty(Jo, "__esModule", {
+        value: true
+    });
+    return Jo;
+}
+
+var Wo = Vo();
+
+const Yo = e(Wo);
+
+var $o = {};
+
+var eu;
+
+function tu() {
+    if (eu) return $o;
+    eu = 1;
+    "use strict";
+    Object.defineProperty($o, "__esModule", {
+        value: true
+    });
+    return $o;
+}
+
+var ru = tu();
+
+const nu = e(ru);
+
+var su = {};
+
+var ou;
+
+function uu() {
+    if (ou) return su;
+    ou = 1;
+    "use strict";
+    Object.defineProperty(su, "__esModule", {
+        value: true
+    });
+    return su;
+}
+
+var iu = uu();
+
+const au = e(iu);
+
+var cu = R();
+
+const vu = e(cu);
+
+var fu = E();
+
+const du = e(fu);
+
+var lu = B();
+
+const yu = e(lu);
+
+var pu = S();
+
+const Ou = e(pu);
+
+var mu = I();
+
+const _u = e(mu);
+
+var gu = N();
+
+const hu = e(gu);
+
+var bu = F();
+
+const ju = e(bu);
+
+var Pu = w();
+
+const Mu = e(Pu);
+
+var Ru = k();
+
+const Eu = e(Ru);
+
+var Bu = {};
+
+var Su;
+
+function Iu() {
+    if (Su) return Bu;
+    Su = 1;
+    "use strict";
+    Object.defineProperty(Bu, "__esModule", {
+        value: true
+    });
+    Bu.NotBrackets = void 0;
+    const e = k();
+    class NotBrackets extends e.Brackets {
+        constructor() {
+            super(...arguments);
+            this["@instanceof"] = Symbol.for("NotBrackets");
         }
     }
-    hashIdentifier(e, t) {
-        if (t.length >= this.IDENTIFIER_MAX_SIZE) {
-            throw new fr.TypeORMError(`Prefix must be shorter than IDENTIFIER_MAX_SIZE`);
+    Bu.NotBrackets = NotBrackets;
+    return Bu;
+}
+
+var Nu = Iu();
+
+const Fu = e(Nu);
+
+var wu = D();
+
+const ku = e(wu);
+
+var Du = C();
+
+const Cu = e(Du);
+
+var Tu = T();
+
+const xu = e(Tu);
+
+var Lu = x();
+
+const Au = e(Lu);
+
+var Qu = L();
+
+const qu = e(Qu);
+
+var Uu = A();
+
+const Xu = e(Uu);
+
+var zu = Q();
+
+const Ku = e(zu);
+
+var Zu = q();
+
+const Gu = e(Zu);
+
+var Ju = {};
+
+var Hu;
+
+function Vu() {
+    if (Hu) return Ju;
+    Hu = 1;
+    "use strict";
+    Object.defineProperty(Ju, "__esModule", {
+        value: true
+    });
+    Ju.LegacyOracleNamingStrategy = void 0;
+    const e = U();
+    const t = q();
+    const r = n();
+    class LegacyOracleNamingStrategy extends t.DefaultNamingStrategy {
+        constructor(e = "hash") {
+            super();
+            this.IDENTIFIER_MAX_SIZE = 30;
+            this.DEFAULT_COLUMN_PREFIX = "COL_";
+            this.shortenStrategy = e;
+        }
+        columnName(e, t, n) {
+            const s = super.columnName(e, t, n);
+            if (this.shortenStrategy === "truncate") {
+                return this.truncateIdentifier(s);
+            } else if (this.shortenStrategy === "hash") {
+                return this.hashIdentifier(s, this.DEFAULT_COLUMN_PREFIX);
+            } else {
+                throw new r.TypeORMError(`Invalid shortenStrategy`);
+            }
+        }
+        hashIdentifier(t, n) {
+            if (n.length >= this.IDENTIFIER_MAX_SIZE) {
+                throw new r.TypeORMError(`Prefix must be shorter than IDENTIFIER_MAX_SIZE`);
+            }
+            return n + e.RandomGenerator.sha1(t).substring(0, this.IDENTIFIER_MAX_SIZE - n.length);
+        }
+        truncateIdentifier(e) {
+            if (e.length > this.IDENTIFIER_MAX_SIZE) {
+                return e.substring(0, this.IDENTIFIER_MAX_SIZE);
+            } else {
+                return e;
+            }
         }
-        return t + pr.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;
+    Ju.LegacyOracleNamingStrategy = LegacyOracleNamingStrategy;
+    return Ju;
+}
+
+var Wu = Vu();
+
+const Yu = e(Wu);
+
+var $u = {};
+
+var ei;
+
+function ti() {
+    if (ei) return $u;
+    ei = 1;
+    "use strict";
+    Object.defineProperty($u, "__esModule", {
+        value: true
+    });
+    $u.EntitySchema = void 0;
+    class EntitySchema {
+        constructor(e) {
+            this.options = e;
+            this["@instanceof"] = Symbol.for("EntitySchema");
         }
     }
+    $u.EntitySchema = EntitySchema;
+    return $u;
 }
 
-yr = lr.LegacyOracleNamingStrategy = LegacyOracleNamingStrategy;
+var ri = ti();
 
-var Or = {};
+const ni = e(ri);
 
-"use strict";
+var si = {};
 
-Object.defineProperty(Or, "__esModule", {
-    value: true
-});
+var oi;
 
-var mr = Or.EntitySchema = void 0;
+function ui() {
+    if (oi) return si;
+    oi = 1;
+    "use strict";
+    Object.defineProperty(si, "__esModule", {
+        value: true
+    });
+    si.EntitySchemaEmbeddedColumnOptions = void 0;
+    class EntitySchemaEmbeddedColumnOptions {}
+    si.EntitySchemaEmbeddedColumnOptions = EntitySchemaEmbeddedColumnOptions;
+    return si;
+}
 
-class EntitySchema {
-    constructor(e) {
-        this.options = e;
-        this["@instanceof"] = Symbol.for("EntitySchema");
-    }
+var ii = ui();
+
+const ai = e(ii);
+
+var ci = {};
+
+var vi;
+
+function fi() {
+    if (vi) return ci;
+    vi = 1;
+    "use strict";
+    Object.defineProperty(ci, "__esModule", {
+        value: true
+    });
+    ci.EntitySchemaOptions = void 0;
+    class EntitySchemaOptions {}
+    ci.EntitySchemaOptions = EntitySchemaOptions;
+    return ci;
 }
 
-mr = Or.EntitySchema = EntitySchema;
+var di = fi();
+
+const li = e(di);
+
+var yi = X();
+
+const pi = e(yi);
+
+var Oi = z();
+
+const mi = e(Oi);
+
+const _i = Ru.Brackets;
+
+const gi = fu.ConnectionOptionsReader;
+
+const hi = K.DataSource;
+
+const bi = Zu.DefaultNamingStrategy;
+
+const ji = mu.DeleteQueryBuilder;
+
+const Pi = Tu.DeleteResult;
+
+const Mi = ri.EntitySchema;
+
+const Ri = ii.EntitySchemaEmbeddedColumnOptions;
+
+const Ei = di.EntitySchemaOptions;
+
+const Bi = gu.InsertQueryBuilder;
 
-var _r = {};
+const Si = wu.InsertResult;
 
-"use strict";
+const Ii = yi.InstanceChecker;
 
-Object.defineProperty(_r, "__esModule", {
-    value: true
-});
+const Ni = Wu.LegacyOracleNamingStrategy;
 
-var gr = _r.EntitySchemaEmbeddedColumnOptions = void 0;
+const Fi = Uu.Migration;
 
-class EntitySchemaEmbeddedColumnOptions {}
+const wi = zu.MigrationExecutor;
 
-gr = _r.EntitySchemaEmbeddedColumnOptions = EntitySchemaEmbeddedColumnOptions;
+const ki = Qu.MongoEntityManager;
 
-var br = {};
+const Di = Nu.NotBrackets;
 
-"use strict";
+const Ci = lu.QueryBuilder;
 
-Object.defineProperty(br, "__esModule", {
-    value: true
-});
+const Ti = Lu.QueryResult;
 
-var hr = br.EntitySchemaOptions = void 0;
+const xi = Pu.RelationQueryBuilder;
 
-class EntitySchemaOptions {}
+const Li = pu.SelectQueryBuilder;
 
-hr = br.EntitySchemaOptions = EntitySchemaOptions;
+const Ai = Oi.TreeRepositoryUtils;
 
-const jr = h.DataSource;
+const Qi = bu.UpdateQueryBuilder;
 
-const Pr = cr.MongoEntityManager;
+const qi = Du.UpdateResult;
 
-export { ue as And, ye as Any, Oe as ArrayContainedBy, be as ArrayContains, Me as ArrayOverlap, Ut as BaseEntity, Se as Between, jr as DataSource, mr as EntitySchema, gr as EntitySchemaEmbeddedColumnOptions, hr as EntitySchemaOptions, ke as Equal, we as EqualOperator, We as ILike, xe as IsNull, ht as JsonContains, yr as LegacyOracleNamingStrategy, Xe as LessThan, Je as LessThanOrEqual, tt as Like, Pr as MongoEntityManager, at as MoreThan, ct as MoreThanOrEqual, pt as Not, ir as NotBrackets, mt as Raw };
+export { _i as Brackets, gi as ConnectionOptionsReader, hi as DataSource, bi as DefaultNamingStrategy, ji as DeleteQueryBuilder, Pi as DeleteResult, Mi as EntitySchema, Ri as EntitySchemaEmbeddedColumnOptions, Ei as EntitySchemaOptions, Bi as InsertQueryBuilder, Si as InsertResult, Ii as InstanceChecker, Ni as LegacyOracleNamingStrategy, Fi as Migration, wi as MigrationExecutor, ki as MongoEntityManager, Di as NotBrackets, Ci as QueryBuilder, Ti as QueryResult, xi as RelationQueryBuilder, Li as SelectQueryBuilder, Ai as TreeRepositoryUtils, Qi as UpdateQueryBuilder, qi as UpdateResult };