c2-desafiox 1.0.106

package/dist/models/ChallengeRound.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChallengeRoundSchema = exports.ChallengeMatchSchema = void 0;
+const mongoose_1 = require("mongoose");
+const ChallengeRoundStatus_1 = require("../types/ChallengeRoundStatus");
+exports.ChallengeMatchSchema = new mongoose_1.Schema({
+    match: { type: mongoose_1.Schema.Types.ObjectId, ref: "championship-match", required: true },
+    enabled: { type: Boolean, required: true, default: true },
+    teamWinner: { type: mongoose_1.Schema.Types.ObjectId, ref: "team", required: false },
+    isDraw: { type: Boolean, required: false, default: false }
+}, { _id: false });
+exports.ChallengeRoundSchema = new mongoose_1.Schema({
+    challenge: { type: mongoose_1.Schema.Types.ObjectId, ref: "challenge", required: true },
+    round: { type: mongoose_1.Schema.Types.ObjectId, ref: "championship-round", required: true },
+    matches: [{ type: exports.ChallengeMatchSchema }],
+    enabled: { type: Boolean, required: true, default: true },
+    status: { type: String, required: true, enum: ChallengeRoundStatus_1.ChallengeRoundStatus, default: ChallengeRoundStatus_1.ChallengeRoundStatus.SCHEDULED },
+    sequenceOrder: { type: Number, required: false }
+}, {
+    timestamps: {
+        createdAt: "createdAtDateTime",
+        updatedAt: "updatedAtDateTime"
+    }
+});

package/dist/models/Championship.d.ts

@@ -0,0 +1,23 @@
+import { Schema, Types } from "mongoose";
+import { Modality } from "../types/Modality";
+import { ITeam } from "./Team";
+export interface IChampionship {
+    _id: Types.ObjectId;
+    name: string;
+    slug?: string;
+    startDate?: Date;
+    endDate?: Date;
+    teams: Types.ObjectId[] | ITeam[];
+    modality: Modality;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChampionshipSchema = void 0;
+const mongoose_1 = require("mongoose");
+const Modality_1 = require("../types/Modality");
+exports.ChampionshipSchema = new mongoose_1.Schema({
+    name: { type: String, required: true },
+    slug: { type: String, required: false },
+    startDate: { type: Date, required: false },
+    endDate: { type: Date, required: false },
+    teams: [{ type: mongoose_1.Schema.Types.ObjectId, ref: "team", required: true }],
+    modality: { type: String, required: true, enum: Modality_1.Modality }
+}, {
+    timestamps: {
+        createdAt: "createdAtDateTime",
+        updatedAt: "updatedAtDateTime"
+    }
+});
+exports.ChampionshipSchema.index({ slug: 1 }, { unique: true, sparse: true });
+exports.ChampionshipSchema.index({ modality: 1 });

package/dist/models/ChampionshipClassification.d.ts

@@ -0,0 +1,31 @@
+import { Schema, Types } from "mongoose";
+import { IChampionship } from "./Championship";
+import { IChampionshipPhase, ISlots } from "./ChampionshipPhase";
+import { ITeam } from "./Team";
+export interface IChampionshipClassification {
+    _id: Types.ObjectId;
+    slot: Types.ObjectId | ISlots;
+    championship: Types.ObjectId | IChampionship;
+    phase: Types.ObjectId | IChampionshipPhase;
+    team: Types.ObjectId | ITeam;
+    group: string;
+    matchesPlayed: number;
+    points: number;
+    wins: number;
+    losses: number;
+    draws: number;
+    goalsFor: number;
+    goalsAgainst: number;
+    goalDifference: number;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+export declare const ChampionshipClassificationSchema: Schema<IChampionshipClassification, import("mongoose").Model<IChampionshipClassification, any, any, any, import("mongoose").Document<unknown, any, IChampionshipClassification, any> & IChampionshipClassification & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IChampionshipClassification, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IChampionshipClassification>, {}> & import("mongoose").FlatRecord<IChampionshipClassification> & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}>;

package/dist/models/ChampionshipClassification.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChampionshipClassificationSchema = void 0;
+const mongoose_1 = require("mongoose");
+exports.ChampionshipClassificationSchema = new mongoose_1.Schema({
+    championship: { type: mongoose_1.Schema.Types.ObjectId, ref: "championship", required: true },
+    phase: { type: mongoose_1.Schema.Types.ObjectId, ref: "championship-phase", required: true },
+    slot: { type: mongoose_1.Schema.Types.ObjectId, required: true },
+    team: { type: mongoose_1.Schema.Types.ObjectId, ref: "team", required: false },
+    group: { type: String, required: true },
+    matchesPlayed: { type: Number, required: true, default: 0 },
+    points: { type: Number, required: true, default: 0 },
+    wins: { type: Number, required: true, default: 0 },
+    losses: { type: Number, required: true, default: 0 },
+    draws: { type: Number, required: true, default: 0 },
+    goalsFor: { type: Number, required: true, default: 0 },
+    goalsAgainst: { type: Number, required: true, default: 0 },
+    goalDifference: { type: Number, required: true, default: 0 },
+}, {
+    timestamps: {
+        createdAt: "createdAtDateTime",
+        updatedAt: "updatedAtDateTime"
+    }
+});
+exports.ChampionshipClassificationSchema.index({ championship: 1 });
+exports.ChampionshipClassificationSchema.index({ phase: 1, slot: 1 }, { unique: true });

package/dist/models/ChampionshipMatch.d.ts

@@ -0,0 +1,33 @@
+import { Schema, Types } from "mongoose";
+import { MatchStatus } from "../types/MatchStatus";
+import { IChampionship } from "./Championship";
+import { IChampionshipPhase, ISlots } from "./ChampionshipPhase";
+import { IChampionshipRound } from "./ChampionshipRound";
+export interface IChampionshipMatch {
+    _id: Types.ObjectId;
+    number: number;
+    championship: Types.ObjectId | IChampionship;
+    phase: Types.ObjectId | IChampionshipPhase;
+    round: Types.ObjectId | IChampionshipRound;
+    group?: string;
+    slotHome: ISlots;
+    slotAway: ISlots;
+    scheduledAt?: Date;
+    homeScore?: number;
+    homeScoreTieBreak?: number;
+    awayScore?: number;
+    awayScoreTieBreak?: number;
+    status: MatchStatus;
+    matchDateTime: Date;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChampionshipMatchSchema = void 0;
+const mongoose_1 = require("mongoose");
+const MatchStatus_1 = require("../types/MatchStatus");
+const ChampionshipPhase_1 = require("./ChampionshipPhase");
+exports.ChampionshipMatchSchema = new mongoose_1.Schema({
+    number: { type: Number, required: true },
+    championship: { type: mongoose_1.Schema.Types.ObjectId, ref: "championship", 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 },
+    group: { type: String, required: false },
+    slotHome: { type: ChampionshipPhase_1.SlotsSchema, required: true },
+    slotAway: { type: ChampionshipPhase_1.SlotsSchema, required: true },
+    scheduledAt: { type: Date, required: false },
+    homeScore: { type: Number, required: false },
+    homeScoreTieBreak: { type: Number, required: false },
+    awayScore: { type: Number, required: false },
+    awayScoreTieBreak: { type: Number, required: false },
+    status: {
+        type: String,
+        required: true,
+        enum: MatchStatus_1.MatchStatus
+    },
+    matchDateTime: { type: Date, required: false },
+}, {
+    timestamps: {
+        createdAt: "createdAtDateTime",
+        updatedAt: "updatedAtDateTime"
+    }
+});
+exports.ChampionshipMatchSchema.index({ round: 1 });

package/dist/models/ChampionshipPhase.d.ts

@@ -0,0 +1,101 @@
+import { Schema, Types } from "mongoose";
+import { GroupMatchMode } from "../types/GroupMatchMode";
+import { QualificationMode } from "../types/QualificationMode";
+import { IChampionship } from "./Championship";
+import { ITeam } from "./Team";
+/** Time na fase, com identificador opcional de grupo (ex.: "A", "B" na fase de grupos). */
+export interface IPhaseParticipant {
+    team: Types.ObjectId | ITeam;
+}
+export interface IGroup {
+    name: string;
+    slots: ISlots[];
+}
+export interface ISlots {
+    _id: Types.ObjectId;
+    label?: string;
+    team?: Types.ObjectId | ITeam;
+}
+export interface IChampionshipPhase {
+    _id: Types.ObjectId;
+    description: string;
+    championship: Types.ObjectId | IChampionship;
+    order: number;
+    matchRules?: IMatchRules;
+    amountSlotsByGroup: number;
+    groups: IGroup[];
+    qualifiedRules: IQualifiedRule[];
+    qualifiedsSlots: IQualifiedsSlots[];
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+export interface IQualifiedsSlots extends ISlots {
+    priority: number;
+    position: number;
+    group?: string;
+}
+export interface IMatchRules {
+    mode: GroupMatchMode;
+    twoLegs: boolean;
+}
+export interface IQualifiedRule {
+    priority: number;
+    mode: QualificationMode;
+    position: number;
+    limit: number;
+    label: string;
+}
+export declare const SlotsSchema: Schema<ISlots, import("mongoose").Model<ISlots, any, any, any, import("mongoose").Document<unknown, any, ISlots, any> & ISlots & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, ISlots, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<ISlots>, {}> & import("mongoose").FlatRecord<ISlots> & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}>;
+export declare const QualifiedsSlotsSchema: Schema<IQualifiedsSlots, import("mongoose").Model<IQualifiedsSlots, any, any, any, import("mongoose").Document<unknown, any, IQualifiedsSlots, any> & IQualifiedsSlots & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IQualifiedsSlots, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IQualifiedsSlots>, {}> & import("mongoose").FlatRecord<IQualifiedsSlots> & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}>;
+export declare const GroupSchema: Schema<IGroup, import("mongoose").Model<IGroup, any, any, any, import("mongoose").Document<unknown, any, IGroup, any> & IGroup & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IGroup, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IGroup>, {}> & import("mongoose").FlatRecord<IGroup> & {
+    _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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChampionshipPhaseSchema = exports.MatchRulesSchema = exports.QualifiedRuleSchema = exports.GroupSchema = exports.QualifiedsSlotsSchema = exports.SlotsSchema = void 0;
+const mongoose_1 = require("mongoose");
+const GroupMatchMode_1 = require("../types/GroupMatchMode");
+const QualificationMode_1 = require("../types/QualificationMode");
+exports.SlotsSchema = new mongoose_1.Schema({
+    _id: { type: mongoose_1.Schema.Types.ObjectId, default: () => new mongoose_1.Types.ObjectId() },
+    label: { type: String, required: false },
+    team: { type: mongoose_1.Schema.Types.ObjectId, ref: "team", required: false },
+});
+exports.QualifiedsSlotsSchema = new mongoose_1.Schema({
+    _id: { type: mongoose_1.Schema.Types.ObjectId, default: () => new mongoose_1.Types.ObjectId() },
+    label: { type: String, required: true },
+    team: { type: mongoose_1.Schema.Types.ObjectId, ref: "team" },
+    priority: { type: Number, required: true },
+    position: { type: Number, required: true },
+    group: { type: String, required: false, default: "" }
+});
+exports.GroupSchema = new mongoose_1.Schema({
+    name: { type: String, required: true },
+    slots: { type: [exports.SlotsSchema], required: true, default: [] },
+}, { _id: false });
+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 },
+    label: { type: String, default: "" },
+});
+exports.MatchRulesSchema = new mongoose_1.Schema({
+    mode: { type: String, required: true, enum: GroupMatchMode_1.GroupMatchMode },
+    twoLegs: { type: Boolean, required: true, default: false },
+});
+exports.ChampionshipPhaseSchema = new mongoose_1.Schema({
+    description: { type: String, required: true },
+    championship: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "championship",
+        required: true
+    },
+    order: { type: Number, required: true },
+    amountSlotsByGroup: { type: Number, required: true, default: 2 },
+    groups: { type: [exports.GroupSchema], required: true, default: [] },
+    matchRules: { type: exports.MatchRulesSchema, required: true },
+    qualifiedRules: { type: [exports.QualifiedRuleSchema], required: true },
+    qualifiedsSlots: { type: [exports.QualifiedsSlotsSchema], required: true, default: [] }
+}, {
+    timestamps: {
+        createdAt: "createdAtDateTime",
+        updatedAt: "updatedAtDateTime"
+    }
+});
+exports.ChampionshipPhaseSchema.index({ championship: 1 });
+exports.ChampionshipPhaseSchema.index({ championship: 1, order: 1 }, { unique: true });

package/dist/models/ChampionshipRound.d.ts

@@ -0,0 +1,26 @@
+import { Schema, Types } from "mongoose";
+import { RoundStatus } from "../types/RoundStatus";
+import { IChampionshipPhase } from "./ChampionshipPhase";
+import { IChampionship } from "./Championship";
+export interface IChampionshipRound {
+    _id: Types.ObjectId;
+    phase: Types.ObjectId | IChampionshipPhase;
+    championship: Types.ObjectId | IChampionship;
+    roundIndexInPhase: number;
+    globalRoundIndex: number;
+    label?: string;
+    startDate?: Date;
+    endDate?: Date;
+    status: RoundStatus;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChampionshipRoundSchema = void 0;
+const mongoose_1 = require("mongoose");
+const RoundStatus_1 = require("../types/RoundStatus");
+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,
+        ref: "championship",
+        required: true
+    },
+    roundIndexInPhase: { type: Number, required: true },
+    globalRoundIndex: { type: Number, required: true },
+    label: { type: String, required: false },
+    startDate: { type: Date, required: false },
+    endDate: { type: Date, required: false },
+    status: {
+        type: String,
+        required: true,
+        enum: RoundStatus_1.RoundStatus
+    }
+}, {
+    timestamps: {
+        createdAt: "createdAtDateTime",
+        updatedAt: "updatedAtDateTime"
+    }
+});
+exports.ChampionshipRoundSchema.index({ phase: 1 });
+exports.ChampionshipRoundSchema.index({ championship: 1 });
+exports.ChampionshipRoundSchema.index({ championship: 1, globalRoundIndex: 1 }, { unique: true });

package/dist/models/File.d.ts

@@ -0,0 +1,33 @@
+import { Schema } from "mongoose";
+export interface IFile {
+    contentType: string;
+    format: string;
+    description: string;
+    url: string;
+    fileBase64: string;
+}
+export declare const FileSchema: Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: {
+        createdAt: string;
+        updatedAt: string;
+    };
+}, {} & {
+    contentType: string;
+    description: string;
+    format?: string | null | undefined;
+    url?: string | null | undefined;
+}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{} & {
+    contentType: string;
+    description: string;
+    format?: string | null | undefined;
+    url?: string | null | undefined;
+}>, {}> & import("mongoose").FlatRecord<{} & {
+    contentType: string;
+    description: string;
+    format?: string | null | undefined;
+    url?: string | null | undefined;
+}> & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}>;

package/dist/models/File.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSchema = void 0;
+const mongoose_1 = require("mongoose");
+exports.FileSchema = new mongoose_1.Schema({
+    contentType: { type: String, required: true },
+    format: { type: String },
+    description: { type: String, required: true },
+    url: { type: String }
+}, {
+    timestamps: { createdAt: "createdAtDateTime", updatedAt: "updatedAtDateTime" }
+});

package/dist/models/Team.d.ts

@@ -0,0 +1,23 @@
+import { Schema, Types } from "mongoose";
+import { Modality } from "../types/Modality";
+import { IFile } from "./File";
+export interface ITeam {
+    _id: Types.ObjectId;
+    name: string;
+    shortName?: string;
+    logoUrl?: string;
+    image?: IFile;
+    externalId?: string;
+    modality: Modality;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TeamSchema = void 0;
+const mongoose_1 = require("mongoose");
+const Modality_1 = require("../types/Modality");
+const File_1 = require("./File");
+exports.TeamSchema = new mongoose_1.Schema({
+    name: { type: String, required: true },
+    shortName: { type: String, required: false },
+    logoUrl: { type: String, required: false },
+    image: { type: File_1.FileSchema, required: false },
+    externalId: { type: String, required: false },
+    modality: { type: String, required: true, enum: Modality_1.Modality }
+}, {
+    timestamps: {
+        createdAt: "createdAtDateTime",
+        updatedAt: "updatedAtDateTime"
+    }
+});
+exports.TeamSchema.index({ name: 1, modality: 1 }, { unique: true });
+exports.TeamSchema.index({ externalId: 1 }, { unique: true, sparse: true });

package/dist/models/Ticket.d.ts

@@ -0,0 +1,34 @@
+import { Schema, Types } from "mongoose";
+import { IAccount } from "./Account";
+import { IChallenge } from "./Challenge";
+import { ITicketOrder } from "./TicketOrder";
+export declare enum TicketStatusInGamming {
+    READY = "READY",
+    SCALLING = "SCALLING",
+    DROPPED = "DROPPED"
+}
+export declare enum TicketStatusFinancial {
+    NOT_PAID = "NOT_PAID",
+    PAID = "PAID",
+    CANCELLED = "CANCELLED"
+}
+export interface ITicket {
+    _id: Types.ObjectId;
+    code: string;
+    account: Types.ObjectId | IAccount;
+    challenge: Types.ObjectId | IChallenge;
+    statusInGamming: TicketStatusInGamming;
+    statusFinancial: TicketStatusFinancial;
+    ticketOrder: Types.ObjectId | ITicketOrder;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+export declare const TicketSchema: Schema<ITicket, import("mongoose").Model<ITicket, any, any, any, import("mongoose").Document<unknown, any, ITicket, any> & ITicket & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, ITicket, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<ITicket>, {}> & import("mongoose").FlatRecord<ITicket> & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}>;

package/dist/models/Ticket.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TicketSchema = exports.TicketStatusFinancial = exports.TicketStatusInGamming = void 0;
+const mongoose_1 = require("mongoose");
+var TicketStatusInGamming;
+(function (TicketStatusInGamming) {
+    TicketStatusInGamming["READY"] = "READY";
+    TicketStatusInGamming["SCALLING"] = "SCALLING";
+    TicketStatusInGamming["DROPPED"] = "DROPPED";
+})(TicketStatusInGamming || (exports.TicketStatusInGamming = TicketStatusInGamming = {}));
+var TicketStatusFinancial;
+(function (TicketStatusFinancial) {
+    TicketStatusFinancial["NOT_PAID"] = "NOT_PAID";
+    TicketStatusFinancial["PAID"] = "PAID";
+    TicketStatusFinancial["CANCELLED"] = "CANCELLED";
+})(TicketStatusFinancial || (exports.TicketStatusFinancial = TicketStatusFinancial = {}));
+exports.TicketSchema = new mongoose_1.Schema({
+    code: { type: String, required: true },
+    account: { type: mongoose_1.Schema.Types.ObjectId, ref: "account", required: true },
+    challenge: { type: mongoose_1.Schema.Types.ObjectId, ref: "challenge", required: true },
+    statusInGamming: { type: String, required: true, enum: TicketStatusInGamming },
+    statusFinancial: { type: String, required: true, enum: TicketStatusFinancial },
+    ticketOrder: { type: mongoose_1.Schema.Types.ObjectId, ref: "ticket-order", required: true },
+}, {
+    timestamps: {
+        createdAt: "createdAtDateTime",
+        updatedAt: "updatedAtDateTime"
+    }
+});
+exports.TicketSchema.index({ account: 1 });
+exports.TicketSchema.index({ challenge: 1 });
+exports.TicketSchema.index({ statusInGamming: 1 });
+exports.TicketSchema.index({ statusFinancial: 1 });

package/dist/models/TicketGuess.d.ts

@@ -0,0 +1,33 @@
+import { Schema, Types } from "mongoose";
+import { IAccount } from "./Account";
+import { IChallenge } from "./Challenge";
+import { ITeam } from "./Team";
+import { IChallengeRound } from "./ChallengeRound";
+import { ITicket } from "./Ticket";
+export declare enum TicketGuessStatus {
+    PENDING = "PENDING",
+    RIGHT = "RIGHT",
+    WRONG = "WRONG"
+}
+export interface ITicketGuess {
+    _id: Types.ObjectId;
+    account: Types.ObjectId | IAccount;
+    challenge: Types.ObjectId | IChallenge;
+    challengeRound: Types.ObjectId | IChallengeRound;
+    ticket: Types.ObjectId | ITicket;
+    guess: Types.ObjectId | ITeam;
+    guessStatus: TicketGuessStatus;
+    isAutomatic: boolean;
+    notes: string;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+export declare const TicketGuessSchema: Schema<ITicketGuess, import("mongoose").Model<ITicketGuess, any, any, any, import("mongoose").Document<unknown, any, ITicketGuess, any> & ITicketGuess & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, ITicketGuess, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<ITicketGuess>, {}> & import("mongoose").FlatRecord<ITicketGuess> & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}>;

package/dist/models/TicketGuess.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TicketGuessSchema = exports.TicketGuessStatus = void 0;
+const mongoose_1 = require("mongoose");
+var TicketGuessStatus;
+(function (TicketGuessStatus) {
+    TicketGuessStatus["PENDING"] = "PENDING";
+    TicketGuessStatus["RIGHT"] = "RIGHT";
+    TicketGuessStatus["WRONG"] = "WRONG";
+})(TicketGuessStatus || (exports.TicketGuessStatus = TicketGuessStatus = {}));
+exports.TicketGuessSchema = new mongoose_1.Schema({
+    account: { type: mongoose_1.Schema.Types.ObjectId, ref: "account", required: true },
+    challenge: { type: mongoose_1.Schema.Types.ObjectId, ref: "challenge", required: true },
+    challengeRound: { type: mongoose_1.Schema.Types.ObjectId, ref: "challenge-round", required: true },
+    ticket: { type: mongoose_1.Schema.Types.ObjectId, ref: "ticket", required: true },
+    guess: { type: mongoose_1.Schema.Types.ObjectId, ref: "team" },
+    guessStatus: { type: String, enum: TicketGuessStatus, default: TicketGuessStatus.PENDING },
+    isAutomatic: { type: Boolean, default: false },
+    notes: { type: String, default: "" },
+}, {
+    timestamps: {
+        createdAt: "createdAtDateTime",
+        updatedAt: "updatedAtDateTime"
+    }
+});
+exports.TicketGuessSchema.index({ account: 1, ticket: 1, challengeRound: 1 }, { unique: true });
+exports.TicketGuessSchema.index({ account: 1 });
+exports.TicketGuessSchema.index({ challenge: 1 });
+exports.TicketGuessSchema.index({ challengeRound: 1 });
+exports.TicketGuessSchema.index({ ticket: 1 });
+exports.TicketGuessSchema.index({ team: 1 });