@mshowes/brackets-manager 1.8.5 → 1.8.6

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

@@ -0,0 +1,268 @@
+export declare const matchGame: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "MatchGame";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "MatchGame";
+            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: "MatchGame";
+            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;
+        }, {}, {}>;
+        extra: import("drizzle-orm/pg-core").PgColumn<{
+            name: "extra";
+            tableName: "MatchGame";
+            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;
+        }, {}, {}>;
+        stageId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "stageId";
+            tableName: "MatchGame";
+            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;
+        }, {}, {}>;
+        matchId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "matchId";
+            tableName: "MatchGame";
+            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: "MatchGame";
+            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 matchGameRelations: import("drizzle-orm").Relations<"MatchGame", {
+    stage: import("drizzle-orm").One<"Stage", true>;
+    match: import("drizzle-orm").One<"Match", true>;
+    opponent1Result: import("drizzle-orm").One<"ParticipantMatchGameResult", true>;
+    opponent2Result: import("drizzle-orm").One<"ParticipantMatchGameResult", true>;
+}>;
+export declare const participantMatchGameResult: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "ParticipantMatchGameResult";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "ParticipantMatchGameResult";
+            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: "ParticipantMatchGameResult";
+            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: "ParticipantMatchGameResult";
+            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: "ParticipantMatchGameResult";
+            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: "ParticipantMatchGameResult";
+            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: "ParticipantMatchGameResult";
+            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;
+        }, {}, {}>;
+        opponent1MatchGameId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "opponent1MatchGameId";
+            tableName: "ParticipantMatchGameResult";
+            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;
+        }, {}, {}>;
+        opponent2MatchGameId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "opponent2MatchGameId";
+            tableName: "ParticipantMatchGameResult";
+            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 participantMatchGameResultRelations: import("drizzle-orm").Relations<"ParticipantMatchGameResult", {
+    participant: import("drizzle-orm").One<"Participant", false>;
+    opponent1MatchGame: import("drizzle-orm").One<"MatchGame", false>;
+    opponent2MatchGame: import("drizzle-orm").One<"MatchGame", false>;
+}>;
+export type MatchGame = typeof matchGame.$inferSelect;
+export type NewMatchGame = typeof matchGame.$inferInsert;
+export type ParticipantMatchGameResult = typeof participantMatchGameResult.$inferSelect;
+export type NewParticipantMatchGameResult = typeof participantMatchGameResult.$inferInsert;
+//# sourceMappingURL=match-game.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"match-game.d.ts","sourceRoot":"","sources":["../../../../src/drizzle/db/schema/match-game.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBpB,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;EAmB5B,CAAC;AAGJ,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBtC,CAAC;AAEF,eAAO,MAAM,mCAAmC;;;;EAkB/C,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,YAAY,CAAC;AACtD,MAAM,MAAM,YAAY,GAAG,OAAO,SAAS,CAAC,YAAY,CAAC;AACzD,MAAM,MAAM,0BAA0B,GAClC,OAAO,0BAA0B,CAAC,YAAY,CAAC;AACnD,MAAM,MAAM,6BAA6B,GACrC,OAAO,0BAA0B,CAAC,YAAY,CAAC"}

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

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

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

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

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