c2-desafiox 1.0.106

package/dist/models/AdminEventComunication.d.ts

@@ -0,0 +1,236 @@
+import { Schema, Types } from "mongoose";
+import { IAccount } from "./Account";
+import { IAdminComunication } from "./AdminComunication";
+import { IFile } from "./File";
+import { IAdminTemplatePush } from "./AdminTemplatePush";
+import { IAdminTemplateEmail } from "./AdminTemplateEmail";
+export declare enum AdminEventComunicationStatus {
+    CREATED = "CREATED",
+    RUNNING = "RUNNING",
+    ERROR = "ERROR",
+    DONE = "DONE"
+}
+export declare enum AdminEventComunicationMessageStatus {
+    CREATED = "CREATED",
+    SENT = "SENT",
+    DELIVERED = "DELIVERED",
+    READ = "READ",
+    ERROR = "ERROR"
+}
+export interface IAdminEventComunication {
+    _id: Types.ObjectId;
+    account: Types.ObjectId | IAccount;
+    comunication: Types.ObjectId | IAdminComunication;
+    pushContent?: {
+        template: Types.ObjectId | IAdminTemplatePush;
+        status: AdminEventComunicationMessageStatus;
+        title: string;
+        body: string;
+        image?: IFile;
+        redirect?: string;
+        metadata?: Map<string, string>;
+        message?: string;
+    };
+    emailContent?: {
+        template: Types.ObjectId | IAdminTemplateEmail;
+        status: AdminEventComunicationMessageStatus;
+        subject: string;
+        bodyHtml: string;
+        addresses: string[];
+        message?: string;
+    };
+    status: AdminEventComunicationStatus;
+    message?: string;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+export declare const AdminEventComunicationSchema: Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: {
+        createdAt: string;
+        updatedAt: string;
+    };
+}, {} & {
+    account: {
+        prototype?: Types.ObjectId | null | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | null | undefined;
+        createFromTime?: {} | null | undefined;
+        createFromHexString?: {} | null | undefined;
+        createFromBase64?: {} | null | undefined;
+        isValid?: {} | null | undefined;
+    };
+    status: string;
+    comunication: {
+        prototype?: Types.ObjectId | null | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | null | undefined;
+        createFromTime?: {} | null | undefined;
+        createFromHexString?: {} | null | undefined;
+        createFromBase64?: {} | null | undefined;
+        isValid?: {} | null | undefined;
+    };
+    message?: string | null | undefined;
+    pushContent?: {
+        status: string;
+        title: string;
+        body: string;
+        template: {
+            prototype?: Types.ObjectId | null | undefined;
+            cacheHexString?: unknown;
+            generate?: {} | null | undefined;
+            createFromTime?: {} | null | undefined;
+            createFromHexString?: {} | null | undefined;
+            createFromBase64?: {} | null | undefined;
+            isValid?: {} | null | undefined;
+        };
+        image?: ({} & {
+            contentType: string;
+            description: string;
+            format?: string | null | undefined;
+            url?: string | null | undefined;
+        }) | null | undefined;
+        message?: string | null | undefined;
+        redirect?: string | null | undefined;
+        metadata?: Map<string, string> | null | undefined;
+    } | null | undefined;
+    emailContent?: {
+        status: string;
+        subject: string;
+        bodyHtml: string;
+        template: {
+            prototype?: Types.ObjectId | null | undefined;
+            cacheHexString?: unknown;
+            generate?: {} | null | undefined;
+            createFromTime?: {} | null | undefined;
+            createFromHexString?: {} | null | undefined;
+            createFromBase64?: {} | null | undefined;
+            isValid?: {} | null | undefined;
+        };
+        addresses: string[];
+        message?: string | null | undefined;
+    } | null | undefined;
+}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{} & {
+    account: {
+        prototype?: Types.ObjectId | null | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | null | undefined;
+        createFromTime?: {} | null | undefined;
+        createFromHexString?: {} | null | undefined;
+        createFromBase64?: {} | null | undefined;
+        isValid?: {} | null | undefined;
+    };
+    status: string;
+    comunication: {
+        prototype?: Types.ObjectId | null | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | null | undefined;
+        createFromTime?: {} | null | undefined;
+        createFromHexString?: {} | null | undefined;
+        createFromBase64?: {} | null | undefined;
+        isValid?: {} | null | undefined;
+    };
+    message?: string | null | undefined;
+    pushContent?: {
+        status: string;
+        title: string;
+        body: string;
+        template: {
+            prototype?: Types.ObjectId | null | undefined;
+            cacheHexString?: unknown;
+            generate?: {} | null | undefined;
+            createFromTime?: {} | null | undefined;
+            createFromHexString?: {} | null | undefined;
+            createFromBase64?: {} | null | undefined;
+            isValid?: {} | null | undefined;
+        };
+        image?: ({} & {
+            contentType: string;
+            description: string;
+            format?: string | null | undefined;
+            url?: string | null | undefined;
+        }) | null | undefined;
+        message?: string | null | undefined;
+        redirect?: string | null | undefined;
+        metadata?: Map<string, string> | null | undefined;
+    } | null | undefined;
+    emailContent?: {
+        status: string;
+        subject: string;
+        bodyHtml: string;
+        template: {
+            prototype?: Types.ObjectId | null | undefined;
+            cacheHexString?: unknown;
+            generate?: {} | null | undefined;
+            createFromTime?: {} | null | undefined;
+            createFromHexString?: {} | null | undefined;
+            createFromBase64?: {} | null | undefined;
+            isValid?: {} | null | undefined;
+        };
+        addresses: string[];
+        message?: string | null | undefined;
+    } | null | undefined;
+}>, {}> & import("mongoose").FlatRecord<{} & {
+    account: {
+        prototype?: Types.ObjectId | null | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | null | undefined;
+        createFromTime?: {} | null | undefined;
+        createFromHexString?: {} | null | undefined;
+        createFromBase64?: {} | null | undefined;
+        isValid?: {} | null | undefined;
+    };
+    status: string;
+    comunication: {
+        prototype?: Types.ObjectId | null | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | null | undefined;
+        createFromTime?: {} | null | undefined;
+        createFromHexString?: {} | null | undefined;
+        createFromBase64?: {} | null | undefined;
+        isValid?: {} | null | undefined;
+    };
+    message?: string | null | undefined;
+    pushContent?: {
+        status: string;
+        title: string;
+        body: string;
+        template: {
+            prototype?: Types.ObjectId | null | undefined;
+            cacheHexString?: unknown;
+            generate?: {} | null | undefined;
+            createFromTime?: {} | null | undefined;
+            createFromHexString?: {} | null | undefined;
+            createFromBase64?: {} | null | undefined;
+            isValid?: {} | null | undefined;
+        };
+        image?: ({} & {
+            contentType: string;
+            description: string;
+            format?: string | null | undefined;
+            url?: string | null | undefined;
+        }) | null | undefined;
+        message?: string | null | undefined;
+        redirect?: string | null | undefined;
+        metadata?: Map<string, string> | null | undefined;
+    } | null | undefined;
+    emailContent?: {
+        status: string;
+        subject: string;
+        bodyHtml: string;
+        template: {
+            prototype?: Types.ObjectId | null | undefined;
+            cacheHexString?: unknown;
+            generate?: {} | null | undefined;
+            createFromTime?: {} | null | undefined;
+            createFromHexString?: {} | null | undefined;
+            createFromBase64?: {} | null | undefined;
+            isValid?: {} | null | undefined;
+        };
+        addresses: string[];
+        message?: string | null | undefined;
+    } | null | undefined;
+}> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;

package/dist/models/AdminEventComunication.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminEventComunicationSchema = exports.AdminEventComunicationMessageStatus = exports.AdminEventComunicationStatus = void 0;
+const mongoose_1 = require("mongoose");
+const File_1 = require("./File");
+var AdminEventComunicationStatus;
+(function (AdminEventComunicationStatus) {
+    AdminEventComunicationStatus["CREATED"] = "CREATED";
+    AdminEventComunicationStatus["RUNNING"] = "RUNNING";
+    AdminEventComunicationStatus["ERROR"] = "ERROR";
+    AdminEventComunicationStatus["DONE"] = "DONE";
+})(AdminEventComunicationStatus || (exports.AdminEventComunicationStatus = AdminEventComunicationStatus = {}));
+var AdminEventComunicationMessageStatus;
+(function (AdminEventComunicationMessageStatus) {
+    AdminEventComunicationMessageStatus["CREATED"] = "CREATED";
+    AdminEventComunicationMessageStatus["SENT"] = "SENT";
+    AdminEventComunicationMessageStatus["DELIVERED"] = "DELIVERED";
+    AdminEventComunicationMessageStatus["READ"] = "READ";
+    AdminEventComunicationMessageStatus["ERROR"] = "ERROR";
+})(AdminEventComunicationMessageStatus || (exports.AdminEventComunicationMessageStatus = AdminEventComunicationMessageStatus = {}));
+exports.AdminEventComunicationSchema = new mongoose_1.Schema({
+    account: { type: mongoose_1.Types.ObjectId, ref: "account", required: true },
+    comunication: { type: mongoose_1.Types.ObjectId, ref: "admin-comunication", required: true },
+    pushContent: {
+        type: {
+            template: { type: mongoose_1.Types.ObjectId, ref: "admin-template-push", required: true },
+            status: { type: String, enum: AdminEventComunicationMessageStatus, required: true, default: AdminEventComunicationMessageStatus.CREATED },
+            title: { type: String, required: true },
+            body: { type: String, required: true },
+            image: { type: File_1.FileSchema, required: false },
+            redirect: { type: String, required: false },
+            metadata: { type: Map, of: String, required: false },
+            message: { type: String, required: false },
+        },
+        required: false
+    },
+    emailContent: {
+        type: {
+            template: { type: mongoose_1.Types.ObjectId, ref: "admin-template-email", required: true },
+            status: { type: String, enum: AdminEventComunicationMessageStatus, required: true, default: AdminEventComunicationMessageStatus.CREATED },
+            subject: { type: String, required: true },
+            bodyHtml: { type: String, required: true },
+            addresses: { type: [String], required: true },
+            message: { type: String, required: false },
+        },
+        required: false
+    },
+    status: { type: String, enum: AdminEventComunicationStatus, required: true, default: AdminEventComunicationStatus.CREATED },
+    message: { type: String, required: false },
+}, {
+    timestamps: { createdAt: "createdAtDateTime", updatedAt: "updatedAtDateTime" }
+});
+exports.AdminEventComunicationSchema.index({ account: 1 }, { unique: false });
+exports.AdminEventComunicationSchema.index({ account: 1, status: 1 }, { unique: false });

package/dist/models/AdminNotification.d.ts

@@ -0,0 +1,86 @@
+import { Schema, Types } from "mongoose";
+import { IAccount } from "./Account";
+export declare enum AdminNotificationStatus {
+    DRAFT = "DRAFT",
+    SCHEDULED = "SCHEDULED",
+    SENT = "SENT",
+    FAILED = "FAILED",
+    CANCELLED = "CANCELLED"
+}
+export interface IAdminNotification {
+    title: string;
+    message: string;
+    redirect: string;
+    metadata: Map<string, string>;
+    destinations: Types.ObjectId[] | IAccount[];
+    sentAtDateTime: Date;
+    status: AdminNotificationStatus;
+    push: boolean;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+export declare const AdminNotificationSchema: Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: {
+        createdAt: string;
+        updatedAt: string;
+    };
+}, {
+    push: boolean;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+    message: string;
+    status: string;
+    title: string;
+    redirect?: string | undefined;
+    metadata?: Map<string, string> | undefined;
+    destinations?: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        createFromBase64?: {} | undefined;
+        isValid?: {} | undefined;
+    }[] | undefined;
+    sentAtDateTime?: Date | undefined;
+}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
+    push: boolean;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+    message: string;
+    status: string;
+    title: string;
+    redirect?: string | undefined;
+    metadata?: Map<string, string> | undefined;
+    destinations?: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        createFromBase64?: {} | undefined;
+        isValid?: {} | undefined;
+    }[] | undefined;
+    sentAtDateTime?: Date | undefined;
+}>> & import("mongoose").FlatRecord<{
+    push: boolean;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+    message: string;
+    status: string;
+    title: string;
+    redirect?: string | undefined;
+    metadata?: Map<string, string> | undefined;
+    destinations?: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        createFromBase64?: {} | undefined;
+        isValid?: {} | undefined;
+    }[] | undefined;
+    sentAtDateTime?: Date | undefined;
+}> & {
+    _id: Types.ObjectId;
+}>;

package/dist/models/AdminNotification.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminNotificationSchema = exports.AdminNotificationStatus = void 0;
+const mongoose_1 = require("mongoose");
+var AdminNotificationStatus;
+(function (AdminNotificationStatus) {
+    AdminNotificationStatus["DRAFT"] = "DRAFT";
+    AdminNotificationStatus["SCHEDULED"] = "SCHEDULED";
+    AdminNotificationStatus["SENT"] = "SENT";
+    AdminNotificationStatus["FAILED"] = "FAILED";
+    AdminNotificationStatus["CANCELLED"] = "CANCELLED";
+})(AdminNotificationStatus || (exports.AdminNotificationStatus = AdminNotificationStatus = {}));
+exports.AdminNotificationSchema = new mongoose_1.Schema({
+    title: { type: String, required: true },
+    message: { type: String, required: true },
+    redirect: { type: String, required: false },
+    metadata: { type: Map, of: String, required: false },
+    destinations: { type: [mongoose_1.Types.ObjectId], required: false },
+    sentAtDateTime: { type: Date, required: false },
+    status: { type: String, enum: AdminNotificationStatus, required: true, default: AdminNotificationStatus.DRAFT },
+    push: { type: Boolean, required: true, default: false },
+    createdAtDateTime: { type: Date, required: true },
+    updatedAtDateTime: { type: Date, required: true }
+}, {
+    timestamps: { createdAt: "createdAtDateTime", updatedAt: "updatedAtDateTime" }
+});

package/dist/models/AdminTemplateEmail.d.ts

@@ -0,0 +1,40 @@
+import { Schema, Types } from "mongoose";
+export declare enum AdminTemplateEmailStatus {
+    DRAFT = "DRAFT",
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE"
+}
+export interface IAdminTemplateEmail {
+    _id: Types.ObjectId;
+    name: string;
+    subject: string;
+    bodyHtml: string;
+    status: AdminTemplateEmailStatus;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+export declare const AdminTemplateEmailSchema: Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: {
+        createdAt: string;
+        updatedAt: string;
+    };
+}, {} & {
+    name: string;
+    status: string;
+    subject: string;
+    bodyHtml: string;
+}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{} & {
+    name: string;
+    status: string;
+    subject: string;
+    bodyHtml: string;
+}>, {}> & import("mongoose").FlatRecord<{} & {
+    name: string;
+    status: string;
+    subject: string;
+    bodyHtml: string;
+}> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;

package/dist/models/AdminTemplateEmail.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminTemplateEmailSchema = exports.AdminTemplateEmailStatus = void 0;
+const mongoose_1 = require("mongoose");
+var AdminTemplateEmailStatus;
+(function (AdminTemplateEmailStatus) {
+    AdminTemplateEmailStatus["DRAFT"] = "DRAFT";
+    AdminTemplateEmailStatus["ACTIVE"] = "ACTIVE";
+    AdminTemplateEmailStatus["INACTIVE"] = "INACTIVE";
+})(AdminTemplateEmailStatus || (exports.AdminTemplateEmailStatus = AdminTemplateEmailStatus = {}));
+exports.AdminTemplateEmailSchema = new mongoose_1.Schema({
+    name: { type: String, required: true },
+    subject: { type: String, required: true },
+    bodyHtml: { type: String, required: true },
+    status: { type: String, enum: AdminTemplateEmailStatus, required: true, default: AdminTemplateEmailStatus.DRAFT },
+}, {
+    timestamps: { createdAt: "createdAtDateTime", updatedAt: "updatedAtDateTime" }
+});
+exports.AdminTemplateEmailSchema.index({ name: 1 }, { unique: true });

package/dist/models/AdminTemplatePush.d.ts

@@ -0,0 +1,68 @@
+import { Schema, Types } from "mongoose";
+import { IFile } from "./File";
+export declare enum AdminTemplatePushStatus {
+    DRAFT = "DRAFT",
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE"
+}
+export interface IAdminTemplatePush {
+    _id: Types.ObjectId;
+    name: string;
+    title: string;
+    body: string;
+    image?: IFile;
+    redirect?: string;
+    metadata?: Map<string, string>;
+    status: AdminTemplatePushStatus;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+export declare const AdminTemplatePushSchema: Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: {
+        createdAt: string;
+        updatedAt: string;
+    };
+}, {} & {
+    name: string;
+    status: string;
+    title: string;
+    body: string;
+    image?: ({} & {
+        contentType: string;
+        description: string;
+        format?: string | null | undefined;
+        url?: string | null | undefined;
+    }) | null | undefined;
+    redirect?: string | null | undefined;
+    metadata?: Map<string, string> | null | undefined;
+}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{} & {
+    name: string;
+    status: string;
+    title: string;
+    body: string;
+    image?: ({} & {
+        contentType: string;
+        description: string;
+        format?: string | null | undefined;
+        url?: string | null | undefined;
+    }) | null | undefined;
+    redirect?: string | null | undefined;
+    metadata?: Map<string, string> | null | undefined;
+}>, {}> & import("mongoose").FlatRecord<{} & {
+    name: string;
+    status: string;
+    title: string;
+    body: string;
+    image?: ({} & {
+        contentType: string;
+        description: string;
+        format?: string | null | undefined;
+        url?: string | null | undefined;
+    }) | null | undefined;
+    redirect?: string | null | undefined;
+    metadata?: Map<string, string> | null | undefined;
+}> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;

package/dist/models/AdminTemplatePush.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminTemplatePushSchema = exports.AdminTemplatePushStatus = void 0;
+const mongoose_1 = require("mongoose");
+const File_1 = require("./File");
+var AdminTemplatePushStatus;
+(function (AdminTemplatePushStatus) {
+    AdminTemplatePushStatus["DRAFT"] = "DRAFT";
+    AdminTemplatePushStatus["ACTIVE"] = "ACTIVE";
+    AdminTemplatePushStatus["INACTIVE"] = "INACTIVE";
+})(AdminTemplatePushStatus || (exports.AdminTemplatePushStatus = AdminTemplatePushStatus = {}));
+exports.AdminTemplatePushSchema = new mongoose_1.Schema({
+    name: { type: String, required: true },
+    title: { type: String, required: true },
+    body: { type: String, required: true },
+    image: { type: File_1.FileSchema, required: false },
+    redirect: { type: String, required: false },
+    metadata: { type: Map, of: String, required: false },
+    status: { type: String, enum: AdminTemplatePushStatus, required: true, default: AdminTemplatePushStatus.DRAFT },
+}, {
+    timestamps: { createdAt: "createdAtDateTime", updatedAt: "updatedAtDateTime" }
+});
+exports.AdminTemplatePushSchema.index({ name: 1 }, { unique: true });

package/dist/models/Challenge.d.ts

@@ -0,0 +1,40 @@
+import { Schema, Types } from "mongoose";
+import { ChallengeStatus } from "../types/ChallengeStatus";
+import { IChampionship } from "./Championship";
+import { IChampionshipRound } from "./ChampionshipRound";
+import { IFile } from "./File";
+import { ChallengeRoundStatus } from "../types/ChallengeRoundStatus";
+import { ITicket } from "./Ticket";
+export interface IChallenge {
+    _id: Types.ObjectId;
+    name: string;
+    slug: string;
+    championship: Types.ObjectId | IChampionship;
+    roundStart: IChampionshipRound;
+    roundEnd: IChampionshipRound;
+    descriptionShort: string;
+    descriptionLong: string;
+    thumb: IFile;
+    bugdetAccumulated: number;
+    ticketValue: number;
+    ticketsLimitDateTime: Date;
+    totalTicketsPaid: number;
+    totalTicketsInGamming: number;
+    ticketsWinners: Types.ObjectId[] | ITicket[];
+    roundStartIndex: number;
+    roundCurrentIndex: number;
+    roundCurrentStatus: ChallengeRoundStatus;
+    roundEndIndex: number;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+    status: ChallengeStatus;
+}
+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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChallengeSchema = void 0;
+const mongoose_1 = require("mongoose");
+const ChallengeStatus_1 = require("../types/ChallengeStatus");
+const File_1 = require("./File");
+const ChallengeRoundStatus_1 = require("../types/ChallengeRoundStatus");
+exports.ChallengeSchema = new mongoose_1.Schema({
+    name: { type: String, required: true },
+    slug: { type: String, required: true },
+    descriptionShort: { type: String, required: false },
+    descriptionLong: { type: String, required: false },
+    thumb: { type: File_1.FileSchema, required: false },
+    championship: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "championship",
+        required: true
+    },
+    roundStart: { type: mongoose_1.Schema.Types.ObjectId, ref: "championship-round", required: true },
+    roundEnd: { type: mongoose_1.Schema.Types.ObjectId, ref: "championship-round", required: true },
+    status: { type: String, enum: ChallengeStatus_1.ChallengeStatus, default: ChallengeStatus_1.ChallengeStatus.DRAFT },
+    bugdetAccumulated: { type: Number, required: false },
+    ticketValue: { type: Number, required: true },
+    ticketsLimitDateTime: { type: Date, required: false },
+    ticketsWinners: { type: [mongoose_1.Schema.Types.ObjectId], ref: "ticket", required: false },
+    roundStartIndex: { type: Number, required: false },
+    roundCurrentIndex: { type: Number, required: false },
+    roundCurrentStatus: { type: String, enum: ChallengeRoundStatus_1.ChallengeRoundStatus, required: false },
+    roundEndIndex: { type: Number, required: false },
+    totalTicketsPaid: { type: Number, required: false },
+    totalTicketsInGamming: { type: Number, required: false },
+}, {
+    timestamps: {
+        createdAt: "createdAtDateTime",
+        updatedAt: "updatedAtDateTime"
+    }
+});
+exports.ChallengeSchema.index({ championship: 1 });

package/dist/models/ChallengeRound.d.ts

@@ -0,0 +1,41 @@
+import { Schema, Types } from "mongoose";
+import { ChallengeRoundStatus } from "../types/ChallengeRoundStatus";
+import { IChallenge } from "./Challenge";
+import { IChampionshipMatch } from "./ChampionshipMatch";
+import { IChampionshipRound } from "./ChampionshipRound";
+import { ITeam } from "./Team";
+export interface IChallengeMatch {
+    match: Types.ObjectId | IChampionshipMatch;
+    enabled: boolean;
+    isDraw?: boolean;
+    teamWinner?: Types.ObjectId | ITeam;
+}
+export interface IChallengeRound {
+    _id: Types.ObjectId;
+    challenge: Types.ObjectId | IChallenge;
+    round: Types.ObjectId | IChampionshipRound;
+    matches?: IChallengeMatch[];
+    enabled: boolean;
+    status: ChallengeRoundStatus;
+    sequenceOrder?: number;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+export declare const ChallengeMatchSchema: Schema<IChallengeMatch, import("mongoose").Model<IChallengeMatch, any, any, any, import("mongoose").Document<unknown, any, IChallengeMatch, any> & IChallengeMatch & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IChallengeMatch, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IChallengeMatch>, {}> & import("mongoose").FlatRecord<IChallengeMatch> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+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;
+}>;