@mshowes/brackets-manager 1.8.5 → 1.8.7

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

@@ -0,0 +1,304 @@
+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;
+//# sourceMappingURL=match.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"match.d.ts","sourceRoot":"","sources":["../../../../src/drizzle/db/schema/match.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBhB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;EAwBxB,CAAC;AAGJ,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBjC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;EAkB3C,CAAC;AAEF,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,YAAY,CAAC;AAC9C,MAAM,MAAM,QAAQ,GAAG,OAAO,KAAK,CAAC,YAAY,CAAC;AACjD,MAAM,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,CAAC,YAAY,CAAC;AAChF,MAAM,MAAM,yBAAyB,GACjC,OAAO,sBAAsB,CAAC,YAAY,CAAC"}

package/dist/drizzle/db/schema/match.js

@@ -0,0 +1,95 @@
+"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',
+    }),
+}));
+//# sourceMappingURL=match.js.map

package/dist/drizzle/db/schema/match.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"match.js","sourceRoot":"","sources":["../../../../src/drizzle/db/schema/match.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,83 @@
+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;
+//# sourceMappingURL=participant.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"participant.d.ts","sourceRoot":"","sources":["../../../../src/drizzle/db/schema/participant.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAStB,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;EAO9B,CAAC;AAEJ,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,YAAY,CAAC;AAC1D,MAAM,MAAM,cAAc,GAAG,OAAO,WAAW,CAAC,YAAY,CAAC"}

package/dist/drizzle/db/schema/participant.js

@@ -0,0 +1,28 @@
+"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),
+}));
+//# sourceMappingURL=participant.js.map

package/dist/drizzle/db/schema/participant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"participant.js","sourceRoot":"","sources":["../../../../src/drizzle/db/schema/participant.ts"],"names":[],"mappings":";;;AAAA,iDAA2D;AAC3D,6CAAwC;AACxC,6CAA0C;AAC1C,mCAAiD;AACjD,6CAA0D;AAE1D,iDAAiD;AACpC,QAAA,WAAW,GAAG,IAAA,iBAAO,EAAC,aAAa,EAAE;IAC9C,EAAE,EAAE,IAAA,cAAI,EAAC,IAAI,CAAC,CAAC,UAAU,EAAE;IAC3B,YAAY,EAAE,IAAA,cAAI,EAAC,cAAc,CAAC;SAC7B,OAAO,EAAE;SACT,UAAU,CAAC,GAAG,EAAE,CAAC,uBAAU,CAAC,EAAE,CAAC;IACpC,0BAA0B;IAC1B,IAAI,EAAE,IAAA,cAAI,EAAC,MAAM,CAAC,CAAC,OAAO,EAAE;IAC5B,sCAAsC;IACtC,KAAK,EAAE,IAAA,eAAK,EAAC,OAAO,CAAC;CACxB,CAAC,CAAC;AAEU,QAAA,oBAAoB,GAAG,IAAA,uBAAS,EAAC,mBAAW,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;IAC3E,UAAU,EAAE,GAAG,CAAC,uBAAU,EAAE;QACxB,MAAM,EAAE,CAAC,mBAAW,CAAC,YAAY,CAAC;QAClC,UAAU,EAAE,CAAC,uBAAU,CAAC,EAAE,CAAC;KAC9B,CAAC;IACF,YAAY,EAAE,IAAI,CAAC,8BAAsB,CAAC;IAC1C,gBAAgB,EAAE,IAAI,CAAC,uCAA0B,CAAC;CACrD,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,83 @@
+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;
+//# sourceMappingURL=round.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"round.d.ts","sourceRoot":"","sources":["../../../../src/drizzle/db/schema/round.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYhB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;EAUxB,CAAC;AAEJ,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,YAAY,CAAC;AAC9C,MAAM,MAAM,QAAQ,GAAG,OAAO,KAAK,CAAC,YAAY,CAAC"}

package/dist/drizzle/db/schema/round.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.roundRelations = exports.round = void 0;
+const pg_core_1 = require("drizzle-orm/pg-core");
+const drizzle_orm_1 = require("drizzle-orm");
+const stage_1 = require("./stage");
+const group_1 = require("./group");
+const match_1 = require("./match");
+// A round of a group.
+exports.round = (0, pg_core_1.pgTable)('Round', {
+    id: (0, pg_core_1.text)('id').primaryKey(),
+    // 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),
+    // The number of the round in its group
+    number: (0, pg_core_1.integer)('number').notNull(),
+});
+exports.roundRelations = (0, drizzle_orm_1.relations)(exports.round, ({ one, many }) => ({
+    stage: one(stage_1.stage, {
+        fields: [exports.round.stageId],
+        references: [stage_1.stage.id],
+    }),
+    group: one(group_1.group, {
+        fields: [exports.round.groupId],
+        references: [group_1.group.id],
+    }),
+    matches: many(match_1.match),
+}));
+//# sourceMappingURL=round.js.map

package/dist/drizzle/db/schema/round.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"round.js","sourceRoot":"","sources":["../../../../src/drizzle/db/schema/round.ts"],"names":[],"mappings":";;;AAAA,iDAA6D;AAC7D,6CAAwC;AACxC,mCAAgC;AAChC,mCAAgC;AAChC,mCAAgC;AAEhC,sBAAsB;AACT,QAAA,KAAK,GAAG,IAAA,iBAAO,EAAC,OAAO,EAAE;IAClC,EAAE,EAAE,IAAA,cAAI,EAAC,IAAI,CAAC,CAAC,UAAU,EAAE;IAC3B,0BAA0B;IAC1B,OAAO,EAAE,IAAA,cAAI,EAAC,SAAS,CAAC;SACnB,OAAO,EAAE;SACT,UAAU,CAAC,GAAG,EAAE,CAAC,aAAK,CAAC,EAAE,CAAC;IAC/B,0BAA0B;IAC1B,OAAO,EAAE,IAAA,cAAI,EAAC,SAAS,CAAC;SACnB,OAAO,EAAE;SACT,UAAU,CAAC,GAAG,EAAE,CAAC,aAAK,CAAC,EAAE,CAAC;IAC/B,uCAAuC;IACvC,MAAM,EAAE,IAAA,iBAAO,EAAC,QAAQ,CAAC,CAAC,OAAO,EAAE;CACtC,CAAC,CAAC;AAEU,QAAA,cAAc,GAAG,IAAA,uBAAS,EAAC,aAAK,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;IAC/D,KAAK,EAAE,GAAG,CAAC,aAAK,EAAE;QACd,MAAM,EAAE,CAAC,aAAK,CAAC,OAAO,CAAC;QACvB,UAAU,EAAE,CAAC,aAAK,CAAC,EAAE,CAAC;KACzB,CAAC;IACF,KAAK,EAAE,GAAG,CAAC,aAAK,EAAE;QACd,MAAM,EAAE,CAAC,aAAK,CAAC,OAAO,CAAC;QACvB,UAAU,EAAE,CAAC,aAAK,CAAC,EAAE,CAAC;KACzB,CAAC;IACF,OAAO,EAAE,IAAI,CAAC,aAAK,CAAC;CACvB,CAAC,CAAC,CAAC"}