c2-climbing-x 1.0.85 → 1.0.87

package/dist/models/Access.d.ts

@@ -18,7 +18,7 @@ export declare const AccessSchema: Schema<any, import("mongoose").Model<any, any
         createdAt: string;
         updatedAt: string;
     };
-}, {} & {
+}, {
     active: boolean;
     account: Types.ObjectId;
     token: string;
@@ -26,9 +26,9 @@ export declare const AccessSchema: Schema<any, import("mongoose").Model<any, any
     userAgent: string;
     latitude: number;
     longitude: number;
-    notes?: string | null | undefined;
-    tokenFCM?: string | null | undefined;
-}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{} & {
+    notes?: string | undefined;
+    tokenFCM?: string | undefined;
+}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
     active: boolean;
     account: Types.ObjectId;
     token: string;
@@ -36,9 +36,9 @@ export declare const AccessSchema: Schema<any, import("mongoose").Model<any, any
     userAgent: string;
     latitude: number;
     longitude: number;
-    notes?: string | null | undefined;
-    tokenFCM?: string | null | undefined;
-}>, {}> & import("mongoose").FlatRecord<{} & {
+    notes?: string | undefined;
+    tokenFCM?: string | undefined;
+}>> & import("mongoose").FlatRecord<{
     active: boolean;
     account: Types.ObjectId;
     token: string;
@@ -46,10 +46,8 @@ export declare const AccessSchema: Schema<any, import("mongoose").Model<any, any
     userAgent: string;
     latitude: number;
     longitude: number;
-    notes?: string | null | undefined;
-    tokenFCM?: string | null | undefined;
+    notes?: string | undefined;
+    tokenFCM?: string | undefined;
 }> & {
     _id: Types.ObjectId;
-} & {
-    __v: number;
 }>;

package/dist/models/Account.d.ts

@@ -18,12 +18,8 @@ export interface IAccount {
     updatedAtDateTime: Date;
     image?: IFile;
 }
-export declare const AccountSchema: Schema<IAccount, import("mongoose").Model<IAccount, any, any, any, import("mongoose").Document<unknown, any, IAccount, any> & IAccount & Required<{
+export declare const AccountSchema: Schema<IAccount, import("mongoose").Model<IAccount, any, any, any, import("mongoose").Document<unknown, any, IAccount> & IAccount & Required<{
     _id: Types.ObjectId;
-}> & {
-    __v: number;
-}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IAccount, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IAccount>, {}> & import("mongoose").FlatRecord<IAccount> & Required<{
+}>, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IAccount, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IAccount>> & import("mongoose").FlatRecord<IAccount> & Required<{
     _id: Types.ObjectId;
-}> & {
-    __v: number;
-}>;
+}>>;

package/dist/models/Challenge.d.ts

@@ -27,12 +27,8 @@ export interface IChallenge {
     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<{
+export declare const ChallengeSchema: Schema<IChallenge, import("mongoose").Model<IChallenge, any, any, any, import("mongoose").Document<unknown, any, IChallenge> & 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<{
+}>, 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/ChallengeRound.d.ts

@@ -21,21 +21,13 @@ export interface IChallengeRound {
     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 & {
+export declare const ChallengeMatchSchema: Schema<IChallengeMatch, import("mongoose").Model<IChallengeMatch, any, any, any, import("mongoose").Document<unknown, any, IChallengeMatch> & IChallengeMatch & {
     _id: Types.ObjectId;
-} & {
-    __v: number;
-}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IChallengeMatch, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IChallengeMatch>, {}> & import("mongoose").FlatRecord<IChallengeMatch> & {
+}, 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<{
+export declare const ChallengeRoundSchema: Schema<IChallengeRound, import("mongoose").Model<IChallengeRound, any, any, any, import("mongoose").Document<unknown, any, IChallengeRound> & 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<{
+}>, 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/Championship.d.ts

@@ -12,12 +12,8 @@ export interface IChampionship {
     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<{
+export declare const ChampionshipSchema: Schema<IChampionship, import("mongoose").Model<IChampionship, any, any, any, import("mongoose").Document<unknown, any, IChampionship> & 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<{
+}>, 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/ChampionshipClassification.d.ts

@@ -20,12 +20,8 @@ export interface IChampionshipClassification {
     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<{
+export declare const ChampionshipClassificationSchema: Schema<IChampionshipClassification, import("mongoose").Model<IChampionshipClassification, any, any, any, import("mongoose").Document<unknown, any, IChampionshipClassification> & 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<{
+}>, 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/ChampionshipMatch.d.ts

@@ -22,12 +22,8 @@ export interface IChampionshipMatch {
     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<{
+export declare const ChampionshipMatchSchema: Schema<IChampionshipMatch, import("mongoose").Model<IChampionshipMatch, any, any, any, import("mongoose").Document<unknown, any, IChampionshipMatch> & 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<{
+}>, 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/ChampionshipPhase.d.ts

@@ -45,57 +45,33 @@ export interface IQualifiedRule {
     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<{
+export declare const SlotsSchema: Schema<ISlots, import("mongoose").Model<ISlots, any, any, any, import("mongoose").Document<unknown, any, ISlots> & 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<{
+}>, 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<{
+}>>;
+export declare const QualifiedsSlotsSchema: Schema<IQualifiedsSlots, import("mongoose").Model<IQualifiedsSlots, any, any, any, import("mongoose").Document<unknown, any, IQualifiedsSlots> & 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<{
+}>, 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 & {
+}>>;
+export declare const GroupSchema: Schema<IGroup, import("mongoose").Model<IGroup, any, any, any, import("mongoose").Document<unknown, any, IGroup> & IGroup & {
     _id: Types.ObjectId;
-} & {
-    __v: number;
-}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IGroup, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IGroup>, {}> & import("mongoose").FlatRecord<IGroup> & {
+}, 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 & {
+export declare const QualifiedRuleSchema: Schema<IQualifiedRule, import("mongoose").Model<IQualifiedRule, any, any, any, import("mongoose").Document<unknown, any, IQualifiedRule> & IQualifiedRule & {
     _id: Types.ObjectId;
-} & {
-    __v: number;
-}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IQualifiedRule, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IQualifiedRule>, {}> & import("mongoose").FlatRecord<IQualifiedRule> & {
+}, 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 & {
+export declare const MatchRulesSchema: Schema<IMatchRules, import("mongoose").Model<IMatchRules, any, any, any, import("mongoose").Document<unknown, any, IMatchRules> & IMatchRules & {
     _id: Types.ObjectId;
-} & {
-    __v: number;
-}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IMatchRules, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IMatchRules>, {}> & import("mongoose").FlatRecord<IMatchRules> & {
+}, 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<{
+export declare const ChampionshipPhaseSchema: Schema<IChampionshipPhase, import("mongoose").Model<IChampionshipPhase, any, any, any, import("mongoose").Document<unknown, any, IChampionshipPhase> & 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<{
+}>, 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/ChampionshipRound.d.ts

@@ -15,12 +15,8 @@ export interface IChampionshipRound {
     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<{
+export declare const ChampionshipRoundSchema: Schema<IChampionshipRound, import("mongoose").Model<IChampionshipRound, any, any, any, import("mongoose").Document<unknown, any, IChampionshipRound> & 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<{
+}>, 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/File.d.ts

@@ -11,23 +11,21 @@ export declare const FileSchema: Schema<any, import("mongoose").Model<any, any,
         createdAt: string;
         updatedAt: string;
     };
-}, {} & {
+}, {
     contentType: string;
     description: string;
-    format?: string | null | undefined;
-    url?: string | null | undefined;
-}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{} & {
+    format?: string | undefined;
+    url?: string | undefined;
+}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
     contentType: string;
     description: string;
-    format?: string | null | undefined;
-    url?: string | null | undefined;
-}>, {}> & import("mongoose").FlatRecord<{} & {
+    format?: string | undefined;
+    url?: string | undefined;
+}>> & import("mongoose").FlatRecord<{
     contentType: string;
     description: string;
-    format?: string | null | undefined;
-    url?: string | null | undefined;
+    format?: string | undefined;
+    url?: string | undefined;
 }> & {
     _id: import("mongoose").Types.ObjectId;
-} & {
-    __v: number;
 }>;

package/dist/models/Team.d.ts

@@ -10,12 +10,8 @@ export interface ITeam {
     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<{
+export declare const TeamSchema: Schema<ITeam, import("mongoose").Model<ITeam, any, any, any, import("mongoose").Document<unknown, any, ITeam> & 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<{
+}>, 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/Ticket.d.ts

@@ -23,12 +23,8 @@ export interface ITicket {
     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<{
+export declare const TicketSchema: Schema<ITicket, import("mongoose").Model<ITicket, any, any, any, import("mongoose").Document<unknown, any, ITicket> & 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<{
+}>, 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/TicketGuess.d.ts

@@ -20,12 +20,8 @@ export interface ITicketGuess {
     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<{
+export declare const TicketGuessSchema: Schema<ITicketGuess, import("mongoose").Model<ITicketGuess, any, any, any, import("mongoose").Document<unknown, any, ITicketGuess> & 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<{
+}>, 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/TicketOrder.d.ts

@@ -34,21 +34,13 @@ export interface ITicketOrder {
     createdAtDateTime: Date;
     updatedAtDateTime: Date;
 }
-export declare const AcceptTermsOfChallengeSchema: Schema<IAcceptTermsOfChallenge, import("mongoose").Model<IAcceptTermsOfChallenge, any, any, any, import("mongoose").Document<unknown, any, IAcceptTermsOfChallenge, any> & IAcceptTermsOfChallenge & {
+export declare const AcceptTermsOfChallengeSchema: Schema<IAcceptTermsOfChallenge, import("mongoose").Model<IAcceptTermsOfChallenge, any, any, any, import("mongoose").Document<unknown, any, IAcceptTermsOfChallenge> & IAcceptTermsOfChallenge & {
     _id: Types.ObjectId;
-} & {
-    __v: number;
-}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IAcceptTermsOfChallenge, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IAcceptTermsOfChallenge>, {}> & import("mongoose").FlatRecord<IAcceptTermsOfChallenge> & {
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IAcceptTermsOfChallenge, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IAcceptTermsOfChallenge>> & import("mongoose").FlatRecord<IAcceptTermsOfChallenge> & {
     _id: Types.ObjectId;
-} & {
-    __v: number;
 }>;
-export declare const TicketOrderSchema: Schema<ITicketOrder, import("mongoose").Model<ITicketOrder, any, any, any, import("mongoose").Document<unknown, any, ITicketOrder, any> & ITicketOrder & Required<{
+export declare const TicketOrderSchema: Schema<ITicketOrder, import("mongoose").Model<ITicketOrder, any, any, any, import("mongoose").Document<unknown, any, ITicketOrder> & ITicketOrder & Required<{
     _id: Types.ObjectId;
-}> & {
-    __v: number;
-}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, ITicketOrder, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<ITicketOrder>, {}> & import("mongoose").FlatRecord<ITicketOrder> & Required<{
+}>, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, ITicketOrder, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<ITicketOrder>> & import("mongoose").FlatRecord<ITicketOrder> & Required<{
     _id: Types.ObjectId;
-}> & {
-    __v: number;
-}>;
+}>>;

package/dist/models/WalletMoviment.d.ts

@@ -17,21 +17,47 @@ export interface IWalletMoviment {
     account: Types.ObjectId | IAccount;
     description: string;
     valueMovemented: number;
+    fee: number;
     typeMovement: WalletMovimentType;
     balanceBefore: number;
     balanceAfter: number;
     status: WalletMovimentStatus;
     confirmDateTime: Date;
+    manual: boolean;
     files: IFile[];
+    pagarmeOrder: {
+        id: string;
+        code: string;
+        status: string;
+        amount: number;
+        gatewayId: string;
+        paymentMethod: string;
+    };
+    pagarmeCharges: {
+        id: string;
+        code: string;
+        status: string;
+        amount: number;
+        gatewayId: string;
+        paymentMethod: string;
+        lastTransaction: {
+            id: string;
+            status: string;
+            success: boolean;
+            gatewayId: string;
+            amount: number;
+            qrCode: string;
+            qrCodeUrl: string;
+            providerTId: string;
+            expireDateTime: Date;
+            transactionType: string;
+        };
+    }[];
     createdAtDateTime: Date;
     updatedAtDateTime: Date;
 }
-export declare const WalletMovimentSchema: Schema<IWalletMoviment, import("mongoose").Model<IWalletMoviment, any, any, any, import("mongoose").Document<unknown, any, IWalletMoviment, any> & IWalletMoviment & Required<{
+export declare const WalletMovimentSchema: Schema<IWalletMoviment, import("mongoose").Model<IWalletMoviment, any, any, any, import("mongoose").Document<unknown, any, IWalletMoviment> & IWalletMoviment & Required<{
     _id: Types.ObjectId;
-}> & {
-    __v: number;
-}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IWalletMoviment, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IWalletMoviment>, {}> & import("mongoose").FlatRecord<IWalletMoviment> & Required<{
+}>, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IWalletMoviment, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IWalletMoviment>> & import("mongoose").FlatRecord<IWalletMoviment> & Required<{
     _id: Types.ObjectId;
-}> & {
-    __v: number;
-}>;
+}>>;

package/dist/models/WalletMoviment.js

@@ -20,12 +20,47 @@ exports.WalletMovimentSchema = new mongoose_1.Schema({
     account: { type: mongoose_1.Schema.Types.ObjectId, ref: "account", required: true },
     description: { type: String, required: true },
     valueMovemented: { type: Number, required: true },
+    fee: { type: Number, required: false },
     typeMovement: { type: String, required: true, enum: WalletMovimentType },
     balanceBefore: { type: Number, required: true },
     balanceAfter: { type: Number, required: true },
     confirmDateTime: { type: Date, required: false },
     status: { type: String, required: true, enum: WalletMovimentStatus },
     files: { type: [File_1.FileSchema], required: false },
+    manual: { type: Boolean, required: false },
+    pagarmeOrder: {
+        type: {
+            id: { type: String, required: false },
+            code: { type: String, required: false },
+            status: { type: String, required: false },
+            amount: { type: Number, required: false },
+            gatewayId: { type: String, required: false },
+            paymentMethod: { type: String, required: false },
+        },
+    },
+    pagarmeCharges: {
+        type: [{
+                id: { type: String, required: false },
+                code: { type: String, required: false },
+                status: { type: String, required: false },
+                amount: { type: Number, required: false },
+                gatewayId: { type: String, required: false },
+                paymentMethod: { type: String, required: false },
+                lastTransaction: {
+                    id: { type: String, required: false },
+                    status: { type: String, required: false },
+                    success: { type: Boolean, required: false },
+                    gatewayId: { type: String, required: false },
+                    amount: { type: Number, required: false },
+                    qrCode: { type: String, required: false },
+                    qrCodeUrl: { type: String, required: false },
+                    providerTId: { type: String, required: false },
+                    expireDateTime: { type: Date, required: false },
+                    transactionType: { type: String, required: false },
+                }
+            }],
+        required: false,
+    },
 }, {
     timestamps: {
         createdAt: "createdAtDateTime",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c2-climbing-x",
-  "version": "1.0.85",
+  "version": "1.0.87",
   "description": "Modelagem TypeScript/Mongoose para o jogo Escalada X (times, campeonatos, fases, rodadas, confrontos, desafios)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/models/Match.d.ts

@@ -1,17 +0,0 @@
-import { Model, Types } from "mongoose";
-import { MatchStatus } from "../types/MatchStatus";
-import { IChampionshipRound } from "./ChampionshipRound";
-import { ITeam } from "./Team";
-export interface IMatch {
-    _id: Types.ObjectId;
-    round: Types.ObjectId | IChampionshipRound;
-    homeTeam: Types.ObjectId | ITeam;
-    awayTeam: Types.ObjectId | ITeam;
-    scheduledAt?: Date;
-    homeScore?: number;
-    awayScore?: number;
-    status: MatchStatus;
-    createdAtDateTime: Date;
-    updatedAtDateTime: Date;
-}
-export declare const MatchModel: Model<IMatch>;

package/dist/models/Match.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MatchModel = void 0;
-const mongoose_1 = require("mongoose");
-const MatchStatus_1 = require("../types/MatchStatus");
-const MatchSchema = new mongoose_1.Schema({
-    round: { type: mongoose_1.Schema.Types.ObjectId, ref: "championship-round", required: true },
-    homeTeam: { type: mongoose_1.Schema.Types.ObjectId, ref: "team", required: true },
-    awayTeam: { type: mongoose_1.Schema.Types.ObjectId, ref: "team", required: true },
-    scheduledAt: { type: Date, required: false },
-    homeScore: { type: Number, required: false },
-    awayScore: { type: Number, required: false },
-    status: {
-        type: String,
-        required: true,
-        enum: MatchStatus_1.MatchStatus
-    }
-}, {
-    timestamps: {
-        createdAt: "createdAtDateTime",
-        updatedAt: "updatedAtDateTime"
-    }
-});
-MatchSchema.index({ round: 1 });
-MatchSchema.index({ round: 1, homeTeam: 1, awayTeam: 1 }, { unique: true });
-exports.MatchModel = (0, mongoose_1.model)("match", MatchSchema);

package/dist/models/Phase.d.ts

@@ -1,13 +0,0 @@
-import { Model, Types } from "mongoose";
-import { PhaseType } from "../types/PhaseType";
-export interface IPhase {
-    _id: Types.ObjectId;
-    championship: Types.ObjectId;
-    order: number;
-    type: PhaseType;
-    qualifiedForNextPhase: number;
-    teams: Types.ObjectId[];
-    createdAtDateTime: Date;
-    updatedAtDateTime: Date;
-}
-export declare const PhaseModel: Model<IPhase>;

package/dist/models/Phase.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PhaseModel = void 0;
-const mongoose_1 = require("mongoose");
-const PhaseSchema = new mongoose_1.Schema({
-    championship: {
-        type: mongoose_1.Schema.Types.ObjectId,
-        ref: "championship",
-        required: true
-    },
-    order: { type: Number, required: true },
-    type: {
-        type: String,
-        required: true,
-        enum: ["PONTO_CORRIDO", "MATA_MATA"]
-    },
-    qualifiedForNextPhase: { type: Number, required: true },
-    teams: [{ type: mongoose_1.Schema.Types.ObjectId, ref: "team", required: true }]
-}, {
-    timestamps: {
-        createdAt: "createdAtDateTime",
-        updatedAt: "updatedAtDateTime"
-    }
-});
-PhaseSchema.index({ championship: 1 });
-PhaseSchema.index({ championship: 1, order: 1 }, { unique: true });
-exports.PhaseModel = (0, mongoose_1.model)("phase", PhaseSchema);

package/dist/models/Round.d.ts

@@ -1,16 +0,0 @@
-import { Model, Types } from "mongoose";
-import { RoundStatus } from "../types/RoundStatus";
-export interface IRound {
-    _id: Types.ObjectId;
-    phase: Types.ObjectId;
-    championship: Types.ObjectId;
-    roundIndexInPhase: number;
-    globalRoundIndex: number;
-    label?: string;
-    startDate?: Date;
-    endDate?: Date;
-    status: RoundStatus;
-    createdAtDateTime: Date;
-    updatedAtDateTime: Date;
-}
-export declare const RoundModel: Model<IRound>;

package/dist/models/Round.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RoundModel = void 0;
-const mongoose_1 = require("mongoose");
-const RoundSchema = new mongoose_1.Schema({
-    phase: { type: mongoose_1.Schema.Types.ObjectId, ref: "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: ["PENDING", "OPEN", "CLOSED"]
-    }
-}, {
-    timestamps: {
-        createdAt: "createdAtDateTime",
-        updatedAt: "updatedAtDateTime"
-    }
-});
-RoundSchema.index({ phase: 1 });
-RoundSchema.index({ championship: 1 });
-RoundSchema.index({ championship: 1, globalRoundIndex: 1 }, { unique: true });
-exports.RoundModel = (0, mongoose_1.model)("round", RoundSchema);