@mshowes/brackets-manager 1.8.4 → 1.8.6

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

@@ -0,0 +1,174 @@
+import type { ParticipantResult } from '@/model';
+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;
+        }, {}, {}>;
+        stage_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "stage_id";
+            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;
+        }, {}, {}>;
+        group_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "group_id";
+            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;
+        }, {}, {}>;
+        round_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "round_id";
+            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;
+        }, {}, {}>;
+        child_count: import("drizzle-orm/pg-core").PgColumn<{
+            name: "child_count";
+            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;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            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;
+        }, {}, {}>;
+        opponent1: import("drizzle-orm/pg-core").PgColumn<{
+            name: "opponent1";
+            tableName: "match";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: ParticipantResult | null;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: ParticipantResult | null;
+        }>;
+        opponent2: import("drizzle-orm/pg-core").PgColumn<{
+            name: "opponent2";
+            tableName: "match";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: ParticipantResult | null;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: ParticipantResult | null;
+        }>;
+    };
+    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>;
+    games: import("drizzle-orm").Many<"match_game">;
+}>;
+export type Match = typeof match.$inferSelect;
+export type NewMatch = typeof match.$inferInsert;
+//# sourceMappingURL=match.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"match.d.ts","sourceRoot":"","sources":["../../../../../src/storage/drizzle/db/schema/match.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAGjD,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBhB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;EAcxB,CAAC;AAEJ,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,YAAY,CAAC;AAC9C,MAAM,MAAM,QAAQ,GAAG,OAAO,KAAK,CAAC,YAAY,CAAC"}

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchRelations = exports.match = 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 round_1 = require("./round");
+const match_game_1 = require("./match-game");
+// A match in a round.
+exports.match = (0, pg_core_1.pgTable)('match', {
+    id: (0, pg_core_1.text)('id').primaryKey(),
+    // ID of the parent stage.
+    stage_id: (0, pg_core_1.text)('stage_id')
+        .notNull()
+        .references(() => stage_1.stage.id),
+    // ID of the parent group.
+    group_id: (0, pg_core_1.text)('group_id')
+        .notNull()
+        .references(() => group_1.group.id),
+    // ID of the parent round.
+    round_id: (0, pg_core_1.text)('round_id')
+        .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.
+    child_count: (0, pg_core_1.integer)('child_count').notNull(),
+    // Status of the match (0=Locked, 1=Waiting, 2=Ready, 3=Running, 4=Completed, 5=Archived)
+    status: (0, pg_core_1.integer)('status').notNull(),
+    // First opponent of the match (embedded as JSONB)
+    opponent1: (0, pg_core_1.jsonb)('opponent1').$type(),
+    // Second opponent of the match (embedded as JSONB)
+    opponent2: (0, pg_core_1.jsonb)('opponent2').$type(),
+});
+exports.matchRelations = (0, drizzle_orm_1.relations)(exports.match, ({ one, many }) => ({
+    stage: one(stage_1.stage, {
+        fields: [exports.match.stage_id],
+        references: [stage_1.stage.id],
+    }),
+    group: one(group_1.group, {
+        fields: [exports.match.group_id],
+        references: [group_1.group.id],
+    }),
+    round: one(round_1.round, {
+        fields: [exports.match.round_id],
+        references: [round_1.round.id],
+    }),
+    games: many(match_game_1.matchGame),
+}));
+//# sourceMappingURL=match.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"match.js","sourceRoot":"","sources":["../../../../../src/storage/drizzle/db/schema/match.ts"],"names":[],"mappings":";;;AAAA,iDAAoE;AACpE,6CAAwC;AACxC,mCAAgC;AAChC,mCAAgC;AAChC,mCAAgC;AAChC,6CAAyC;AAGzC,sBAAsB;AACT,QAAA,KAAK,GAAG,IAAA,iBAAO,EAAC,OAAO,EAAE;IAClC,EAAE,EAAE,IAAA,cAAI,EAAC,IAAI,CAAC,CAAC,UAAU,EAAE;IAC3B,0BAA0B;IAC1B,QAAQ,EAAE,IAAA,cAAI,EAAC,UAAU,CAAC;SACrB,OAAO,EAAE;SACT,UAAU,CAAC,GAAG,EAAE,CAAC,aAAK,CAAC,EAAE,CAAC;IAC/B,0BAA0B;IAC1B,QAAQ,EAAE,IAAA,cAAI,EAAC,UAAU,CAAC;SACrB,OAAO,EAAE;SACT,UAAU,CAAC,GAAG,EAAE,CAAC,aAAK,CAAC,EAAE,CAAC;IAC/B,0BAA0B;IAC1B,QAAQ,EAAE,IAAA,cAAI,EAAC,UAAU,CAAC;SACrB,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;IACnC,2CAA2C;IAC3C,WAAW,EAAE,IAAA,iBAAO,EAAC,aAAa,CAAC,CAAC,OAAO,EAAE;IAC7C,yFAAyF;IACzF,MAAM,EAAE,IAAA,iBAAO,EAAC,QAAQ,CAAC,CAAC,OAAO,EAAE;IACnC,kDAAkD;IAClD,SAAS,EAAE,IAAA,eAAK,EAAC,WAAW,CAAC,CAAC,KAAK,EAA4B;IAC/D,mDAAmD;IACnD,SAAS,EAAE,IAAA,eAAK,EAAC,WAAW,CAAC,CAAC,KAAK,EAA4B;CAClE,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,QAAQ,CAAC;QACxB,UAAU,EAAE,CAAC,aAAK,CAAC,EAAE,CAAC;KACzB,CAAC;IACF,KAAK,EAAE,GAAG,CAAC,aAAK,EAAE;QACd,MAAM,EAAE,CAAC,aAAK,CAAC,QAAQ,CAAC;QACxB,UAAU,EAAE,CAAC,aAAK,CAAC,EAAE,CAAC;KACzB,CAAC;IACF,KAAK,EAAE,GAAG,CAAC,aAAK,EAAE;QACd,MAAM,EAAE,CAAC,aAAK,CAAC,QAAQ,CAAC;QACxB,UAAU,EAAE,CAAC,aAAK,CAAC,EAAE,CAAC;KACzB,CAAC;IACF,KAAK,EAAE,IAAI,CAAC,sBAAS,CAAC;CACzB,CAAC,CAAC,CAAC"}

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

@@ -0,0 +1,64 @@
+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;
+        }, {}, {}>;
+        tournament_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tournament_id";
+            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;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const participantRelations: import("drizzle-orm").Relations<"participant", {
+    tournament: import("drizzle-orm").One<"tournament", true>;
+}>;
+export type Participant = typeof participant.$inferSelect;
+export type NewParticipant = typeof participant.$inferInsert;
+//# sourceMappingURL=participant.d.ts.map

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

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

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

@@ -0,0 +1,22 @@
+"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");
+// A participant of a stage (team or individual).
+exports.participant = (0, pg_core_1.pgTable)('participant', {
+    id: (0, pg_core_1.text)('id').primaryKey(),
+    tournament_id: (0, pg_core_1.text)('tournament_id')
+        .notNull()
+        .references(() => tournament_1.tournament.id),
+    // Name of the participant
+    name: (0, pg_core_1.text)('name').notNull(),
+});
+exports.participantRelations = (0, drizzle_orm_1.relations)(exports.participant, ({ one }) => ({
+    tournament: one(tournament_1.tournament, {
+        fields: [exports.participant.tournament_id],
+        references: [tournament_1.tournament.id],
+    }),
+}));
+//# sourceMappingURL=participant.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"participant.js","sourceRoot":"","sources":["../../../../../src/storage/drizzle/db/schema/participant.ts"],"names":[],"mappings":";;;AAAA,iDAAoD;AACpD,6CAAwC;AACxC,6CAA0C;AAE1C,iDAAiD;AACpC,QAAA,WAAW,GAAG,IAAA,iBAAO,EAAC,aAAa,EAAE;IAC9C,EAAE,EAAE,IAAA,cAAI,EAAC,IAAI,CAAC,CAAC,UAAU,EAAE;IAC3B,aAAa,EAAE,IAAA,cAAI,EAAC,eAAe,CAAC;SAC/B,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;CAC/B,CAAC,CAAC;AAEU,QAAA,oBAAoB,GAAG,IAAA,uBAAS,EAAC,mBAAW,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC;IACrE,UAAU,EAAE,GAAG,CAAC,uBAAU,EAAE;QACxB,MAAM,EAAE,CAAC,mBAAW,CAAC,aAAa,CAAC;QACnC,UAAU,EAAE,CAAC,uBAAU,CAAC,EAAE,CAAC;KAC9B,CAAC;CACL,CAAC,CAAC,CAAC"}

package/dist/storage/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;
+        }, {}, {}>;
+        stage_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "stage_id";
+            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;
+        }, {}, {}>;
+        group_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "group_id";
+            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/storage/drizzle/db/schema/round.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"round.d.ts","sourceRoot":"","sources":["../../../../../src/storage/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/storage/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.
+    stage_id: (0, pg_core_1.text)('stage_id')
+        .notNull()
+        .references(() => stage_1.stage.id),
+    // ID of the parent group.
+    group_id: (0, pg_core_1.text)('group_id')
+        .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.stage_id],
+        references: [stage_1.stage.id],
+    }),
+    group: one(group_1.group, {
+        fields: [exports.round.group_id],
+        references: [group_1.group.id],
+    }),
+    matches: many(match_1.match),
+}));
+//# sourceMappingURL=round.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"round.js","sourceRoot":"","sources":["../../../../../src/storage/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,QAAQ,EAAE,IAAA,cAAI,EAAC,UAAU,CAAC;SACrB,OAAO,EAAE;SACT,UAAU,CAAC,GAAG,EAAE,CAAC,aAAK,CAAC,EAAE,CAAC;IAC/B,0BAA0B;IAC1B,QAAQ,EAAE,IAAA,cAAI,EAAC,UAAU,CAAC;SACrB,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,QAAQ,CAAC;QACxB,UAAU,EAAE,CAAC,aAAK,CAAC,EAAE,CAAC;KACzB,CAAC;IACF,KAAK,EAAE,GAAG,CAAC,aAAK,EAAE;QACd,MAAM,EAAE,CAAC,aAAK,CAAC,QAAQ,CAAC;QACxB,UAAU,EAAE,CAAC,aAAK,CAAC,EAAE,CAAC;KACzB,CAAC;IACF,OAAO,EAAE,IAAI,CAAC,aAAK,CAAC;CACvB,CAAC,CAAC,CAAC"}

package/dist/storage/drizzle/db/schema/stage.d.ts

@@ -0,0 +1,143 @@
+export declare const stage: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "stage";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "stage";
+            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;
+        }, {}, {}>;
+        tournament_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tournament_id";
+            tableName: "stage";
+            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: "stage";
+            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;
+        }, {}, {}>;
+        type: import("drizzle-orm/pg-core").PgColumn<{
+            name: "type";
+            tableName: "stage";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "round_robin" | "single_elimination" | "double_elimination";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["round_robin", "single_elimination", "double_elimination"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        number: import("drizzle-orm/pg-core").PgColumn<{
+            name: "number";
+            tableName: "stage";
+            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;
+        }, {}, {}>;
+        settings: import("drizzle-orm/pg-core").PgColumn<{
+            name: "settings";
+            tableName: "stage";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: {
+                size?: number | undefined;
+                seedOrdering?: string[] | undefined;
+                balanceByes?: boolean | undefined;
+                matchesChildCount?: number | undefined;
+                groupCount?: number | undefined;
+                roundRobinMode?: "simple" | "double" | undefined;
+                manualOrdering?: number[][] | undefined;
+                consolationFinal?: boolean | undefined;
+                skipFirstRound?: boolean | undefined;
+                grandFinal?: "none" | "simple" | "double" | undefined;
+            };
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: {
+                size?: number | undefined;
+                seedOrdering?: string[] | undefined;
+                balanceByes?: boolean | undefined;
+                matchesChildCount?: number | undefined;
+                groupCount?: number | undefined;
+                roundRobinMode?: "simple" | "double" | undefined;
+                manualOrdering?: number[][] | undefined;
+                consolationFinal?: boolean | undefined;
+                skipFirstRound?: boolean | undefined;
+                grandFinal?: "none" | "simple" | "double" | undefined;
+            };
+        }>;
+    };
+    dialect: "pg";
+}>;
+export declare const stageRelations: import("drizzle-orm").Relations<"stage", {
+    tournament: import("drizzle-orm").One<"tournament", true>;
+    groups: import("drizzle-orm").Many<"group">;
+    rounds: import("drizzle-orm").Many<"round">;
+    matches: import("drizzle-orm").Many<"match">;
+    matchGames: import("drizzle-orm").Many<"match_game">;
+}>;
+export type Stage = typeof stage.$inferSelect;
+export type NewStage = typeof stage.$inferInsert;
+//# sourceMappingURL=stage.d.ts.map

package/dist/storage/drizzle/db/schema/stage.d.ts.map

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

package/dist/storage/drizzle/db/schema/stage.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stageRelations = exports.stage = void 0;
+const pg_core_1 = require("drizzle-orm/pg-core");
+const drizzle_orm_1 = require("drizzle-orm");
+const enums_1 = require("./enums");
+const tournament_1 = require("./tournament");
+const group_1 = require("./group");
+const round_1 = require("./round");
+const match_1 = require("./match");
+const match_game_1 = require("./match-game");
+// A stage, which can be a round-robin stage or a single/double elimination stage.
+exports.stage = (0, pg_core_1.pgTable)('stage', {
+    id: (0, pg_core_1.text)('id').primaryKey(),
+    tournament_id: (0, pg_core_1.text)('tournament_id')
+        .notNull()
+        .references(() => tournament_1.tournament.id),
+    // Name of the stage
+    name: (0, pg_core_1.text)('name').notNull(),
+    // Type of the stage
+    type: (0, enums_1.stageTypeEnum)('type').notNull(),
+    // The number of the stage in its tournament
+    number: (0, pg_core_1.integer)('number').notNull(),
+    // Settings of the stage (embedded as JSONB to match model)
+    settings: (0, pg_core_1.jsonb)('settings').notNull().$type(),
+});
+exports.stageRelations = (0, drizzle_orm_1.relations)(exports.stage, ({ one, many }) => ({
+    tournament: one(tournament_1.tournament, {
+        fields: [exports.stage.tournament_id],
+        references: [tournament_1.tournament.id],
+    }),
+    groups: many(group_1.group),
+    rounds: many(round_1.round),
+    matches: many(match_1.match),
+    matchGames: many(match_game_1.matchGame),
+}));
+//# sourceMappingURL=stage.js.map

package/dist/storage/drizzle/db/schema/stage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage.js","sourceRoot":"","sources":["../../../../../src/storage/drizzle/db/schema/stage.ts"],"names":[],"mappings":";;;AAAA,iDAAoE;AACpE,6CAAwC;AACxC,mCAAwC;AACxC,6CAA0C;AAC1C,mCAAgC;AAChC,mCAAgC;AAChC,mCAAgC;AAChC,6CAAyC;AAEzC,kFAAkF;AACrE,QAAA,KAAK,GAAG,IAAA,iBAAO,EAAC,OAAO,EAAE;IAClC,EAAE,EAAE,IAAA,cAAI,EAAC,IAAI,CAAC,CAAC,UAAU,EAAE;IAC3B,aAAa,EAAE,IAAA,cAAI,EAAC,eAAe,CAAC;SAC/B,OAAO,EAAE;SACT,UAAU,CAAC,GAAG,EAAE,CAAC,uBAAU,CAAC,EAAE,CAAC;IACpC,oBAAoB;IACpB,IAAI,EAAE,IAAA,cAAI,EAAC,MAAM,CAAC,CAAC,OAAO,EAAE;IAC5B,oBAAoB;IACpB,IAAI,EAAE,IAAA,qBAAa,EAAC,MAAM,CAAC,CAAC,OAAO,EAAE;IACrC,4CAA4C;IAC5C,MAAM,EAAE,IAAA,iBAAO,EAAC,QAAQ,CAAC,CAAC,OAAO,EAAE;IACnC,2DAA2D;IAC3D,QAAQ,EAAE,IAAA,eAAK,EAAC,UAAU,CAAC,CAAC,OAAO,EAAE,CAAC,KAAK,EAWvC;CACP,CAAC,CAAC;AAEU,QAAA,cAAc,GAAG,IAAA,uBAAS,EAAC,aAAK,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;IAC/D,UAAU,EAAE,GAAG,CAAC,uBAAU,EAAE;QACxB,MAAM,EAAE,CAAC,aAAK,CAAC,aAAa,CAAC;QAC7B,UAAU,EAAE,CAAC,uBAAU,CAAC,EAAE,CAAC;KAC9B,CAAC;IACF,MAAM,EAAE,IAAI,CAAC,aAAK,CAAC;IACnB,MAAM,EAAE,IAAI,CAAC,aAAK,CAAC;IACnB,OAAO,EAAE,IAAI,CAAC,aAAK,CAAC;IACpB,UAAU,EAAE,IAAI,CAAC,sBAAS,CAAC;CAC9B,CAAC,CAAC,CAAC"}