brackets-drizzle-db 2.1.0

package/dist/db/schema/match-game.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.participantMatchGameResultRelations = exports.participantMatchGameResult = exports.matchGameRelations = exports.matchGame = void 0;
+const pg_core_1 = require("drizzle-orm/pg-core");
+const drizzle_orm_1 = require("drizzle-orm");
+const enums_1 = require("./enums");
+const stage_1 = require("./stage");
+const match_1 = require("./match");
+const participant_1 = require("./participant");
+// A game within a match.
+exports.matchGame = (0, pg_core_1.pgTable)('MatchGame', {
+    id: (0, pg_core_1.text)('id').primaryKey(),
+    // Status of the match game.
+    status: (0, enums_1.matchStatusEnum)('status').notNull(),
+    // Additional data for the match game.
+    extra: (0, pg_core_1.jsonb)('extra'),
+    // ID of the parent stage.
+    stageId: (0, pg_core_1.text)('stageId')
+        .notNull()
+        .references(() => stage_1.stage.id),
+    // ID of the parent match.
+    matchId: (0, pg_core_1.text)('matchId')
+        .notNull()
+        .references(() => match_1.match.id),
+    // The number of the match game in its match
+    number: (0, pg_core_1.integer)('number').notNull(),
+});
+exports.matchGameRelations = (0, drizzle_orm_1.relations)(exports.matchGame, ({ one }) => ({
+    stage: one(stage_1.stage, {
+        fields: [exports.matchGame.stageId],
+        references: [stage_1.stage.id],
+    }),
+    match: one(match_1.match, {
+        fields: [exports.matchGame.matchId],
+        references: [match_1.match.id],
+    }),
+    opponent1Result: one(exports.participantMatchGameResult, {
+        fields: [exports.matchGame.id],
+        references: [exports.participantMatchGameResult.opponent1MatchGameId],
+        relationName: 'opponent1',
+    }),
+    opponent2Result: one(exports.participantMatchGameResult, {
+        fields: [exports.matchGame.id],
+        references: [exports.participantMatchGameResult.opponent2MatchGameId],
+        relationName: 'opponent2',
+    }),
+}));
+// The results of a participant in a match game.
+exports.participantMatchGameResult = (0, pg_core_1.pgTable)('ParticipantMatchGameResult', {
+    id: (0, pg_core_1.text)('id').primaryKey(),
+    // If `null`, the participant is to be determined.
+    participantId: (0, pg_core_1.text)('participantId').references(() => participant_1.participant.id),
+    // Indicates where the participant comes from.
+    position: (0, pg_core_1.integer)('position'),
+    // If this participant forfeits, the other automatically wins.
+    forfeit: (0, pg_core_1.boolean)('forfeit'),
+    // The current score of the participant.
+    score: (0, pg_core_1.integer)('score'),
+    // Tells what is the result of a duel for this participant.
+    result: (0, enums_1.matchResultEnum)('result'),
+    // Foreign key for opponent1 relation
+    opponent1MatchGameId: (0, pg_core_1.text)('opponent1MatchGameId').unique(),
+    // Foreign key for opponent2 relation
+    opponent2MatchGameId: (0, pg_core_1.text)('opponent2MatchGameId').unique(),
+});
+exports.participantMatchGameResultRelations = (0, drizzle_orm_1.relations)(exports.participantMatchGameResult, ({ one }) => ({
+    participant: one(participant_1.participant, {
+        fields: [exports.participantMatchGameResult.participantId],
+        references: [participant_1.participant.id],
+    }),
+    opponent1MatchGame: one(exports.matchGame, {
+        fields: [exports.participantMatchGameResult.opponent1MatchGameId],
+        references: [exports.matchGame.id],
+        relationName: 'opponent1',
+    }),
+    opponent2MatchGame: one(exports.matchGame, {
+        fields: [exports.participantMatchGameResult.opponent2MatchGameId],
+        references: [exports.matchGame.id],
+        relationName: 'opponent2',
+    }),
+}));

package/dist/db/schema/match.d.ts

@@ -0,0 +1,303 @@
+export declare const match: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "Match";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "Match";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "Match";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "LOCKED" | "WAITING" | "READY" | "RUNNING" | "COMPLETED" | "ARCHIVED";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["LOCKED", "WAITING", "READY", "RUNNING", "COMPLETED", "ARCHIVED"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        stageId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "stageId";
+            tableName: "Match";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        groupId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "groupId";
+            tableName: "Match";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        roundId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "roundId";
+            tableName: "Match";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        number: import("drizzle-orm/pg-core").PgColumn<{
+            name: "number";
+            tableName: "Match";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        childCount: import("drizzle-orm/pg-core").PgColumn<{
+            name: "childCount";
+            tableName: "Match";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        extra: import("drizzle-orm/pg-core").PgColumn<{
+            name: "extra";
+            tableName: "Match";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const matchRelations: import("drizzle-orm").Relations<"Match", {
+    stage: import("drizzle-orm").One<"Stage", true>;
+    group: import("drizzle-orm").One<"Group", true>;
+    round: import("drizzle-orm").One<"Round", true>;
+    opponent1Result: import("drizzle-orm").One<"ParticipantMatchResult", true>;
+    opponent2Result: import("drizzle-orm").One<"ParticipantMatchResult", true>;
+    games: import("drizzle-orm").Many<"MatchGame">;
+}>;
+export declare const participantMatchResult: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "ParticipantMatchResult";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "ParticipantMatchResult";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        participantId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "participantId";
+            tableName: "ParticipantMatchResult";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        position: import("drizzle-orm/pg-core").PgColumn<{
+            name: "position";
+            tableName: "ParticipantMatchResult";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        forfeit: import("drizzle-orm/pg-core").PgColumn<{
+            name: "forfeit";
+            tableName: "ParticipantMatchResult";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        score: import("drizzle-orm/pg-core").PgColumn<{
+            name: "score";
+            tableName: "ParticipantMatchResult";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        result: import("drizzle-orm/pg-core").PgColumn<{
+            name: "result";
+            tableName: "ParticipantMatchResult";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "WIN" | "DRAW" | "LOSS";
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["WIN", "DRAW", "LOSS"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        opponent1MatchId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "opponent1MatchId";
+            tableName: "ParticipantMatchResult";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        opponent2MatchId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "opponent2MatchId";
+            tableName: "ParticipantMatchResult";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const participantMatchResultRelations: import("drizzle-orm").Relations<"ParticipantMatchResult", {
+    participant: import("drizzle-orm").One<"Participant", false>;
+    opponent1Match: import("drizzle-orm").One<"Match", false>;
+    opponent2Match: import("drizzle-orm").One<"Match", false>;
+}>;
+export type Match = typeof match.$inferSelect;
+export type NewMatch = typeof match.$inferInsert;
+export type ParticipantMatchResult = typeof participantMatchResult.$inferSelect;
+export type NewParticipantMatchResult = typeof participantMatchResult.$inferInsert;

package/dist/db/schema/match.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.participantMatchResultRelations = exports.participantMatchResult = exports.matchRelations = exports.match = void 0;
+const pg_core_1 = require("drizzle-orm/pg-core");
+const drizzle_orm_1 = require("drizzle-orm");
+const enums_1 = require("./enums");
+const stage_1 = require("./stage");
+const group_1 = require("./group");
+const round_1 = require("./round");
+const match_game_1 = require("./match-game");
+const participant_1 = require("./participant");
+// A match in a round.
+exports.match = (0, pg_core_1.pgTable)('Match', {
+    id: (0, pg_core_1.text)('id').primaryKey(),
+    // Status of the match.
+    status: (0, enums_1.matchStatusEnum)('status').notNull(),
+    // ID of the parent stage.
+    stageId: (0, pg_core_1.text)('stageId')
+        .notNull()
+        .references(() => stage_1.stage.id),
+    // ID of the parent group.
+    groupId: (0, pg_core_1.text)('groupId')
+        .notNull()
+        .references(() => group_1.group.id),
+    // ID of the parent round.
+    roundId: (0, pg_core_1.text)('roundId')
+        .notNull()
+        .references(() => round_1.round.id),
+    // The number of the match in its round
+    number: (0, pg_core_1.integer)('number').notNull(),
+    // The count of match games this match has.
+    childCount: (0, pg_core_1.integer)('childCount').notNull(),
+    // Additional data for the match
+    extra: (0, pg_core_1.jsonb)('extra'),
+});
+exports.matchRelations = (0, drizzle_orm_1.relations)(exports.match, ({ one, many }) => ({
+    stage: one(stage_1.stage, {
+        fields: [exports.match.stageId],
+        references: [stage_1.stage.id],
+    }),
+    group: one(group_1.group, {
+        fields: [exports.match.groupId],
+        references: [group_1.group.id],
+    }),
+    round: one(round_1.round, {
+        fields: [exports.match.roundId],
+        references: [round_1.round.id],
+    }),
+    opponent1Result: one(exports.participantMatchResult, {
+        fields: [exports.match.id],
+        references: [exports.participantMatchResult.opponent1MatchId],
+        relationName: 'opponent1',
+    }),
+    opponent2Result: one(exports.participantMatchResult, {
+        fields: [exports.match.id],
+        references: [exports.participantMatchResult.opponent2MatchId],
+        relationName: 'opponent2',
+    }),
+    games: many(match_game_1.matchGame),
+}));
+// The results of a participant in a match.
+exports.participantMatchResult = (0, pg_core_1.pgTable)('ParticipantMatchResult', {
+    id: (0, pg_core_1.text)('id').primaryKey(),
+    // If `null`, the participant is to be determined.
+    participantId: (0, pg_core_1.text)('participantId').references(() => participant_1.participant.id),
+    // Indicates where the participant comes from.
+    position: (0, pg_core_1.integer)('position'),
+    // If this participant forfeits, the other automatically wins.
+    forfeit: (0, pg_core_1.boolean)('forfeit'),
+    // The current score of the participant.
+    score: (0, pg_core_1.integer)('score'),
+    // Tells what is the result of a duel for this participant.
+    result: (0, enums_1.matchResultEnum)('result'),
+    // Foreign key for opponent1 relation
+    opponent1MatchId: (0, pg_core_1.text)('opponent1MatchId').unique(),
+    // Foreign key for opponent2 relation
+    opponent2MatchId: (0, pg_core_1.text)('opponent2MatchId').unique(),
+});
+exports.participantMatchResultRelations = (0, drizzle_orm_1.relations)(exports.participantMatchResult, ({ one }) => ({
+    participant: one(participant_1.participant, {
+        fields: [exports.participantMatchResult.participantId],
+        references: [participant_1.participant.id],
+    }),
+    opponent1Match: one(exports.match, {
+        fields: [exports.participantMatchResult.opponent1MatchId],
+        references: [exports.match.id],
+        relationName: 'opponent1',
+    }),
+    opponent2Match: one(exports.match, {
+        fields: [exports.participantMatchResult.opponent2MatchId],
+        references: [exports.match.id],
+        relationName: 'opponent2',
+    }),
+}));

package/dist/db/schema/participant.d.ts

@@ -0,0 +1,82 @@
+export declare const participant: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "Participant";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "Participant";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        tournamentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tournamentId";
+            tableName: "Participant";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "Participant";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        extra: import("drizzle-orm/pg-core").PgColumn<{
+            name: "extra";
+            tableName: "Participant";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const participantRelations: import("drizzle-orm").Relations<"Participant", {
+    tournament: import("drizzle-orm").One<"Tournament", true>;
+    matchResults: import("drizzle-orm").Many<"ParticipantMatchResult">;
+    matchGameResults: import("drizzle-orm").Many<"ParticipantMatchGameResult">;
+}>;
+export type Participant = typeof participant.$inferSelect;
+export type NewParticipant = typeof participant.$inferInsert;

package/dist/db/schema/participant.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.participantRelations = exports.participant = void 0;
+const pg_core_1 = require("drizzle-orm/pg-core");
+const drizzle_orm_1 = require("drizzle-orm");
+const tournament_1 = require("./tournament");
+const match_1 = require("./match");
+const match_game_1 = require("./match-game");
+// A participant of a stage (team or individual).
+exports.participant = (0, pg_core_1.pgTable)('Participant', {
+    id: (0, pg_core_1.text)('id').primaryKey(),
+    tournamentId: (0, pg_core_1.text)('tournamentId')
+        .notNull()
+        .references(() => tournament_1.tournament.id),
+    // Name of the participant
+    name: (0, pg_core_1.text)('name').notNull(),
+    // Additional data for the participant
+    extra: (0, pg_core_1.jsonb)('extra'),
+});
+exports.participantRelations = (0, drizzle_orm_1.relations)(exports.participant, ({ one, many }) => ({
+    tournament: one(tournament_1.tournament, {
+        fields: [exports.participant.tournamentId],
+        references: [tournament_1.tournament.id],
+    }),
+    matchResults: many(match_1.participantMatchResult),
+    matchGameResults: many(match_game_1.participantMatchGameResult),
+}));

package/dist/db/schema/round.d.ts

@@ -0,0 +1,82 @@
+export declare const round: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "Round";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "Round";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        stageId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "stageId";
+            tableName: "Round";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        groupId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "groupId";
+            tableName: "Round";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        number: import("drizzle-orm/pg-core").PgColumn<{
+            name: "number";
+            tableName: "Round";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const roundRelations: import("drizzle-orm").Relations<"Round", {
+    stage: import("drizzle-orm").One<"Stage", true>;
+    group: import("drizzle-orm").One<"Group", true>;
+    matches: import("drizzle-orm").Many<"Match">;
+}>;
+export type Round = typeof round.$inferSelect;
+export type NewRound = typeof round.$inferInsert;