lakutata 2.0.96 → 2.0.98

package/orm.mjs

@@ -1,51 +1,45 @@
-/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
-import "./vendor/Package.internal.175.mjs";
+/* Build Date: Wed Nov 26 2025 13:02:50 GMT+0800 (China Standard Time) */
+import "./vendor/Package.internal.1.mjs";
 
-import { D as a, a2 as e } from "./vendor/Package.internal.184.mjs";
+import { a as e, F as r, f as a, g as s, O as c, B as d, h as f, D as O, e as g, R as b } from "./vendor/Package.internal.51.mjs";
 
-export { az as AbstractLogger, aA as AdvancedConsoleLogger, ae as And, af as Any, ag as ArrayContainedBy, ah as ArrayContains, ai as ArrayOverlap, aF as BaseEntity, aj as Between, Y as Brackets, K as ConnectionOptionsReader, a5 as DefaultNamingStrategy, L as DeleteQueryBuilder, a0 as DeleteResult, aD as EntityMetadata, a7 as EntitySchema, a8 as EntitySchemaEmbeddedColumnOptions, a9 as EntitySchemaOptions, ak as Equal, aw as EqualOperator, aC as FileLogger, ax as FindOperator, ay as FindOptionsUtils, ap as ILike, al as In, N as InsertQueryBuilder, _ as InsertResult, aa as InstanceChecker, am as IsNull, av as JsonContains, a6 as LegacyOracleNamingStrategy, an as LessThan, ao as LessThanOrEqual, aq as Like, a3 as Migration, a4 as MigrationExecutor, aH as MongoRepository, ar as MoreThan, as as MoreThanOrEqual, aP as MssqlParameter, at as Not, Z as NotBrackets, Q as QueryBuilder, a1 as QueryResult, au as Raw, X as RelationQueryBuilder, aE as Repository, S as SelectQueryBuilder, aB as SimpleConsoleLogger, aO as Table, aI as TableCheck, aJ as TableColumn, aK as TableExclusion, aL as TableForeignKey, aM as TableIndex, aN as TableUnique, aG as TreeRepository, ab as TreeRepositoryUtils, W as UpdateQueryBuilder, $ as UpdateResult, ad as getFromContainer, ac as useContainer } from "./vendor/Package.internal.184.mjs";
+export { G as AbstractLogger, H as AdvancedConsoleLogger, m as Brackets, i as ConnectionOptionsReader, u as DefaultNamingStrategy, j as DeleteQueryBuilder, p as DeleteResult, L as EntityMetadata, K as FileLogger, z as FindOperator, A as FindOptionsUtils, y as In, k as InsertQueryBuilder, n as InsertResult, v as InstanceChecker, M as Migration, t as MigrationExecutor, W as MongoRepository, a2 as MssqlParameter, Q as QueryBuilder, q as QueryResult, l as RelationQueryBuilder, N as Repository, S as SelectQueryBuilder, J as SimpleConsoleLogger, a1 as Table, X as TableCheck, Y as TableColumn, Z as TableExclusion, _ as TableForeignKey, $ as TableIndex, a0 as TableUnique, V as TreeRepository, T as TreeRepositoryUtils, U as UpdateQueryBuilder, o as UpdateResult, x as getFromContainer, w as useContainer } from "./vendor/Package.internal.51.mjs";
 
-import "./vendor/Package.internal.8.mjs";
+import { D as h } from "./vendor/Package.internal.512.mjs";
 
-import "./vendor/Package.internal.135.mjs";
+import "./vendor/Package.internal.2.mjs";
 
-import "fs/promises";
+import "./vendor/Package.internal.310.mjs";
 
-import "path";
+import "./vendor/Package.internal.3.mjs";
 
-import "./vendor/Package.internal.70.mjs";
+import "./vendor/Package.internal.52.mjs";
 
-import "./vendor/Package.internal.28.mjs";
+import "buffer";
 
-import "./vendor/Package.internal.82.mjs";
+import "tty";
+
+import "util";
+
+import "./vendor/Package.internal.6.mjs";
 
 import "fs";
 
+import "path";
+
 import "os";
 
 import "crypto";
 
-import "./vendor/Package.internal.183.mjs";
-
-import "./vendor/Package.internal.24.mjs";
-
 import "events";
 
 import "stream";
 
-import "./vendor/Package.internal.27.mjs";
-
 import "module";
 
-import "url";
-
-import "./vendor/Package.internal.66.mjs";
-
-import "util";
-
-import "./vendor/Package.internal.44.mjs";
+import "fs/promises";
 
-import "./vendor/Package.internal.37.mjs";
+import "url";
 
 import "node:url";
 
@@ -55,86 +49,893 @@ import "node:fs";
 
 import "node:fs/promises";
 
-import "./vendor/Package.internal.113.mjs";
-
 import "node:events";
 
 import "node:stream";
 
 import "node:string_decoder";
 
-import "./vendor/Package.internal.67.mjs";
+e();
 
-import "./vendor/Package.internal.68.mjs";
+var P = {};
 
-import "tty";
+Object.defineProperty(P, "__esModule", {
+    value: true
+});
 
-import "./vendor/Package.internal.69.mjs";
+var R = {};
 
-import "./vendor/Package.internal.178.mjs";
+Object.defineProperty(R, "__esModule", {
+    value: true
+});
 
-import "./vendor/Package.internal.43.mjs";
+var E = {};
 
-import "./vendor/Package.internal.177.mjs";
+Object.defineProperty(E, "__esModule", {
+    value: true
+});
 
-import "buffer";
+var B = {};
 
-import "./vendor/Package.internal.179.mjs";
+Object.defineProperty(B, "__esModule", {
+    value: true
+});
 
-import "./vendor/Package.internal.129.mjs";
+var I = {};
 
-import "./vendor/Package.internal.186.mjs";
+Object.defineProperty(I, "__esModule", {
+    value: true
+});
 
-import "./vendor/Package.internal.55.mjs";
+var F = {};
 
-import "./vendor/Package.internal.56.mjs";
+Object.defineProperty(F, "__esModule", {
+    value: true
+});
 
-import "./vendor/Package.internal.57.mjs";
+var C = {};
 
-import "./vendor/Package.internal.86.mjs";
+Object.defineProperty(C, "__esModule", {
+    value: true
+});
 
-import "./vendor/Package.internal.105.mjs";
+var D = {};
 
-import "./vendor/Package.internal.72.mjs";
+Object.defineProperty(D, "__esModule", {
+    value: true
+});
 
-import "./vendor/Package.internal.52.mjs";
+var ee = {};
+
+Object.defineProperty(ee, "__esModule", {
+    value: true
+});
+
+var te = {};
+
+Object.defineProperty(te, "__esModule", {
+    value: true
+});
+
+var re = {};
+
+Object.defineProperty(re, "__esModule", {
+    value: true
+});
+
+var ne = {};
+
+Object.defineProperty(ne, "__esModule", {
+    value: true
+});
+
+var ae = {};
+
+Object.defineProperty(ae, "__esModule", {
+    value: true
+});
+
+var oe = {};
+
+Object.defineProperty(oe, "__esModule", {
+    value: true
+});
+
+var ie = oe.And = ue;
+
+const se = r;
+
+function ue(...e) {
+    return new se.FindOperator("and", e, true, true);
+}
+
+var ce = {};
+
+Object.defineProperty(ce, "__esModule", {
+    value: true
+});
+
+var de = ce.Any = ye;
+
+const le = r;
+
+function ye(e) {
+    return new le.FindOperator("any", e);
+}
+
+var pe = {};
+
+Object.defineProperty(pe, "__esModule", {
+    value: true
+});
+
+var ve = pe.ArrayContainedBy = Oe;
+
+const fe = r;
+
+function Oe(e) {
+    return new fe.FindOperator("arrayContainedBy", e);
+}
+
+var me = {};
+
+Object.defineProperty(me, "__esModule", {
+    value: true
+});
+
+var _e = me.ArrayContains = be;
+
+const ge = r;
+
+function be(e) {
+    return new ge.FindOperator("arrayContains", e);
+}
+
+var he = {};
+
+Object.defineProperty(he, "__esModule", {
+    value: true
+});
+
+var je = he.ArrayOverlap = Me;
+
+const Pe = r;
+
+function Me(e) {
+    return new Pe.FindOperator("arrayOverlap", e);
+}
+
+var Re = {};
+
+Object.defineProperty(Re, "__esModule", {
+    value: true
+});
+
+var Ee = Re.Between = Se;
+
+const Be = r;
+
+function Se(e, t) {
+    return new Be.FindOperator("between", [ e, t ], true, true);
+}
+
+var Ie = {};
+
+var Ne = {};
+
+Object.defineProperty(Ne, "__esModule", {
+    value: true
+});
+
+var Fe = Ne.EqualOperator = void 0;
+
+const Te = r;
+
+class EqualOperator extends Te.FindOperator {
+    constructor(e) {
+        super("equal", e);
+        this["@instanceof"] = Symbol.for("EqualOperator");
+    }
+}
+
+Fe = Ne.EqualOperator = EqualOperator;
+
+Object.defineProperty(Ie, "__esModule", {
+    value: true
+});
+
+var we = Ie.Equal = ke;
+
+const Ce = Ne;
+
+function ke(e) {
+    return new Ce.EqualOperator(e);
+}
+
+var De = {};
+
+Object.defineProperty(De, "__esModule", {
+    value: true
+});
+
+var Le = De.IsNull = xe;
+
+const Ae = r;
+
+function xe() {
+    return new Ae.FindOperator("isNull", undefined, false);
+}
+
+var qe = {};
+
+Object.defineProperty(qe, "__esModule", {
+    value: true
+});
+
+var Ue = qe.LessThan = Xe;
+
+const Qe = r;
+
+function Xe(e) {
+    return new Qe.FindOperator("lessThan", e);
+}
+
+var Ke = {};
+
+Object.defineProperty(Ke, "__esModule", {
+    value: true
+});
+
+var ze = Ke.LessThanOrEqual = Je;
+
+const Ze = r;
+
+function Je(e) {
+    return new Ze.FindOperator("lessThanOrEqual", e);
+}
+
+var Ge = {};
+
+Object.defineProperty(Ge, "__esModule", {
+    value: true
+});
+
+var He = Ge.ILike = We;
+
+const Ve = r;
+
+function We(e) {
+    return new Ve.FindOperator("ilike", e);
+}
+
+var Ye = {};
+
+Object.defineProperty(Ye, "__esModule", {
+    value: true
+});
+
+var $e = Ye.Like = tt;
+
+const et = r;
+
+function tt(e) {
+    return new et.FindOperator("like", e);
+}
+
+var rt = {};
+
+Object.defineProperty(rt, "__esModule", {
+    value: true
+});
+
+var nt = rt.MoreThan = ot;
+
+const at = r;
+
+function ot(e) {
+    return new at.FindOperator("moreThan", e);
+}
+
+var it = {};
+
+Object.defineProperty(it, "__esModule", {
+    value: true
+});
+
+var st = it.MoreThanOrEqual = ct;
+
+const ut = r;
+
+function ct(e) {
+    return new ut.FindOperator("moreThanOrEqual", e);
+}
+
+var dt = {};
+
+Object.defineProperty(dt, "__esModule", {
+    value: true
+});
+
+var lt = dt.Not = pt;
+
+const yt = r;
+
+function pt(e) {
+    return new yt.FindOperator("not", e);
+}
+
+var vt = {};
+
+Object.defineProperty(vt, "__esModule", {
+    value: true
+});
+
+var ft = vt.Raw = mt;
+
+const Ot = r;
+
+function mt(e, t) {
+    if (typeof e !== "function") {
+        return new Ot.FindOperator("raw", e, false);
+    }
+    return new Ot.FindOperator("raw", [], true, true, e, t);
+}
+
+var _t = {};
+
+Object.defineProperty(_t, "__esModule", {
+    value: true
+});
+
+var gt = _t.JsonContains = ht;
+
+const bt = r;
+
+function ht(e) {
+    return new bt.FindOperator("jsonContains", e);
+}
+
+var jt = {};
+
+Object.defineProperty(jt, "__esModule", {
+    value: true
+});
+
+var Pt = {};
+
+Object.defineProperty(Pt, "__esModule", {
+    value: true
+});
+
+var Mt = {};
+
+Object.defineProperty(Mt, "__esModule", {
+    value: true
+});
+
+var Rt = {};
+
+Object.defineProperty(Rt, "__esModule", {
+    value: true
+});
+
+var Et = {};
+
+Object.defineProperty(Et, "__esModule", {
+    value: true
+});
+
+var Bt = {};
+
+Object.defineProperty(Bt, "__esModule", {
+    value: true
+});
+
+var St = {};
+
+Object.defineProperty(St, "__esModule", {
+    value: true
+});
 
-import "./vendor/Package.internal.106.mjs";
+var It = {};
+
+Object.defineProperty(It, "__esModule", {
+    value: true
+});
+
+var Nt = {};
+
+Object.defineProperty(Nt, "__esModule", {
+    value: true
+});
+
+var Ft = {};
+
+Object.defineProperty(Ft, "__esModule", {
+    value: true
+});
+
+var Tt = {};
+
+Object.defineProperty(Tt, "__esModule", {
+    value: true
+});
+
+var wt = {};
+
+Object.defineProperty(wt, "__esModule", {
+    value: true
+});
+
+a();
+
+s();
+
+var Ct = {};
+
+Object.defineProperty(Ct, "__esModule", {
+    value: true
+});
+
+var kt = Ct.BaseEntity = void 0;
+
+const Dt = c;
+
+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);
+        Dt.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();
+    }
+}
+
+kt = Ct.BaseEntity = BaseEntity;
+
+var Lt = {};
+
+Object.defineProperty(Lt, "__esModule", {
+    value: true
+});
+
+var At = {};
+
+Object.defineProperty(At, "__esModule", {
+    value: true
+});
+
+var xt = {};
+
+Object.defineProperty(xt, "__esModule", {
+    value: true
+});
+
+var qt = {};
+
+Object.defineProperty(qt, "__esModule", {
+    value: true
+});
+
+var Ut = {};
+
+Object.defineProperty(Ut, "__esModule", {
+    value: true
+});
+
+var Qt = {};
+
+Object.defineProperty(Qt, "__esModule", {
+    value: true
+});
+
+var Xt = {};
+
+Object.defineProperty(Xt, "__esModule", {
+    value: true
+});
+
+var Kt = {};
+
+Object.defineProperty(Kt, "__esModule", {
+    value: true
+});
+
+var zt = {};
+
+Object.defineProperty(zt, "__esModule", {
+    value: true
+});
+
+var Zt = {};
+
+Object.defineProperty(Zt, "__esModule", {
+    value: true
+});
+
+var Jt = {};
+
+var Gt = {};
+
+Object.defineProperty(Gt, "__esModule", {
+    value: true
+});
+
+Gt.BSON = void 0;
+
+(function(e) {
+    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 = Gt;
+    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;
+        }
+    });
+})(Jt);
+
+var Ht = {};
+
+Object.defineProperty(Ht, "__esModule", {
+    value: true
+});
+
+var Vt = {};
+
+Object.defineProperty(Vt, "__esModule", {
+    value: true
+});
+
+var Wt = {};
+
+Object.defineProperty(Wt, "__esModule", {
+    value: true
+});
+
+var Yt = {};
+
+Object.defineProperty(Yt, "__esModule", {
+    value: true
+});
+
+var $t = Yt.NotBrackets = void 0;
+
+const er = d;
+
+class NotBrackets extends er.Brackets {
+    constructor() {
+        super(...arguments);
+        this["@instanceof"] = Symbol.for("NotBrackets");
+    }
+}
+
+$t = Yt.NotBrackets = NotBrackets;
+
+var tr = f();
+
+var rr = {};
+
+Object.defineProperty(rr, "__esModule", {
+    value: true
+});
+
+var nr = rr.LegacyOracleNamingStrategy = void 0;
+
+const ar = b;
+
+const or = O;
+
+const ir = g;
+
+class LegacyOracleNamingStrategy extends or.DefaultNamingStrategy {
+    constructor(e = "hash") {
+        super();
+        this.IDENTIFIER_MAX_SIZE = 30;
+        this.DEFAULT_COLUMN_PREFIX = "COL_";
+        this.shortenStrategy = e;
+    }
+    columnName(e, t, r) {
+        const n = super.columnName(e, t, r);
+        if (this.shortenStrategy === "truncate") {
+            return this.truncateIdentifier(n);
+        } else if (this.shortenStrategy === "hash") {
+            return this.hashIdentifier(n, this.DEFAULT_COLUMN_PREFIX);
+        } else {
+            throw new ir.TypeORMError(`Invalid shortenStrategy`);
+        }
+    }
+    hashIdentifier(e, t) {
+        if (t.length >= this.IDENTIFIER_MAX_SIZE) {
+            throw new ir.TypeORMError(`Prefix must be shorter than IDENTIFIER_MAX_SIZE`);
+        }
+        return t + ar.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;
+        }
+    }
+}
 
-import "./vendor/Package.internal.107.mjs";
+nr = rr.LegacyOracleNamingStrategy = LegacyOracleNamingStrategy;
 
-import "./vendor/Package.internal.83.mjs";
+var sr = {};
 
-import "./vendor/Package.internal.53.mjs";
+Object.defineProperty(sr, "__esModule", {
+    value: true
+});
 
-import "./vendor/Package.internal.54.mjs";
+var ur = sr.EntitySchema = void 0;
 
-import "./vendor/Package.internal.108.mjs";
+class EntitySchema {
+    constructor(e) {
+        this.options = e;
+        this["@instanceof"] = Symbol.for("EntitySchema");
+    }
+}
 
-import "./vendor/Package.internal.127.mjs";
+ur = sr.EntitySchema = EntitySchema;
 
-import "./vendor/Package.internal.128.mjs";
+var cr = {};
 
-import "./vendor/Package.internal.100.mjs";
+Object.defineProperty(cr, "__esModule", {
+    value: true
+});
 
-import "./vendor/Package.internal.101.mjs";
+var dr = cr.EntitySchemaEmbeddedColumnOptions = void 0;
 
-import "./vendor/Package.internal.34.mjs";
+class EntitySchemaEmbeddedColumnOptions {}
 
-import "./vendor/Package.internal.35.mjs";
+dr = cr.EntitySchemaEmbeddedColumnOptions = EntitySchemaEmbeddedColumnOptions;
 
-import "./vendor/Package.internal.50.mjs";
+var lr = {};
 
-import "./vendor/Package.internal.51.mjs";
+Object.defineProperty(lr, "__esModule", {
+    value: true
+});
 
-import "./vendor/Package.internal.71.mjs";
+var yr = lr.EntitySchemaOptions = void 0;
 
-import "./vendor/Package.internal.114.mjs";
+class EntitySchemaOptions {}
 
-import "./vendor/Package.internal.115.mjs";
+yr = lr.EntitySchemaOptions = EntitySchemaOptions;
 
-const r = a.DataSource;
+const pr = h.DataSource;
 
-const n = e.MongoEntityManager;
+const vr = tr.MongoEntityManager;
 
-export { r as DataSource, n as MongoEntityManager };
+export { ie as And, de as Any, ve as ArrayContainedBy, _e as ArrayContains, je as ArrayOverlap, kt as BaseEntity, Ee as Between, pr as DataSource, ur as EntitySchema, dr as EntitySchemaEmbeddedColumnOptions, yr as EntitySchemaOptions, we as Equal, Fe as EqualOperator, He as ILike, Le as IsNull, gt as JsonContains, nr as LegacyOracleNamingStrategy, Ue as LessThan, ze as LessThanOrEqual, $e as Like, vr as MongoEntityManager, nt as MoreThan, st as MoreThanOrEqual, lt as Not, $t as NotBrackets, ft as Raw };