c2-climbing-x 1.0.1 → 1.0.4

package/dist/models/Challenge.d.ts

@@ -1,4 +1,4 @@
-import { Model, Types } from "mongoose";
+import { Schema, Types } from "mongoose";
 import { IChampionship } from "./Championship";
 export interface IChallenge {
     _id: Types.ObjectId;
@@ -8,4 +8,12 @@ export interface IChallenge {
     createdAtDateTime: Date;
     updatedAtDateTime: Date;
 }
-export declare const ChallengeModel: Model<IChallenge>;
+export declare const ChallengeSchema: Schema<IChallenge, import("mongoose").Model<IChallenge, any, any, any, import("mongoose").Document<unknown, any, IChallenge, any> & IChallenge & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IChallenge, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IChallenge>, {}> & import("mongoose").FlatRecord<IChallenge> & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}>;

package/dist/models/Challenge.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChallengeModel = void 0;
+exports.ChallengeSchema = void 0;
 const mongoose_1 = require("mongoose");
-const ChallengeSchema = new mongoose_1.Schema({
+exports.ChallengeSchema = new mongoose_1.Schema({
     championship: {
         type: mongoose_1.Schema.Types.ObjectId,
         ref: "championship",
@@ -16,6 +16,5 @@ const ChallengeSchema = new mongoose_1.Schema({
         updatedAt: "updatedAtDateTime"
     }
 });
-ChallengeSchema.index({ championship: 1 });
-ChallengeSchema.index({ championship: 1, roundStart: 1, roundEnd: 1 });
-exports.ChallengeModel = (0, mongoose_1.model)("challenge", ChallengeSchema);
+exports.ChallengeSchema.index({ championship: 1 });
+exports.ChallengeSchema.index({ championship: 1, roundStart: 1, roundEnd: 1 });

package/dist/models/ChallengeRound.d.ts

@@ -1,7 +1,7 @@
-import { Model, Types } from "mongoose";
+import { Schema, Types } from "mongoose";
 import { IChallenge } from "./Challenge";
-import { IChampionshipRound } from "./ChampionshipRound";
 import { IChampionshipMatch } from "./ChampionshipMatch";
+import { IChampionshipRound } from "./ChampionshipRound";
 export interface IChallengeRound {
     _id: Types.ObjectId;
     challenge: Types.ObjectId | IChallenge;
@@ -12,4 +12,12 @@ export interface IChallengeRound {
     createdAtDateTime: Date;
     updatedAtDateTime: Date;
 }
-export declare const ChallengeRoundModel: Model<IChallengeRound>;
+export declare const ChallengeRoundSchema: Schema<IChallengeRound, import("mongoose").Model<IChallengeRound, any, any, any, import("mongoose").Document<unknown, any, IChallengeRound, any> & IChallengeRound & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IChallengeRound, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IChallengeRound>, {}> & import("mongoose").FlatRecord<IChallengeRound> & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}>;

package/dist/models/ChallengeRound.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChallengeRoundModel = void 0;
+exports.ChallengeRoundSchema = void 0;
 const mongoose_1 = require("mongoose");
-const ChallengeRoundSchema = new mongoose_1.Schema({
+exports.ChallengeRoundSchema = new mongoose_1.Schema({
     challenge: {
         type: mongoose_1.Schema.Types.ObjectId,
         ref: "challenge",
@@ -18,6 +18,5 @@ const ChallengeRoundSchema = new mongoose_1.Schema({
         updatedAt: "updatedAtDateTime"
     }
 });
-ChallengeRoundSchema.index({ challenge: 1 });
-ChallengeRoundSchema.index({ challenge: 1, round: 1 }, { unique: true });
-exports.ChallengeRoundModel = (0, mongoose_1.model)("challenge-round", ChallengeRoundSchema);
+exports.ChallengeRoundSchema.index({ challenge: 1 });
+exports.ChallengeRoundSchema.index({ challenge: 1, round: 1 }, { unique: true });

package/dist/models/Championship.d.ts

@@ -1,6 +1,6 @@
-import { Model, Types } from "mongoose";
-import { ITeam } from "./Team";
+import { Schema, Types } from "mongoose";
 import { Modality } from "../types/Modality";
+import { ITeam } from "./Team";
 export interface IChampionship {
     _id: Types.ObjectId;
     name: string;
@@ -12,4 +12,12 @@ export interface IChampionship {
     createdAtDateTime: Date;
     updatedAtDateTime: Date;
 }
-export declare const ChampionshipModel: Model<IChampionship>;
+export declare const ChampionshipSchema: Schema<IChampionship, import("mongoose").Model<IChampionship, any, any, any, import("mongoose").Document<unknown, any, IChampionship, any> & IChampionship & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IChampionship, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IChampionship>, {}> & import("mongoose").FlatRecord<IChampionship> & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}>;

package/dist/models/Championship.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChampionshipModel = void 0;
+exports.ChampionshipSchema = void 0;
 const mongoose_1 = require("mongoose");
 const Modality_1 = require("../types/Modality");
-const ChampionshipSchema = new mongoose_1.Schema({
+exports.ChampionshipSchema = new mongoose_1.Schema({
     name: { type: String, required: true },
     slug: { type: String, required: false },
     startDate: { type: Date, required: false },
@@ -16,6 +16,5 @@ const ChampionshipSchema = new mongoose_1.Schema({
         updatedAt: "updatedAtDateTime"
     }
 });
-ChampionshipSchema.index({ slug: 1 }, { unique: true, sparse: true });
-ChampionshipSchema.index({ modality: 1 });
-exports.ChampionshipModel = (0, mongoose_1.model)("championship", ChampionshipSchema);
+exports.ChampionshipSchema.index({ slug: 1 }, { unique: true, sparse: true });
+exports.ChampionshipSchema.index({ modality: 1 });

package/dist/models/ChampionshipMatch.d.ts

@@ -1,8 +1,8 @@
-import { Model, Types } from "mongoose";
+import { Schema, Types } from "mongoose";
 import { MatchStatus } from "../types/MatchStatus";
+import { IChampionshipPhase } from "./ChampionshipPhase";
 import { IChampionshipRound } from "./ChampionshipRound";
 import { ITeam } from "./Team";
-import { IChampionshipPhase } from "./ChampionshipPhase";
 export interface IChampionshipMatch {
     _id: Types.ObjectId;
     number: number;
@@ -18,4 +18,12 @@ export interface IChampionshipMatch {
     createdAtDateTime: Date;
     updatedAtDateTime: Date;
 }
-export declare const MatchModel: Model<IChampionshipMatch>;
+export declare const ChampionshipMatchSchema: Schema<IChampionshipMatch, import("mongoose").Model<IChampionshipMatch, any, any, any, import("mongoose").Document<unknown, any, IChampionshipMatch, any> & IChampionshipMatch & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IChampionshipMatch, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IChampionshipMatch>, {}> & import("mongoose").FlatRecord<IChampionshipMatch> & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}>;

package/dist/models/ChampionshipMatch.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MatchModel = void 0;
+exports.ChampionshipMatchSchema = void 0;
 const mongoose_1 = require("mongoose");
 const MatchStatus_1 = require("../types/MatchStatus");
-const ChampionshipMatchSchema = new mongoose_1.Schema({
+exports.ChampionshipMatchSchema = new mongoose_1.Schema({
     number: { type: Number, required: true },
     phase: { type: mongoose_1.Schema.Types.ObjectId, ref: "championship-phase", required: true },
     round: { type: mongoose_1.Schema.Types.ObjectId, ref: "championship-round", required: true },
@@ -24,6 +24,5 @@ const ChampionshipMatchSchema = new mongoose_1.Schema({
         updatedAt: "updatedAtDateTime"
     }
 });
-ChampionshipMatchSchema.index({ round: 1 });
-ChampionshipMatchSchema.index({ round: 1, homeTeam: 1, awayTeam: 1 }, { unique: true });
-exports.MatchModel = (0, mongoose_1.model)("championship-match", ChampionshipMatchSchema);
+exports.ChampionshipMatchSchema.index({ round: 1 });
+exports.ChampionshipMatchSchema.index({ round: 1, homeTeam: 1, awayTeam: 1 }, { unique: true });

package/dist/models/ChampionshipPhase.d.ts

@@ -1,4 +1,4 @@
-import { Model, Types } from "mongoose";
+import { Schema, Types } from "mongoose";
 import { GroupMatchMode } from "../types/GroupMatchMode";
 import { QualificationMode } from "../types/QualificationMode";
 import { IChampionship } from "./Championship";
@@ -32,4 +32,39 @@ export interface IQualifiedRule {
     position: number;
     limit: number;
 }
-export declare const ChampionshipPhaseModel: Model<IChampionshipPhase>;
+export declare const PhaseParticipantSchema: Schema<IPhaseParticipant, import("mongoose").Model<IPhaseParticipant, any, any, any, import("mongoose").Document<unknown, any, IPhaseParticipant, any> & IPhaseParticipant & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IPhaseParticipant, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IPhaseParticipant>, {}> & import("mongoose").FlatRecord<IPhaseParticipant> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export declare const QualifiedRuleSchema: Schema<IQualifiedRule, import("mongoose").Model<IQualifiedRule, any, any, any, import("mongoose").Document<unknown, any, IQualifiedRule, any> & IQualifiedRule & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IQualifiedRule, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IQualifiedRule>, {}> & import("mongoose").FlatRecord<IQualifiedRule> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export declare const MatchRulesSchema: Schema<IMatchRules, import("mongoose").Model<IMatchRules, any, any, any, import("mongoose").Document<unknown, any, IMatchRules, any> & IMatchRules & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IMatchRules, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IMatchRules>, {}> & import("mongoose").FlatRecord<IMatchRules> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export declare const ChampionshipPhaseSchema: Schema<IChampionshipPhase, import("mongoose").Model<IChampionshipPhase, any, any, any, import("mongoose").Document<unknown, any, IChampionshipPhase, any> & IChampionshipPhase & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IChampionshipPhase, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IChampionshipPhase>, {}> & import("mongoose").FlatRecord<IChampionshipPhase> & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}>;

package/dist/models/ChampionshipPhase.js

@@ -1,24 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChampionshipPhaseModel = void 0;
+exports.ChampionshipPhaseSchema = exports.MatchRulesSchema = exports.QualifiedRuleSchema = exports.PhaseParticipantSchema = void 0;
 const mongoose_1 = require("mongoose");
 const GroupMatchMode_1 = require("../types/GroupMatchMode");
 const QualificationMode_1 = require("../types/QualificationMode");
-const PhaseParticipantSchema = new mongoose_1.Schema({
+exports.PhaseParticipantSchema = new mongoose_1.Schema({
     team: { type: mongoose_1.Schema.Types.ObjectId, ref: "team", required: true },
     group: { type: String, required: false }
 }, { _id: false });
-const QualifiedRuleSchema = new mongoose_1.Schema({
+exports.QualifiedRuleSchema = new mongoose_1.Schema({
     priority: { type: Number, required: true },
     mode: { type: String, required: true, enum: QualificationMode_1.QualificationMode },
     position: { type: Number, required: true },
     limit: { type: Number, required: true },
 });
-const MatchRulesSchema = new mongoose_1.Schema({
+exports.MatchRulesSchema = new mongoose_1.Schema({
     mode: { type: String, required: true, enum: GroupMatchMode_1.GroupMatchMode },
     twoLegs: { type: Boolean, required: true, default: false },
 });
-const ChampionshipPhaseSchema = new mongoose_1.Schema({
+exports.ChampionshipPhaseSchema = new mongoose_1.Schema({
     description: { type: String, required: true },
     championship: {
         type: mongoose_1.Schema.Types.ObjectId,
@@ -26,15 +26,14 @@ const ChampionshipPhaseSchema = new mongoose_1.Schema({
         required: true
     },
     order: { type: Number, required: true },
-    participants: { type: [PhaseParticipantSchema], required: true, default: [] },
-    matchRules: { type: MatchRulesSchema, required: true },
-    qualifiedRules: { type: [QualifiedRuleSchema], required: true }
+    participants: { type: [exports.PhaseParticipantSchema], required: true, default: [] },
+    matchRules: { type: exports.MatchRulesSchema, required: true },
+    qualifiedRules: { type: [exports.QualifiedRuleSchema], required: true }
 }, {
     timestamps: {
         createdAt: "createdAtDateTime",
         updatedAt: "updatedAtDateTime"
     }
 });
-ChampionshipPhaseSchema.index({ championship: 1 });
-ChampionshipPhaseSchema.index({ championship: 1, order: 1 }, { unique: true });
-exports.ChampionshipPhaseModel = (0, mongoose_1.model)("championship-phase", ChampionshipPhaseSchema);
+exports.ChampionshipPhaseSchema.index({ championship: 1 });
+exports.ChampionshipPhaseSchema.index({ championship: 1, order: 1 }, { unique: true });

package/dist/models/ChampionshipRound.d.ts

@@ -1,4 +1,4 @@
-import { Model, Types } from "mongoose";
+import { Schema, Types } from "mongoose";
 import { RoundStatus } from "../types/RoundStatus";
 import { IChampionshipPhase } from "./ChampionshipPhase";
 import { IChampionship } from "./Championship";
@@ -15,4 +15,12 @@ export interface IChampionshipRound {
     createdAtDateTime: Date;
     updatedAtDateTime: Date;
 }
-export declare const ChampionshipRoundModel: Model<IChampionshipRound>;
+export declare const ChampionshipRoundSchema: Schema<IChampionshipRound, import("mongoose").Model<IChampionshipRound, any, any, any, import("mongoose").Document<unknown, any, IChampionshipRound, any> & IChampionshipRound & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IChampionshipRound, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IChampionshipRound>, {}> & import("mongoose").FlatRecord<IChampionshipRound> & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}>;

package/dist/models/ChampionshipRound.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChampionshipRoundModel = void 0;
+exports.ChampionshipRoundSchema = void 0;
 const mongoose_1 = require("mongoose");
 const RoundStatus_1 = require("../types/RoundStatus");
-const ChampionshipRoundSchema = new mongoose_1.Schema({
+exports.ChampionshipRoundSchema = new mongoose_1.Schema({
     phase: { type: mongoose_1.Schema.Types.ObjectId, ref: "championship-phase", required: true },
     championship: {
         type: mongoose_1.Schema.Types.ObjectId,
@@ -26,7 +26,6 @@ const ChampionshipRoundSchema = new mongoose_1.Schema({
         updatedAt: "updatedAtDateTime"
     }
 });
-ChampionshipRoundSchema.index({ phase: 1 });
-ChampionshipRoundSchema.index({ championship: 1 });
-ChampionshipRoundSchema.index({ championship: 1, globalRoundIndex: 1 }, { unique: true });
-exports.ChampionshipRoundModel = (0, mongoose_1.model)("championship-round", ChampionshipRoundSchema);
+exports.ChampionshipRoundSchema.index({ phase: 1 });
+exports.ChampionshipRoundSchema.index({ championship: 1 });
+exports.ChampionshipRoundSchema.index({ championship: 1, globalRoundIndex: 1 }, { unique: true });

package/dist/models/Team.d.ts

@@ -1,4 +1,4 @@
-import { Model, Types } from "mongoose";
+import { Schema, Types } from "mongoose";
 import { Modality } from "../types/Modality";
 export interface ITeam {
     _id: Types.ObjectId;
@@ -10,4 +10,12 @@ export interface ITeam {
     createdAtDateTime: Date;
     updatedAtDateTime: Date;
 }
-export declare const TeamModel: Model<ITeam>;
+export declare const TeamSchema: Schema<ITeam, import("mongoose").Model<ITeam, any, any, any, import("mongoose").Document<unknown, any, ITeam, any> & ITeam & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, ITeam, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<ITeam>, {}> & import("mongoose").FlatRecord<ITeam> & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}>;

package/dist/models/Team.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TeamModel = void 0;
+exports.TeamSchema = void 0;
 const mongoose_1 = require("mongoose");
 const Modality_1 = require("../types/Modality");
-const TeamSchema = new mongoose_1.Schema({
+exports.TeamSchema = new mongoose_1.Schema({
     name: { type: String, required: true },
     shortName: { type: String, required: false },
     logoUrl: { type: String, required: false },
@@ -15,6 +15,5 @@ const TeamSchema = new mongoose_1.Schema({
         updatedAt: "updatedAtDateTime"
     }
 });
-TeamSchema.index({ name: 1, modality: 1 }, { unique: true });
-TeamSchema.index({ externalId: 1 }, { unique: true, sparse: true });
-exports.TeamModel = (0, mongoose_1.model)("team", TeamSchema);
+exports.TeamSchema.index({ name: 1, modality: 1 }, { unique: true });
+exports.TeamSchema.index({ externalId: 1 }, { unique: true, sparse: true });

package/dist/models/index.d.ts

@@ -1,7 +1,7 @@
-export { ChallengeModel, type IChallenge } from "./Challenge";
-export { ChallengeRoundModel } from "./ChallengeRound";
-export { ChampionshipModel, type IChampionship } from "./Championship";
-export { ChampionshipPhaseModel, type IChampionshipPhase, type IPhaseParticipant } from "./ChampionshipPhase";
-export { ChampionshipRoundModel } from "./ChampionshipRound";
-export { MatchModel, type IChampionshipMatch as IMatch } from "./ChampionshipMatch";
-export { TeamModel, type ITeam } from "./Team";
+export * from "./Challenge";
+export * from "./ChallengeRound";
+export * from "./Championship";
+export * from "./ChampionshipMatch";
+export * from "./ChampionshipPhase";
+export * from "./ChampionshipRound";
+export * from "./Team";

package/dist/models/index.js

@@ -1,17 +1,23 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TeamModel = exports.MatchModel = exports.ChampionshipRoundModel = exports.ChampionshipPhaseModel = exports.ChampionshipModel = exports.ChallengeRoundModel = exports.ChallengeModel = void 0;
-var Challenge_1 = require("./Challenge");
-Object.defineProperty(exports, "ChallengeModel", { enumerable: true, get: function () { return Challenge_1.ChallengeModel; } });
-var ChallengeRound_1 = require("./ChallengeRound");
-Object.defineProperty(exports, "ChallengeRoundModel", { enumerable: true, get: function () { return ChallengeRound_1.ChallengeRoundModel; } });
-var Championship_1 = require("./Championship");
-Object.defineProperty(exports, "ChampionshipModel", { enumerable: true, get: function () { return Championship_1.ChampionshipModel; } });
-var ChampionshipPhase_1 = require("./ChampionshipPhase");
-Object.defineProperty(exports, "ChampionshipPhaseModel", { enumerable: true, get: function () { return ChampionshipPhase_1.ChampionshipPhaseModel; } });
-var ChampionshipRound_1 = require("./ChampionshipRound");
-Object.defineProperty(exports, "ChampionshipRoundModel", { enumerable: true, get: function () { return ChampionshipRound_1.ChampionshipRoundModel; } });
-var ChampionshipMatch_1 = require("./ChampionshipMatch");
-Object.defineProperty(exports, "MatchModel", { enumerable: true, get: function () { return ChampionshipMatch_1.MatchModel; } });
-var Team_1 = require("./Team");
-Object.defineProperty(exports, "TeamModel", { enumerable: true, get: function () { return Team_1.TeamModel; } });
+__exportStar(require("./Challenge"), exports);
+__exportStar(require("./ChallengeRound"), exports);
+__exportStar(require("./Championship"), exports);
+__exportStar(require("./ChampionshipMatch"), exports);
+__exportStar(require("./ChampionshipPhase"), exports);
+__exportStar(require("./ChampionshipRound"), exports);
+__exportStar(require("./Team"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c2-climbing-x",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "description": "Modelagem TypeScript/Mongoose para o jogo Escalada X (times, campeonatos, fases, rodadas, confrontos, desafios)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,7 +17,7 @@
   },
   "devDependencies": {
     "@types/node": "^20.12.11",
-    "mongoose": "^9.0.0",
+    "mongoose": "8.16.1",
     "typescript": "^5.4.5"
   },
   "files": [