@lyxa.ai/marketing 1.0.47 → 1.0.49

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;CAUrF"}

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

@@ -0,0 +1,14 @@
+import { mongoose } from '@typegoose/typegoose';
+import { Tournament as Model } from '@lyxa.ai/core/dist/libraries/mongo/models';
+export declare class TournamentConfigRepository {
+    private model;
+    constructor();
+    findActive(): Promise<Pick<Model, 'name' | 'tag' | 'startDate' | 'endDate'> | null>;
+    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;AAGjG,qBACa,0BAA0B;IACtC,OAAO,CAAC,KAAK,CAAyB;;IAMhC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,GAAG,WAAW,GAAG,SAAS,CAAC,GAAG,IAAI,CAAC;IAMnF,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,251 @@
+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: {
+            name: string;
+            startDate: string | Date;
+            endDate: string | Date;
+            tag: string;
+            status?: import("@lyxa.ai/core/dist/utilities/enum").Status | undefined;
+            reward?: {
+                type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
+            } | {
+                type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.COUPON;
+                couponNamePrefix: string;
+                percentage: number;
+                maxDiscountPerOrder?: number | null | undefined;
+            } | undefined;
+        };
+        output: {
+            message: string;
+            success: boolean;
+            data?: {
+                status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                name: string;
+                tag: string;
+                _id?: string | import("mongoose").Types.ObjectId | undefined;
+                createdAt?: Date | null | undefined;
+                startDate?: Date | null | undefined;
+                endDate?: Date | null | undefined;
+                updatedAt?: Date | null | undefined;
+                reward?: {
+                    type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
+                } | {
+                    type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.COUPON;
+                    maxDiscountPerOrder?: number | null | undefined;
+                    couponNamePrefix?: string | undefined;
+                    percentage?: number | undefined;
+                } | undefined;
+            } | {
+                documents: {
+                    status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                    name: string;
+                    tag: string;
+                    _id?: string | import("mongoose").Types.ObjectId | undefined;
+                    createdAt?: Date | null | undefined;
+                    startDate?: Date | null | undefined;
+                    endDate?: Date | null | undefined;
+                    updatedAt?: Date | null | undefined;
+                    reward?: {
+                        type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
+                    } | {
+                        type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.COUPON;
+                        maxDiscountPerOrder?: number | null | undefined;
+                        couponNamePrefix?: string | undefined;
+                        percentage?: number | 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;
+                name: string;
+                tag: string;
+                _id?: string | import("mongoose").Types.ObjectId | undefined;
+                createdAt?: Date | null | undefined;
+                startDate?: Date | null | undefined;
+                endDate?: Date | null | undefined;
+                updatedAt?: Date | null | undefined;
+                reward?: {
+                    type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
+                } | {
+                    type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.COUPON;
+                    maxDiscountPerOrder?: number | null | undefined;
+                    percentage?: number | undefined;
+                } | undefined;
+            }[] | {
+                documents: {
+                    status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                    name: string;
+                    tag: string;
+                    _id?: string | import("mongoose").Types.ObjectId | undefined;
+                    createdAt?: Date | null | undefined;
+                    startDate?: Date | null | undefined;
+                    endDate?: Date | null | undefined;
+                    updatedAt?: Date | null | undefined;
+                    reward?: {
+                        type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
+                    } | {
+                        type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.COUPON;
+                        maxDiscountPerOrder?: number | null | undefined;
+                        percentage?: number | 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;
+                name: string;
+                tag: string;
+                _id?: string | import("mongoose").Types.ObjectId | undefined;
+                createdAt?: Date | null | undefined;
+                startDate?: Date | null | undefined;
+                endDate?: Date | null | undefined;
+                updatedAt?: Date | null | undefined;
+                reward?: {
+                    type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
+                } | {
+                    type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.COUPON;
+                    maxDiscountPerOrder?: number | null | undefined;
+                    couponNamePrefix?: string | undefined;
+                    percentage?: number | undefined;
+                } | undefined;
+            } | {
+                documents: {
+                    status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                    name: string;
+                    tag: string;
+                    _id?: string | import("mongoose").Types.ObjectId | undefined;
+                    createdAt?: Date | null | undefined;
+                    startDate?: Date | null | undefined;
+                    endDate?: Date | null | undefined;
+                    updatedAt?: Date | null | undefined;
+                    reward?: {
+                        type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
+                    } | {
+                        type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.COUPON;
+                        maxDiscountPerOrder?: number | null | undefined;
+                        couponNamePrefix?: string | undefined;
+                        percentage?: number | 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;
+            name?: string | undefined;
+            startDate?: string | Date | undefined;
+            endDate?: string | Date | undefined;
+            tag?: string | undefined;
+            reward?: {
+                type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
+            } | {
+                type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.COUPON;
+                couponNamePrefix: string;
+                percentage: number;
+                maxDiscountPerOrder?: number | null | undefined;
+            } | undefined;
+        };
+        output: {
+            message: string;
+            success: boolean;
+            data?: {
+                status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                name: string;
+                tag: string;
+                _id?: string | import("mongoose").Types.ObjectId | undefined;
+                createdAt?: Date | null | undefined;
+                startDate?: Date | null | undefined;
+                endDate?: Date | null | undefined;
+                updatedAt?: Date | null | undefined;
+                reward?: {
+                    type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
+                } | {
+                    type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.COUPON;
+                    maxDiscountPerOrder?: number | null | undefined;
+                    couponNamePrefix?: string | undefined;
+                    percentage?: number | undefined;
+                } | undefined;
+            } | {
+                documents: {
+                    status: import("@lyxa.ai/core/dist/utilities/enum").Status;
+                    name: string;
+                    tag: string;
+                    _id?: string | import("mongoose").Types.ObjectId | undefined;
+                    createdAt?: Date | null | undefined;
+                    startDate?: Date | null | undefined;
+                    endDate?: Date | null | undefined;
+                    updatedAt?: Date | null | undefined;
+                    reward?: {
+                        type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.FREE_DELIVERY;
+                    } | {
+                        type: import("@lyxa.ai/core/dist/utilities/enum").TournamentRewardType.COUPON;
+                        maxDiscountPerOrder?: number | null | undefined;
+                        couponNamePrefix?: string | undefined;
+                        percentage?: number | 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, TournamentConfigListItemOutputDTO, TournamentConfigOutputDTO, UpdateTournamentConfigInputDTO } from './config.validation';
+export declare class TournamentConfigService {
+    private repository;
+    constructor();
+    private ensureTagUnique;
+    private validateDates;
+    create(input: CreateTournamentConfigInputDTO): Promise<TournamentConfigOutputDTO>;
+    getAll(): Promise<TournamentConfigListItemOutputDTO[]>;
+    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,EAAC,QAAQ,EAAC,MAAM,sBAAsB,CAAC;AAE9C,OAAO,EACH,8BAA8B,EAC9B,iCAAiC,EACjC,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,iCAAiC,EAAE,CAAC;IAItD,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"}