@lyxa.ai/marketing 1.0.47 → 1.0.48

package/dist/types/modules/marketing/validations/featured-marketing.validation.d.ts

@@ -29,9 +29,9 @@ declare const FeaturedMarketingValidationSchema: z.ZodObject<{
         end?: Date | undefined;
     };
     shop: import("mongoose").Types.ObjectId;
-    marketingType: MarketingType.FEATURED;
     isAppliedByCompany: boolean;
     pausedAt: Date | null;
+    marketingType: MarketingType.FEATURED;
     amount: number;
     admin?: import("mongoose").Types.ObjectId | null | undefined;
 }, {
@@ -40,8 +40,8 @@ declare const FeaturedMarketingValidationSchema: z.ZodObject<{
         end?: string | Date | undefined;
     };
     shop: string | import("mongoose").Types.ObjectId;
-    marketingType: MarketingType.FEATURED;
     isAppliedByCompany: boolean;
+    marketingType: MarketingType.FEATURED;
     amount: number;
     status?: import("@lyxa.ai/core/dist/utilities/enum").MarketingStatus | undefined;
     admin?: string | import("mongoose").Types.ObjectId | null | undefined;
@@ -192,9 +192,9 @@ declare const FeaturedMarketingValidationSchemaRefined: z.ZodEffects<z.ZodObject
         end?: Date | undefined;
     };
     shop: import("mongoose").Types.ObjectId;
-    marketingType: MarketingType.FEATURED;
     isAppliedByCompany: boolean;
     pausedAt: Date | null;
+    marketingType: MarketingType.FEATURED;
     amount: number;
     admin?: import("mongoose").Types.ObjectId | null | undefined;
 }, {
@@ -203,8 +203,8 @@ declare const FeaturedMarketingValidationSchemaRefined: z.ZodEffects<z.ZodObject
         end?: string | Date | undefined;
     };
     shop: string | import("mongoose").Types.ObjectId;
-    marketingType: MarketingType.FEATURED;
     isAppliedByCompany: boolean;
+    marketingType: MarketingType.FEATURED;
     amount: number;
     status?: import("@lyxa.ai/core/dist/utilities/enum").MarketingStatus | undefined;
     admin?: string | import("mongoose").Types.ObjectId | null | undefined;
@@ -216,9 +216,9 @@ declare const FeaturedMarketingValidationSchemaRefined: z.ZodEffects<z.ZodObject
         end?: Date | undefined;
     };
     shop: import("mongoose").Types.ObjectId;
-    marketingType: MarketingType.FEATURED;
     isAppliedByCompany: boolean;
     pausedAt: Date | null;
+    marketingType: MarketingType.FEATURED;
     amount: number;
     admin?: import("mongoose").Types.ObjectId | null | undefined;
 }, {
@@ -227,8 +227,8 @@ declare const FeaturedMarketingValidationSchemaRefined: z.ZodEffects<z.ZodObject
         end?: string | Date | undefined;
     };
     shop: string | import("mongoose").Types.ObjectId;
-    marketingType: MarketingType.FEATURED;
     isAppliedByCompany: boolean;
+    marketingType: MarketingType.FEATURED;
     amount: number;
     status?: import("@lyxa.ai/core/dist/utilities/enum").MarketingStatus | undefined;
     admin?: string | import("mongoose").Types.ObjectId | null | undefined;

package/dist/types/modules/marketing/validations/free-delivery-marketing.validation.d.ts

@@ -93,9 +93,9 @@ declare const FreeDeliveryMarketingValidationSchema: z.ZodEffects<z.ZodObject<{
     spendLimit: number;
     isSpendLimitEnabled: boolean;
     shop: import("mongoose").Types.ObjectId;
-    marketingType: MarketingType.FREE_DELIVERY;
     isAppliedByCompany: boolean;
     pausedAt: Date | null;
+    marketingType: MarketingType.FREE_DELIVERY;
     admin?: import("mongoose").Types.ObjectId | null | undefined;
 }, {
     duration: {
@@ -103,8 +103,8 @@ declare const FreeDeliveryMarketingValidationSchema: z.ZodEffects<z.ZodObject<{
         end?: string | Date | undefined;
     };
     shop: string | import("mongoose").Types.ObjectId;
-    marketingType: MarketingType.FREE_DELIVERY;
     isAppliedByCompany: boolean;
+    marketingType: MarketingType.FREE_DELIVERY;
     status?: import("@lyxa.ai/core/dist/utilities/enum").MarketingStatus | undefined;
     spendLimit?: number | undefined;
     isSpendLimitEnabled?: boolean | undefined;
@@ -119,9 +119,9 @@ declare const FreeDeliveryMarketingValidationSchema: z.ZodEffects<z.ZodObject<{
     spendLimit: number;
     isSpendLimitEnabled: boolean;
     shop: import("mongoose").Types.ObjectId;
-    marketingType: MarketingType.FREE_DELIVERY;
     isAppliedByCompany: boolean;
     pausedAt: Date | null;
+    marketingType: MarketingType.FREE_DELIVERY;
     admin?: import("mongoose").Types.ObjectId | null | undefined;
 }, {
     duration: {
@@ -129,8 +129,8 @@ declare const FreeDeliveryMarketingValidationSchema: z.ZodEffects<z.ZodObject<{
         end?: string | Date | undefined;
     };
     shop: string | import("mongoose").Types.ObjectId;
-    marketingType: MarketingType.FREE_DELIVERY;
     isAppliedByCompany: boolean;
+    marketingType: MarketingType.FREE_DELIVERY;
     status?: import("@lyxa.ai/core/dist/utilities/enum").MarketingStatus | undefined;
     spendLimit?: number | undefined;
     isSpendLimitEnabled?: boolean | undefined;

package/dist/types/modules/marketing/validations/marketing.validation.d.ts

@@ -49,9 +49,9 @@ declare const MarketingValidationSchema: z.ZodObject<{
         end?: Date | undefined;
     };
     shop: import("mongoose").Types.ObjectId;
-    marketingType: MarketingType;
     isAppliedByCompany: boolean;
     pausedAt: Date | null;
+    marketingType: MarketingType;
     admin?: import("mongoose").Types.ObjectId | null | undefined;
 }, {
     duration: {
@@ -59,8 +59,8 @@ declare const MarketingValidationSchema: z.ZodObject<{
         end?: string | Date | undefined;
     };
     shop: string | import("mongoose").Types.ObjectId;
-    marketingType: MarketingType;
     isAppliedByCompany: boolean;
+    marketingType: MarketingType;
     status?: MarketingStatus | undefined;
     admin?: string | import("mongoose").Types.ObjectId | null | undefined;
     pausedAt?: string | Date | null | undefined;

package/dist/types/modules/marketing/validations/product-marketing.validation.d.ts

@@ -192,14 +192,14 @@ export declare const BatchCreateProductMarketingsInputSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     shop: import("mongoose").Types.ObjectId;
     categories: import("mongoose").Types.ObjectId[];
+    isEntireMenu: boolean;
     products: {
         product: import("mongoose").Types.ObjectId;
         value?: number | undefined;
         valueType?: ValueType | null | undefined;
     }[];
-    marketingId: import("mongoose").Types.ObjectId;
     isBuy1Get1: boolean;
-    isEntireMenu: boolean;
+    marketingId: import("mongoose").Types.ObjectId;
     value?: number | undefined;
     valueType?: ValueType | undefined;
     isAppliedByCompany?: boolean | undefined;
@@ -207,18 +207,18 @@ export declare const BatchCreateProductMarketingsInputSchema: z.ZodObject<{
     categoryValueType?: ValueType | undefined;
 }, {
     shop: string | import("mongoose").Types.ObjectId;
-    marketingId: string | import("mongoose").Types.ObjectId;
-    isBuy1Get1: boolean;
     isEntireMenu: boolean;
+    isBuy1Get1: boolean;
+    marketingId: string | import("mongoose").Types.ObjectId;
     value?: number | undefined;
     valueType?: ValueType | undefined;
     categories?: (string | import("mongoose").Types.ObjectId)[] | undefined;
+    isAppliedByCompany?: boolean | undefined;
     products?: {
         product: string | import("mongoose").Types.ObjectId;
         value?: number | undefined;
         valueType?: ValueType | null | undefined;
     }[] | undefined;
-    isAppliedByCompany?: boolean | undefined;
     categoryValue?: number | undefined;
     categoryValueType?: ValueType | undefined;
 }>;

package/dist/types/modules/marketing/validations/punch-marketing.validation.d.ts

@@ -107,9 +107,9 @@ declare const PunchMarketingValidationSchema: z.ZodEffects<z.ZodObject<{
         end?: Date | undefined;
     };
     shop: import("mongoose").Types.ObjectId;
-    marketingType: MarketingType.PUNCH_MARKETING;
     isAppliedByCompany: boolean;
     pausedAt: Date | null;
+    marketingType: MarketingType.PUNCH_MARKETING;
     minimumOrderValue: number;
     couponValueType: ValueType;
     couponValue: number;
@@ -123,8 +123,8 @@ declare const PunchMarketingValidationSchema: z.ZodEffects<z.ZodObject<{
         end?: string | Date | undefined;
     };
     shop: string | import("mongoose").Types.ObjectId;
-    marketingType: MarketingType.PUNCH_MARKETING;
     isAppliedByCompany: boolean;
+    marketingType: MarketingType.PUNCH_MARKETING;
     minimumOrderValue: number;
     couponValueType: ValueType;
     couponValue: number;
@@ -141,9 +141,9 @@ declare const PunchMarketingValidationSchema: z.ZodEffects<z.ZodObject<{
         end?: Date | undefined;
     };
     shop: import("mongoose").Types.ObjectId;
-    marketingType: MarketingType.PUNCH_MARKETING;
     isAppliedByCompany: boolean;
     pausedAt: Date | null;
+    marketingType: MarketingType.PUNCH_MARKETING;
     minimumOrderValue: number;
     couponValueType: ValueType;
     couponValue: number;
@@ -157,8 +157,8 @@ declare const PunchMarketingValidationSchema: z.ZodEffects<z.ZodObject<{
         end?: string | Date | undefined;
     };
     shop: string | import("mongoose").Types.ObjectId;
-    marketingType: MarketingType.PUNCH_MARKETING;
     isAppliedByCompany: boolean;
+    marketingType: MarketingType.PUNCH_MARKETING;
     minimumOrderValue: number;
     couponValueType: ValueType;
     couponValue: number;

package/dist/types/modules/punch-marketing-history/routers/punch-marketing-history.router.d.ts

@@ -18,8 +18,8 @@ export declare const punchMarketingHistoryRouter: import("@trpc/server").TRPCBui
         input: {
             user: string | import("mongoose").Types.ObjectId;
             shop: string | import("mongoose").Types.ObjectId;
-            minimumOrderValue: number;
             marketing: string | import("mongoose").Types.ObjectId;
+            minimumOrderValue: number;
             targetOrder: number;
             couponValueType: import("@lyxa.ai/core/dist/utilities/enum").ValueType;
             couponValue: number;

package/dist/types/modules/punch-marketing-history/validations/punch-marketing-history.validation.d.ts

@@ -22,8 +22,8 @@ declare const PunchMarketingHistoryValidationSchema: z.ZodObject<{
 }, "strict", z.ZodTypeAny, {
     user: import("mongoose").Types.ObjectId;
     shop: import("mongoose").Types.ObjectId;
-    minimumOrderValue: number;
     marketing: import("mongoose").Types.ObjectId;
+    minimumOrderValue: number;
     targetOrder: number;
     couponValueType: ValueType;
     couponValue: number;
@@ -37,8 +37,8 @@ declare const PunchMarketingHistoryValidationSchema: z.ZodObject<{
 }, {
     user: string | import("mongoose").Types.ObjectId;
     shop: string | import("mongoose").Types.ObjectId;
-    minimumOrderValue: number;
     marketing: string | import("mongoose").Types.ObjectId;
+    minimumOrderValue: number;
     targetOrder: number;
     couponValueType: ValueType;
     couponValue: number;

package/dist/types/modules/tournament/config/config.builder.d.ts

@@ -0,0 +1,5 @@
+import { UpdateTournamentConfigInputDTO } from './config.validation';
+export declare class TournamentConfigBuilder {
+    static buildUpdate(input: UpdateTournamentConfigInputDTO): Record<string, unknown>;
+}
+//# sourceMappingURL=config.builder.d.ts.map

package/dist/types/modules/tournament/config/config.builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.builder.d.ts","sourceRoot":"/","sources":["modules/tournament/config/config.builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,8BAA8B,EAAE,MAAM,qBAAqB,CAAC;AAErE,qBAAa,uBAAuB;IAChC,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,8BAA8B,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAQrF"}

package/dist/types/modules/tournament/config/config.repository.d.ts

@@ -0,0 +1,13 @@
+import { mongoose } from '@typegoose/typegoose';
+import { Tournament as Model } from '@lyxa.ai/core/dist/libraries/mongo/models';
+export declare class TournamentConfigRepository {
+    private model;
+    constructor();
+    existsByTag(tag: string): Promise<boolean>;
+    create(input: object): Promise<Model>;
+    findById(id: mongoose.Types.ObjectId): Promise<Model | null>;
+    findAll(): Promise<Model[]>;
+    updateById(id: mongoose.Types.ObjectId, updates: object): Promise<Model | null>;
+}
+export declare const tournamentConfigRepository: TournamentConfigRepository;
+//# sourceMappingURL=config.repository.d.ts.map

package/dist/types/modules/tournament/config/config.repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.repository.d.ts","sourceRoot":"/","sources":["modules/tournament/config/config.repository.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,UAAU,IAAI,KAAK,EAAmB,MAAM,2CAA2C,CAAC;AAEjG,qBACa,0BAA0B;IACtC,OAAO,CAAC,KAAK,CAAyB;;IAMhC,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAI1C,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAKrC,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;IAI5D,OAAO,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;IAI3B,UAAU,CAAC,EAAE,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;CAIrF;AAED,eAAO,MAAM,0BAA0B,4BAA4C,CAAC"}

package/dist/types/modules/tournament/config/config.router.d.ts

@@ -0,0 +1,363 @@
+export declare const configRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("@lyxa.ai/core/dist/libraries/trpc/context").LyxaHTTPContext;
+    meta: object;
+    errorShape: {
+        message: string;
+        data: {
+            stack: undefined;
+            path: undefined;
+            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+        };
+        stack: undefined;
+        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    create: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            startDate: string | Date;
+            endDate: string | Date;
+            tag: string;
+            status?: import("@lyxa.ai/core/dist/utilities/enum").Status | undefined;
+        };
+        output: {
+            message: string;
+            success: boolean;
+            data?: {
+                status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                _id: string | import("mongoose").Types.ObjectId;
+                tag: string;
+                createdAt?: Date | null | undefined;
+                startDate?: Date | null | undefined;
+                endDate?: Date | null | undefined;
+                updatedAt?: Date | null | undefined;
+                matches?: {
+                    _id: string | import("mongoose").Types.ObjectId;
+                    team1: {
+                        name: string;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                    };
+                    team2: {
+                        name: string;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                    };
+                    score: {
+                        team1: number | null;
+                        team2: number | null;
+                    };
+                    stage: string;
+                    endDate?: Date | null | undefined;
+                    startingDate?: Date | null | undefined;
+                    additionalTag?: string | undefined;
+                    winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                }[] | undefined;
+                teams?: {
+                    name: string;
+                    _id: string | import("mongoose").Types.ObjectId;
+                    picture?: string | null | undefined;
+                }[] | undefined;
+            } | {
+                documents: {
+                    status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                    _id: string | import("mongoose").Types.ObjectId;
+                    tag: string;
+                    createdAt?: Date | null | undefined;
+                    startDate?: Date | null | undefined;
+                    endDate?: Date | null | undefined;
+                    updatedAt?: Date | null | undefined;
+                    matches?: {
+                        _id: string | import("mongoose").Types.ObjectId;
+                        team1: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                        };
+                        team2: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                        };
+                        score: {
+                            team1: number | null;
+                            team2: number | null;
+                        };
+                        stage: string;
+                        endDate?: Date | null | undefined;
+                        startingDate?: Date | null | undefined;
+                        additionalTag?: string | undefined;
+                        winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                    }[] | undefined;
+                    teams?: {
+                        name: string;
+                        _id: string | import("mongoose").Types.ObjectId;
+                        picture?: string | null | undefined;
+                    }[] | undefined;
+                }[];
+                metadata?: {
+                    page: number;
+                    size: number;
+                    totalElements: number;
+                    totalPages: number;
+                } | undefined;
+            } | undefined;
+        };
+        meta: object;
+    }>;
+    getAll: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            message: string;
+            success: boolean;
+            data?: {
+                status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                _id: string | import("mongoose").Types.ObjectId;
+                tag: string;
+                createdAt?: Date | null | undefined;
+                startDate?: Date | null | undefined;
+                endDate?: Date | null | undefined;
+                updatedAt?: Date | null | undefined;
+                matches?: {
+                    _id: string | import("mongoose").Types.ObjectId;
+                    team1: {
+                        name: string;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                    };
+                    team2: {
+                        name: string;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                    };
+                    score: {
+                        team1: number | null;
+                        team2: number | null;
+                    };
+                    stage: string;
+                    endDate?: Date | null | undefined;
+                    startingDate?: Date | null | undefined;
+                    additionalTag?: string | undefined;
+                    winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                }[] | undefined;
+                teams?: {
+                    name: string;
+                    _id: string | import("mongoose").Types.ObjectId;
+                    picture?: string | null | undefined;
+                }[] | undefined;
+            }[] | {
+                documents: {
+                    status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                    _id: string | import("mongoose").Types.ObjectId;
+                    tag: string;
+                    createdAt?: Date | null | undefined;
+                    startDate?: Date | null | undefined;
+                    endDate?: Date | null | undefined;
+                    updatedAt?: Date | null | undefined;
+                    matches?: {
+                        _id: string | import("mongoose").Types.ObjectId;
+                        team1: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                        };
+                        team2: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                        };
+                        score: {
+                            team1: number | null;
+                            team2: number | null;
+                        };
+                        stage: string;
+                        endDate?: Date | null | undefined;
+                        startingDate?: Date | null | undefined;
+                        additionalTag?: string | undefined;
+                        winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                    }[] | undefined;
+                    teams?: {
+                        name: string;
+                        _id: string | import("mongoose").Types.ObjectId;
+                        picture?: string | null | undefined;
+                    }[] | undefined;
+                }[][];
+                metadata?: {
+                    page: number;
+                    size: number;
+                    totalElements: number;
+                    totalPages: number;
+                } | undefined;
+            } | undefined;
+        };
+        meta: object;
+    }>;
+    getById: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            tournamentId: string | import("mongoose").Types.ObjectId;
+        };
+        output: {
+            message: string;
+            success: boolean;
+            data?: {
+                status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                _id: string | import("mongoose").Types.ObjectId;
+                tag: string;
+                createdAt?: Date | null | undefined;
+                startDate?: Date | null | undefined;
+                endDate?: Date | null | undefined;
+                updatedAt?: Date | null | undefined;
+                matches?: {
+                    _id: string | import("mongoose").Types.ObjectId;
+                    team1: {
+                        name: string;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                    };
+                    team2: {
+                        name: string;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                    };
+                    score: {
+                        team1: number | null;
+                        team2: number | null;
+                    };
+                    stage: string;
+                    endDate?: Date | null | undefined;
+                    startingDate?: Date | null | undefined;
+                    additionalTag?: string | undefined;
+                    winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                }[] | undefined;
+                teams?: {
+                    name: string;
+                    _id: string | import("mongoose").Types.ObjectId;
+                    picture?: string | null | undefined;
+                }[] | undefined;
+            } | {
+                documents: {
+                    status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                    _id: string | import("mongoose").Types.ObjectId;
+                    tag: string;
+                    createdAt?: Date | null | undefined;
+                    startDate?: Date | null | undefined;
+                    endDate?: Date | null | undefined;
+                    updatedAt?: Date | null | undefined;
+                    matches?: {
+                        _id: string | import("mongoose").Types.ObjectId;
+                        team1: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                        };
+                        team2: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                        };
+                        score: {
+                            team1: number | null;
+                            team2: number | null;
+                        };
+                        stage: string;
+                        endDate?: Date | null | undefined;
+                        startingDate?: Date | null | undefined;
+                        additionalTag?: string | undefined;
+                        winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                    }[] | undefined;
+                    teams?: {
+                        name: string;
+                        _id: string | import("mongoose").Types.ObjectId;
+                        picture?: string | null | undefined;
+                    }[] | undefined;
+                }[];
+                metadata?: {
+                    page: number;
+                    size: number;
+                    totalElements: number;
+                    totalPages: number;
+                } | undefined;
+            } | undefined;
+        };
+        meta: object;
+    }>;
+    update: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            _id: string | import("mongoose").Types.ObjectId;
+            status?: import("@lyxa.ai/core/dist/utilities/enum").Status | undefined;
+            startDate?: string | Date | undefined;
+            endDate?: string | Date | undefined;
+            tag?: string | undefined;
+        };
+        output: {
+            message: string;
+            success: boolean;
+            data?: {
+                status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                _id: string | import("mongoose").Types.ObjectId;
+                tag: string;
+                createdAt?: Date | null | undefined;
+                startDate?: Date | null | undefined;
+                endDate?: Date | null | undefined;
+                updatedAt?: Date | null | undefined;
+                matches?: {
+                    _id: string | import("mongoose").Types.ObjectId;
+                    team1: {
+                        name: string;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                    };
+                    team2: {
+                        name: string;
+                        teamId: string | import("mongoose").Types.ObjectId;
+                    };
+                    score: {
+                        team1: number | null;
+                        team2: number | null;
+                    };
+                    stage: string;
+                    endDate?: Date | null | undefined;
+                    startingDate?: Date | null | undefined;
+                    additionalTag?: string | undefined;
+                    winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                }[] | undefined;
+                teams?: {
+                    name: string;
+                    _id: string | import("mongoose").Types.ObjectId;
+                    picture?: string | null | undefined;
+                }[] | undefined;
+            } | {
+                documents: {
+                    status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                    _id: string | import("mongoose").Types.ObjectId;
+                    tag: string;
+                    createdAt?: Date | null | undefined;
+                    startDate?: Date | null | undefined;
+                    endDate?: Date | null | undefined;
+                    updatedAt?: Date | null | undefined;
+                    matches?: {
+                        _id: string | import("mongoose").Types.ObjectId;
+                        team1: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                        };
+                        team2: {
+                            name: string;
+                            teamId: string | import("mongoose").Types.ObjectId;
+                        };
+                        score: {
+                            team1: number | null;
+                            team2: number | null;
+                        };
+                        stage: string;
+                        endDate?: Date | null | undefined;
+                        startingDate?: Date | null | undefined;
+                        additionalTag?: string | undefined;
+                        winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                    }[] | undefined;
+                    teams?: {
+                        name: string;
+                        _id: string | import("mongoose").Types.ObjectId;
+                        picture?: string | null | undefined;
+                    }[] | undefined;
+                }[];
+                metadata?: {
+                    page: number;
+                    size: number;
+                    totalElements: number;
+                    totalPages: number;
+                } | undefined;
+            } | undefined;
+        };
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=config.router.d.ts.map

package/dist/types/modules/tournament/config/config.router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.router.d.ts","sourceRoot":"/","sources":["modules/tournament/config/config.router.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCvB,CAAC"}

package/dist/types/modules/tournament/config/config.service.d.ts

@@ -0,0 +1,14 @@
+import { mongoose } from '@typegoose/typegoose';
+import { CreateTournamentConfigInputDTO, TournamentConfigOutputDTO, UpdateTournamentConfigInputDTO } from './config.validation';
+export declare class TournamentConfigService {
+    private repository;
+    constructor();
+    private ensureTagUnique;
+    private validateDates;
+    create(input: CreateTournamentConfigInputDTO): Promise<TournamentConfigOutputDTO>;
+    getAll(): Promise<TournamentConfigOutputDTO[]>;
+    getById(id: mongoose.Types.ObjectId): Promise<TournamentConfigOutputDTO>;
+    update(input: UpdateTournamentConfigInputDTO): Promise<TournamentConfigOutputDTO>;
+}
+export declare const tournamentConfigService: TournamentConfigService;
+//# sourceMappingURL=config.service.d.ts.map

package/dist/types/modules/tournament/config/config.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.service.d.ts","sourceRoot":"/","sources":["modules/tournament/config/config.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD,OAAO,EACH,8BAA8B,EAC9B,yBAAyB,EACzB,8BAA8B,EACjC,MAAM,qBAAqB,CAAC;AAI7B,qBACa,uBAAuB;IAChC,OAAO,CAAC,UAAU,CAA6B;;YAMjC,eAAe;IAO7B,OAAO,CAAC,aAAa;IAIR,MAAM,CAAC,KAAK,EAAE,8BAA8B,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAKjF,MAAM,IAAI,OAAO,CAAC,yBAAyB,EAAE,CAAC;IAI9C,OAAO,CAAC,EAAE,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAMxE,MAAM,CAAC,KAAK,EAAE,8BAA8B,GAAG,OAAO,CAAC,yBAAyB,CAAC;CAejG;AAED,eAAO,MAAM,uBAAuB,yBAAyC,CAAC"}