@lyxa.ai/marketing 1.0.47 → 1.0.49

package/dist/lib/modules/tournament/team/team.validation.d.ts

@@ -0,0 +1,986 @@
+import { z } from 'zod';
+import { DTO } from '@lyxa.ai/core/dist/utilities/validation/global-validation';
+import { Status } from '@lyxa.ai/core/dist/utilities/enum';
+export declare const AddTournamentTeamsSchema: z.ZodObject<{
+    tournamentId: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+    teams: z.ZodArray<z.ZodObject<{
+        name: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+        picture: z.ZodOptional<z.ZodString> | z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        picture?: string | undefined;
+    }, {
+        name: string;
+        picture?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    tournamentId: import("mongoose").Types.ObjectId;
+    teams: {
+        name: string;
+        picture?: string | undefined;
+    }[];
+}, {
+    tournamentId: string | import("mongoose").Types.ObjectId;
+    teams: {
+        name: string;
+        picture?: string | undefined;
+    }[];
+}>;
+export declare const GetTournamentTeamsSchema: z.ZodObject<{
+    tournamentId: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+}, "strip", z.ZodTypeAny, {
+    tournamentId: import("mongoose").Types.ObjectId;
+}, {
+    tournamentId: string | import("mongoose").Types.ObjectId;
+}>;
+export declare const TeamMatchFilterSchema: z.ZodEnum<["upcoming", "completed"]>;
+export declare const GetTeamMatchesSchema: z.ZodObject<{
+    tournamentId: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+    filter: z.ZodEnum<["upcoming", "completed"]>;
+}, "strip", z.ZodTypeAny, {
+    filter: "completed" | "upcoming";
+    tournamentId: import("mongoose").Types.ObjectId;
+}, {
+    filter: "completed" | "upcoming";
+    tournamentId: string | import("mongoose").Types.ObjectId;
+}>;
+declare const TournamentTeamSchema: z.ZodObject<{
+    name: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    picture: z.ZodOptional<z.ZodString> | z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+} & {
+    _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    _id: import("mongoose").Types.ObjectId;
+    picture?: string | undefined;
+}, {
+    name: string;
+    _id: string | import("mongoose").Types.ObjectId;
+    picture?: string | undefined;
+}>;
+export declare const TournamentWithTeamsSchema: z.ZodObject<{
+    tournamentId: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+    tag: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    startDate: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    endDate: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    status: z.ZodNativeEnum<typeof Status>;
+} & {
+    teams: z.ZodArray<z.ZodObject<{
+        name: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+        picture: z.ZodOptional<z.ZodString> | z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+    } & {
+        _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        _id: import("mongoose").Types.ObjectId;
+        picture?: string | undefined;
+    }, {
+        name: string;
+        _id: string | import("mongoose").Types.ObjectId;
+        picture?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    status: Status;
+    tag: string;
+    tournamentId: import("mongoose").Types.ObjectId;
+    teams: {
+        name: string;
+        _id: import("mongoose").Types.ObjectId;
+        picture?: string | undefined;
+    }[];
+    startDate?: Date | null | undefined;
+    endDate?: Date | null | undefined;
+}, {
+    status: Status;
+    tag: string;
+    tournamentId: string | import("mongoose").Types.ObjectId;
+    teams: {
+        name: string;
+        _id: string | import("mongoose").Types.ObjectId;
+        picture?: string | undefined;
+    }[];
+    startDate?: Date | null | undefined;
+    endDate?: Date | null | undefined;
+}>;
+export declare const TournamentWithMatchesSchema: z.ZodObject<{
+    tournamentId: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+    tag: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    startDate: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    endDate: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    status: z.ZodNativeEnum<typeof Status>;
+} & {
+    matches: z.ZodArray<z.ZodObject<{
+        _id: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+        additionalTag: z.ZodOptional<z.ZodString> | z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+        stage: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+        team1: z.ZodObject<{
+            teamId: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+            name: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            teamId: import("mongoose").Types.ObjectId;
+        }, {
+            name: string;
+            teamId: string | import("mongoose").Types.ObjectId;
+        }>;
+        team2: z.ZodObject<{
+            teamId: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>;
+            name: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            teamId: import("mongoose").Types.ObjectId;
+        }, {
+            name: string;
+            teamId: string | import("mongoose").Types.ObjectId;
+        }>;
+        score: z.ZodObject<{
+            team1: z.ZodNullable<z.ZodNumber>;
+            team2: z.ZodNullable<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            team1: number | null;
+            team2: number | null;
+        }, {
+            team1: number | null;
+            team2: number | null;
+        }>;
+        winnerId: z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, import("mongoose").Types.ObjectId, string>, z.ZodType<import("mongoose").Types.ObjectId, z.ZodTypeDef, import("mongoose").Types.ObjectId>]>>>;
+        startingDate: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+        endDate: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    } & {
+        prediction: z.ZodNullable<z.ZodObject<{
+            score: z.ZodObject<{
+                team1: z.ZodNullable<z.ZodNumber>;
+                team2: z.ZodNullable<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                team1: number | null;
+                team2: number | null;
+            }, {
+                team1: number | null;
+                team2: number | null;
+            }>;
+            succeeded: z.ZodNullable<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            succeeded: boolean | null;
+        }, {
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            succeeded: boolean | null;
+        }>>;
+        canPredict: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        _id: import("mongoose").Types.ObjectId;
+        team1: {
+            name: string;
+            teamId: import("mongoose").Types.ObjectId;
+        };
+        team2: {
+            name: string;
+            teamId: import("mongoose").Types.ObjectId;
+        };
+        score: {
+            team1: number | null;
+            team2: number | null;
+        };
+        stage: string;
+        prediction: {
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            succeeded: boolean | null;
+        } | null;
+        canPredict: boolean;
+        endDate?: Date | null | undefined;
+        additionalTag?: string | undefined;
+        winnerId?: import("mongoose").Types.ObjectId | null | undefined;
+        startingDate?: Date | null | undefined;
+    }, {
+        _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;
+        prediction: {
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            succeeded: boolean | null;
+        } | null;
+        canPredict: boolean;
+        endDate?: Date | null | undefined;
+        additionalTag?: string | undefined;
+        winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+        startingDate?: Date | null | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    status: Status;
+    tag: string;
+    tournamentId: import("mongoose").Types.ObjectId;
+    matches: {
+        _id: import("mongoose").Types.ObjectId;
+        team1: {
+            name: string;
+            teamId: import("mongoose").Types.ObjectId;
+        };
+        team2: {
+            name: string;
+            teamId: import("mongoose").Types.ObjectId;
+        };
+        score: {
+            team1: number | null;
+            team2: number | null;
+        };
+        stage: string;
+        prediction: {
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            succeeded: boolean | null;
+        } | null;
+        canPredict: boolean;
+        endDate?: Date | null | undefined;
+        additionalTag?: string | undefined;
+        winnerId?: import("mongoose").Types.ObjectId | null | undefined;
+        startingDate?: Date | null | undefined;
+    }[];
+    startDate?: Date | null | undefined;
+    endDate?: Date | null | undefined;
+}, {
+    status: Status;
+    tag: string;
+    tournamentId: string | import("mongoose").Types.ObjectId;
+    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;
+        prediction: {
+            score: {
+                team1: number | null;
+                team2: number | null;
+            };
+            succeeded: boolean | null;
+        } | null;
+        canPredict: boolean;
+        endDate?: Date | null | undefined;
+        additionalTag?: string | undefined;
+        winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+        startingDate?: Date | null | undefined;
+    }[];
+    startDate?: Date | null | undefined;
+    endDate?: Date | null | undefined;
+}>;
+export declare const TournamentTeamListResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    data: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        metadata: z.ZodOptional<z.ZodObject<{
+            page: z.ZodNumber;
+            size: z.ZodNumber;
+            totalElements: z.ZodNumber;
+            totalPages: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        }, {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        }>>;
+        documents: z.ZodArray<z.ZodType<{
+            name: string;
+            _id: string | import("mongoose").Types.ObjectId;
+            picture?: string | undefined;
+        }[], z.ZodTypeDef, {
+            name: string;
+            _id: string | import("mongoose").Types.ObjectId;
+            picture?: string | undefined;
+        }[]>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        documents: {
+            name: string;
+            _id: string | import("mongoose").Types.ObjectId;
+            picture?: string | undefined;
+        }[][];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    }, {
+        documents: {
+            name: string;
+            _id: string | import("mongoose").Types.ObjectId;
+            picture?: string | undefined;
+        }[][];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    }>, z.ZodType<{
+        name: string;
+        _id: string | import("mongoose").Types.ObjectId;
+        picture?: string | undefined;
+    }[], z.ZodTypeDef, {
+        name: string;
+        _id: string | import("mongoose").Types.ObjectId;
+        picture?: string | undefined;
+    }[]>]>>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    success: boolean;
+    data?: {
+        name: string;
+        _id: string | import("mongoose").Types.ObjectId;
+        picture?: string | undefined;
+    }[] | {
+        documents: {
+            name: string;
+            _id: string | import("mongoose").Types.ObjectId;
+            picture?: string | undefined;
+        }[][];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    } | undefined;
+}, {
+    message: string;
+    success: boolean;
+    data?: {
+        name: string;
+        _id: string | import("mongoose").Types.ObjectId;
+        picture?: string | undefined;
+    }[] | {
+        documents: {
+            name: string;
+            _id: string | import("mongoose").Types.ObjectId;
+            picture?: string | undefined;
+        }[][];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    } | undefined;
+}>;
+export declare const TournamentWithTeamsResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    data: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        metadata: z.ZodOptional<z.ZodObject<{
+            page: z.ZodNumber;
+            size: z.ZodNumber;
+            totalElements: z.ZodNumber;
+            totalPages: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        }, {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        }>>;
+        documents: z.ZodArray<z.ZodType<{
+            status: Status;
+            tag: string;
+            tournamentId: string | import("mongoose").Types.ObjectId;
+            teams: {
+                name: string;
+                _id: string | import("mongoose").Types.ObjectId;
+                picture?: string | undefined;
+            }[];
+            startDate?: Date | null | undefined;
+            endDate?: Date | null | undefined;
+        }, z.ZodTypeDef, {
+            status: Status;
+            tag: string;
+            tournamentId: string | import("mongoose").Types.ObjectId;
+            teams: {
+                name: string;
+                _id: string | import("mongoose").Types.ObjectId;
+                picture?: string | undefined;
+            }[];
+            startDate?: Date | null | undefined;
+            endDate?: Date | null | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        documents: {
+            status: Status;
+            tag: string;
+            tournamentId: string | import("mongoose").Types.ObjectId;
+            teams: {
+                name: string;
+                _id: string | import("mongoose").Types.ObjectId;
+                picture?: string | undefined;
+            }[];
+            startDate?: Date | null | undefined;
+            endDate?: Date | null | undefined;
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    }, {
+        documents: {
+            status: Status;
+            tag: string;
+            tournamentId: string | import("mongoose").Types.ObjectId;
+            teams: {
+                name: string;
+                _id: string | import("mongoose").Types.ObjectId;
+                picture?: string | undefined;
+            }[];
+            startDate?: Date | null | undefined;
+            endDate?: Date | null | undefined;
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    }>, z.ZodType<{
+        status: Status;
+        tag: string;
+        tournamentId: string | import("mongoose").Types.ObjectId;
+        teams: {
+            name: string;
+            _id: string | import("mongoose").Types.ObjectId;
+            picture?: string | undefined;
+        }[];
+        startDate?: Date | null | undefined;
+        endDate?: Date | null | undefined;
+    }, z.ZodTypeDef, {
+        status: Status;
+        tag: string;
+        tournamentId: string | import("mongoose").Types.ObjectId;
+        teams: {
+            name: string;
+            _id: string | import("mongoose").Types.ObjectId;
+            picture?: string | undefined;
+        }[];
+        startDate?: Date | null | undefined;
+        endDate?: Date | null | undefined;
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    success: boolean;
+    data?: {
+        status: Status;
+        tag: string;
+        tournamentId: string | import("mongoose").Types.ObjectId;
+        teams: {
+            name: string;
+            _id: string | import("mongoose").Types.ObjectId;
+            picture?: string | undefined;
+        }[];
+        startDate?: Date | null | undefined;
+        endDate?: Date | null | undefined;
+    } | {
+        documents: {
+            status: Status;
+            tag: string;
+            tournamentId: string | import("mongoose").Types.ObjectId;
+            teams: {
+                name: string;
+                _id: string | import("mongoose").Types.ObjectId;
+                picture?: string | undefined;
+            }[];
+            startDate?: Date | null | undefined;
+            endDate?: Date | null | undefined;
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    } | undefined;
+}, {
+    message: string;
+    success: boolean;
+    data?: {
+        status: Status;
+        tag: string;
+        tournamentId: string | import("mongoose").Types.ObjectId;
+        teams: {
+            name: string;
+            _id: string | import("mongoose").Types.ObjectId;
+            picture?: string | undefined;
+        }[];
+        startDate?: Date | null | undefined;
+        endDate?: Date | null | undefined;
+    } | {
+        documents: {
+            status: Status;
+            tag: string;
+            tournamentId: string | import("mongoose").Types.ObjectId;
+            teams: {
+                name: string;
+                _id: string | import("mongoose").Types.ObjectId;
+                picture?: string | undefined;
+            }[];
+            startDate?: Date | null | undefined;
+            endDate?: Date | null | undefined;
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    } | undefined;
+}>;
+export declare const TournamentWithMatchesResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString | z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    data: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        metadata: z.ZodOptional<z.ZodObject<{
+            page: z.ZodNumber;
+            size: z.ZodNumber;
+            totalElements: z.ZodNumber;
+            totalPages: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        }, {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        }>>;
+        documents: z.ZodArray<z.ZodType<{
+            status: Status;
+            tag: string;
+            tournamentId: string | import("mongoose").Types.ObjectId;
+            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;
+                prediction: {
+                    score: {
+                        team1: number | null;
+                        team2: number | null;
+                    };
+                    succeeded: boolean | null;
+                } | null;
+                canPredict: boolean;
+                endDate?: Date | null | undefined;
+                additionalTag?: string | undefined;
+                winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                startingDate?: Date | null | undefined;
+            }[];
+            startDate?: Date | null | undefined;
+            endDate?: Date | null | undefined;
+        }, z.ZodTypeDef, {
+            status: Status;
+            tag: string;
+            tournamentId: string | import("mongoose").Types.ObjectId;
+            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;
+                prediction: {
+                    score: {
+                        team1: number | null;
+                        team2: number | null;
+                    };
+                    succeeded: boolean | null;
+                } | null;
+                canPredict: boolean;
+                endDate?: Date | null | undefined;
+                additionalTag?: string | undefined;
+                winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                startingDate?: Date | null | undefined;
+            }[];
+            startDate?: Date | null | undefined;
+            endDate?: Date | null | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        documents: {
+            status: Status;
+            tag: string;
+            tournamentId: string | import("mongoose").Types.ObjectId;
+            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;
+                prediction: {
+                    score: {
+                        team1: number | null;
+                        team2: number | null;
+                    };
+                    succeeded: boolean | null;
+                } | null;
+                canPredict: boolean;
+                endDate?: Date | null | undefined;
+                additionalTag?: string | undefined;
+                winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                startingDate?: Date | null | undefined;
+            }[];
+            startDate?: Date | null | undefined;
+            endDate?: Date | null | undefined;
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    }, {
+        documents: {
+            status: Status;
+            tag: string;
+            tournamentId: string | import("mongoose").Types.ObjectId;
+            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;
+                prediction: {
+                    score: {
+                        team1: number | null;
+                        team2: number | null;
+                    };
+                    succeeded: boolean | null;
+                } | null;
+                canPredict: boolean;
+                endDate?: Date | null | undefined;
+                additionalTag?: string | undefined;
+                winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                startingDate?: Date | null | undefined;
+            }[];
+            startDate?: Date | null | undefined;
+            endDate?: Date | null | undefined;
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    }>, z.ZodType<{
+        status: Status;
+        tag: string;
+        tournamentId: string | import("mongoose").Types.ObjectId;
+        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;
+            prediction: {
+                score: {
+                    team1: number | null;
+                    team2: number | null;
+                };
+                succeeded: boolean | null;
+            } | null;
+            canPredict: boolean;
+            endDate?: Date | null | undefined;
+            additionalTag?: string | undefined;
+            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+            startingDate?: Date | null | undefined;
+        }[];
+        startDate?: Date | null | undefined;
+        endDate?: Date | null | undefined;
+    }, z.ZodTypeDef, {
+        status: Status;
+        tag: string;
+        tournamentId: string | import("mongoose").Types.ObjectId;
+        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;
+            prediction: {
+                score: {
+                    team1: number | null;
+                    team2: number | null;
+                };
+                succeeded: boolean | null;
+            } | null;
+            canPredict: boolean;
+            endDate?: Date | null | undefined;
+            additionalTag?: string | undefined;
+            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+            startingDate?: Date | null | undefined;
+        }[];
+        startDate?: Date | null | undefined;
+        endDate?: Date | null | undefined;
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    success: boolean;
+    data?: {
+        status: Status;
+        tag: string;
+        tournamentId: string | import("mongoose").Types.ObjectId;
+        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;
+            prediction: {
+                score: {
+                    team1: number | null;
+                    team2: number | null;
+                };
+                succeeded: boolean | null;
+            } | null;
+            canPredict: boolean;
+            endDate?: Date | null | undefined;
+            additionalTag?: string | undefined;
+            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+            startingDate?: Date | null | undefined;
+        }[];
+        startDate?: Date | null | undefined;
+        endDate?: Date | null | undefined;
+    } | {
+        documents: {
+            status: Status;
+            tag: string;
+            tournamentId: string | import("mongoose").Types.ObjectId;
+            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;
+                prediction: {
+                    score: {
+                        team1: number | null;
+                        team2: number | null;
+                    };
+                    succeeded: boolean | null;
+                } | null;
+                canPredict: boolean;
+                endDate?: Date | null | undefined;
+                additionalTag?: string | undefined;
+                winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                startingDate?: Date | null | undefined;
+            }[];
+            startDate?: Date | null | undefined;
+            endDate?: Date | null | undefined;
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    } | undefined;
+}, {
+    message: string;
+    success: boolean;
+    data?: {
+        status: Status;
+        tag: string;
+        tournamentId: string | import("mongoose").Types.ObjectId;
+        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;
+            prediction: {
+                score: {
+                    team1: number | null;
+                    team2: number | null;
+                };
+                succeeded: boolean | null;
+            } | null;
+            canPredict: boolean;
+            endDate?: Date | null | undefined;
+            additionalTag?: string | undefined;
+            winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+            startingDate?: Date | null | undefined;
+        }[];
+        startDate?: Date | null | undefined;
+        endDate?: Date | null | undefined;
+    } | {
+        documents: {
+            status: Status;
+            tag: string;
+            tournamentId: string | import("mongoose").Types.ObjectId;
+            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;
+                prediction: {
+                    score: {
+                        team1: number | null;
+                        team2: number | null;
+                    };
+                    succeeded: boolean | null;
+                } | null;
+                canPredict: boolean;
+                endDate?: Date | null | undefined;
+                additionalTag?: string | undefined;
+                winnerId?: string | import("mongoose").Types.ObjectId | null | undefined;
+                startingDate?: Date | null | undefined;
+            }[];
+            startDate?: Date | null | undefined;
+            endDate?: Date | null | undefined;
+        }[];
+        metadata?: {
+            page: number;
+            size: number;
+            totalElements: number;
+            totalPages: number;
+        } | undefined;
+    } | undefined;
+}>;
+export type AddTournamentTeamsInputDTO = DTO<typeof AddTournamentTeamsSchema>;
+export type GetTournamentTeamsInputDTO = DTO<typeof GetTournamentTeamsSchema>;
+export type GetTeamMatchesInputDTO = DTO<typeof GetTeamMatchesSchema>;
+export type TournamentTeamOutputDTO = DTO<typeof TournamentTeamSchema>;
+export type TournamentWithTeamsOutputDTO = DTO<typeof TournamentWithTeamsSchema>;
+export type TournamentWithMatchesOutputDTO = DTO<typeof TournamentWithMatchesSchema>;
+export {};
+//# sourceMappingURL=team.validation.d.ts.map