@opprs/db-prisma 2.2.0 → 2.2.1-canary.11b4651

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import * as _prisma_client_runtime_library from '@prisma/client/runtime/library';
 import * as _prisma_client from '@prisma/client';
-import { PrismaClient, Player, Prisma, EventBoosterType, Tournament, TournamentResult, User } from '@prisma/client';
-export { EventBoosterType, Player, Prisma, Role, Tournament, TournamentResult, User } from '@prisma/client';
+import { PrismaClient, Player, Prisma, OpprPlayerRanking, OpprRankingChangeType, OpprRankingHistory, EventBoosterType, Tournament, Round, Match, MatchResult, Entry, Standing, User, ApiKey, Location, PostStatus, BlogPost, BlogTag } from '@prisma/client';
+export { Entry, EventBoosterType, Location, Match, MatchResult, OpprPlayerRanking, OpprRankingChangeType, OpprRankingHistory, Player, Prisma, Role, Round, Standing, Tournament, User } from '@prisma/client';
 
 declare const prisma: PrismaClient<_prisma_client.Prisma.PrismaClientOptions, never, _prisma_client_runtime_library.DefaultArgs>;
 /**
@@ -25,24 +25,17 @@ declare function testConnection(): Promise<boolean>;
  */
 interface CreatePlayerInput {
     externalId?: string;
+    playerNumber?: number;
     name?: string;
-    rating?: number;
-    ratingDeviation?: number;
-    ranking?: number;
-    isRated?: boolean;
     eventCount?: number;
+    lastEventDate?: Date;
 }
 /**
  * Input for updating a player
  */
 interface UpdatePlayerInput {
     name?: string;
-    rating?: number;
-    ratingDeviation?: number;
-    ranking?: number;
-    isRated?: boolean;
     eventCount?: number;
-    lastRatingUpdate?: Date;
     lastEventDate?: Date;
 }
 /**
@@ -56,7 +49,7 @@ interface FindPlayersOptions {
     include?: Prisma.PlayerInclude;
 }
 /**
- * Creates a new player
+ * Creates a new player with auto-generated playerNumber
  */
 declare function createPlayer(data: CreatePlayerInput): Promise<Player>;
 /**
@@ -67,6 +60,10 @@ declare function findPlayerById(id: string, include?: Prisma.PlayerInclude): Pro
  * Finds a player by external ID
  */
 declare function findPlayerByExternalId(externalId: string, include?: Prisma.PlayerInclude): Promise<Player | null>;
+/**
+ * Finds a player by player number
+ */
+declare function findPlayerByPlayerNumber(playerNumber: number, include?: Prisma.PlayerInclude): Promise<Player | null>;
 /**
  * Finds a player through their linked User's email
  */
@@ -75,26 +72,10 @@ declare function findPlayerByUserEmail(email: string, include?: Prisma.PlayerInc
  * Finds multiple players with optional filters
  */
 declare function findPlayers(options?: FindPlayersOptions): Promise<Player[]>;
-/**
- * Gets all rated players (has 5+ events)
- */
-declare function getRatedPlayers(options?: Omit<FindPlayersOptions, 'where'>): Promise<Player[]>;
-/**
- * Gets top players by rating
- */
-declare function getTopPlayersByRating(limit?: number): Promise<Player[]>;
-/**
- * Gets top players by ranking
- */
-declare function getTopPlayersByRanking(limit?: number): Promise<Player[]>;
 /**
  * Updates a player
  */
 declare function updatePlayer(id: string, data: UpdatePlayerInput): Promise<Player>;
-/**
- * Updates player rating after a tournament
- */
-declare function updatePlayerRating(id: string, rating: number, ratingDeviation: number, eventCount?: number): Promise<Player>;
 /**
  * Deletes a player
  */
@@ -104,7 +85,7 @@ declare function deletePlayer(id: string): Promise<Player>;
  */
 declare function countPlayers(where?: Prisma.PlayerWhereInput): Promise<number>;
 /**
- * Gets player with their tournament results
+ * Gets player with their tournament standings
  */
 declare function getPlayerWithResults(id: string): Promise<{
     results: ({
@@ -114,8 +95,10 @@ declare function getPlayerWithResults(id: string): Promise<{
             createdAt: Date;
             updatedAt: Date;
             externalId: string | null;
-            location: string | null;
+            description: string | null;
             date: Date;
+            locationId: string | null;
+            organizerId: string | null;
             tgpConfig: Prisma.JsonValue | null;
             eventBooster: _prisma_client.$Enums.EventBoosterType;
             allowsOptOut: boolean;
@@ -131,9 +114,10 @@ declare function getPlayerWithResults(id: string): Promise<{
         id: string;
         createdAt: Date;
         updatedAt: Date;
-        playerId: string;
         tournamentId: string;
+        playerId: string;
         position: number;
+        isFinals: boolean;
         optedOut: boolean;
         linearPoints: number | null;
         dynamicPoints: number | null;
@@ -143,15 +127,17 @@ declare function getPlayerWithResults(id: string): Promise<{
         decayedPoints: number | null;
         efficiency: number | null;
     })[];
-    tournamentResults: ({
+    standings: ({
         tournament: {
             name: string;
             id: string;
             createdAt: Date;
             updatedAt: Date;
             externalId: string | null;
-            location: string | null;
+            description: string | null;
             date: Date;
+            locationId: string | null;
+            organizerId: string | null;
             tgpConfig: Prisma.JsonValue | null;
             eventBooster: _prisma_client.$Enums.EventBoosterType;
             allowsOptOut: boolean;
@@ -167,9 +153,10 @@ declare function getPlayerWithResults(id: string): Promise<{
         id: string;
         createdAt: Date;
         updatedAt: Date;
-        playerId: string;
         tournamentId: string;
+        playerId: string;
         position: number;
+        isFinals: boolean;
         optedOut: boolean;
         linearPoints: number | null;
         dynamicPoints: number | null;
@@ -184,12 +171,8 @@ declare function getPlayerWithResults(id: string): Promise<{
     createdAt: Date;
     updatedAt: Date;
     externalId: string | null;
-    rating: number;
-    ratingDeviation: number;
-    ranking: number | null;
-    isRated: boolean;
+    playerNumber: number;
     eventCount: number;
-    lastRatingUpdate: Date;
     lastEventDate: Date | null;
 } | null>;
 /**
@@ -197,14 +180,151 @@ declare function getPlayerWithResults(id: string): Promise<{
  */
 declare function searchPlayers(query: string, limit?: number): Promise<Player[]>;
 
+/**
+ * Input for creating a new OPPR player ranking
+ */
+interface CreateOpprPlayerRankingInput {
+    playerId: string;
+    rating?: number;
+    ratingDeviation?: number;
+    ranking?: number;
+    isRated?: boolean;
+}
+/**
+ * Input for updating an OPPR player ranking
+ */
+interface UpdateOpprPlayerRankingInput {
+    rating?: number;
+    ratingDeviation?: number;
+    ranking?: number;
+    isRated?: boolean;
+    lastRatingUpdate?: Date;
+}
+/**
+ * Options for querying OPPR rankings
+ */
+interface FindOpprPlayerRankingsOptions {
+    take?: number;
+    skip?: number;
+    orderBy?: Prisma.OpprPlayerRankingOrderByWithRelationInput;
+    where?: Prisma.OpprPlayerRankingWhereInput;
+    include?: Prisma.OpprPlayerRankingInclude;
+}
+/**
+ * Input for creating a ranking history record
+ */
+interface CreateOpprRankingHistoryInput {
+    opprPlayerRankingId: string;
+    rating: number;
+    ratingDeviation: number;
+    ranking?: number;
+    isRated: boolean;
+    changeType: OpprRankingChangeType;
+    tournamentId?: string;
+    notes?: string;
+}
+/**
+ * Gets or creates an OPPR player ranking for a player
+ */
+declare function getOrCreateOpprPlayerRanking(playerId: string): Promise<OpprPlayerRanking>;
+/**
+ * Creates a new OPPR player ranking
+ */
+declare function createOpprPlayerRanking(data: CreateOpprPlayerRankingInput): Promise<OpprPlayerRanking>;
+/**
+ * Finds OPPR ranking by ID
+ */
+declare function findOpprPlayerRankingById(id: string, include?: Prisma.OpprPlayerRankingInclude): Promise<OpprPlayerRanking | null>;
+/**
+ * Finds OPPR ranking by player ID
+ */
+declare function findOpprPlayerRankingByPlayerId(playerId: string, include?: Prisma.OpprPlayerRankingInclude): Promise<OpprPlayerRanking | null>;
+/**
+ * Finds multiple OPPR rankings with optional filters
+ */
+declare function findOpprPlayerRankings(options?: FindOpprPlayerRankingsOptions): Promise<OpprPlayerRanking[]>;
+/**
+ * Gets all rated players ordered by rating (highest first)
+ */
+declare function getTopPlayersByOpprRating(limit?: number): Promise<OpprPlayerRanking[]>;
+/**
+ * Gets all ranked players ordered by world ranking (best first)
+ */
+declare function getTopPlayersByOpprRanking(limit?: number): Promise<OpprPlayerRanking[]>;
+/**
+ * Gets all rated players
+ */
+declare function getRatedOpprPlayers(options?: Omit<FindOpprPlayerRankingsOptions, 'where'>): Promise<OpprPlayerRanking[]>;
+/**
+ * Updates OPPR player ranking
+ */
+declare function updateOpprPlayerRanking(playerId: string, data: UpdateOpprPlayerRankingInput): Promise<OpprPlayerRanking>;
+/**
+ * Updates rating after a tournament and creates history record
+ */
+declare function updateOpprRatingAfterTournament(playerId: string, newRating: number, newRD: number, tournamentId: string, eventCount?: number): Promise<OpprPlayerRanking>;
+/**
+ * Updates world rankings for all players (batch operation)
+ */
+declare function updateWorldRankings(rankings: Array<{
+    playerId: string;
+    ranking: number;
+}>): Promise<void>;
+/**
+ * Applies RD decay for inactive players
+ */
+declare function applyRDDecayForInactivePlayers(thresholdDays?: number, decayPerDay?: number, maxRD?: number): Promise<number>;
+/**
+ * Deletes OPPR player ranking (cascades to history)
+ */
+declare function deleteOpprPlayerRanking(playerId: string): Promise<OpprPlayerRanking>;
+/**
+ * Counts OPPR rankings
+ */
+declare function countOpprPlayerRankings(where?: Prisma.OpprPlayerRankingWhereInput): Promise<number>;
+/**
+ * Creates a ranking history record
+ */
+declare function createOpprRankingHistory(data: CreateOpprRankingHistoryInput): Promise<OpprRankingHistory>;
+/**
+ * Gets ranking history for a player
+ */
+declare function getOpprRankingHistory(playerId: string, limit?: number): Promise<OpprRankingHistory[]>;
+/**
+ * Gets ranking history for a specific time period
+ */
+declare function getOpprRankingHistoryByDateRange(playerId: string, startDate: Date, endDate: Date): Promise<OpprRankingHistory[]>;
+/**
+ * Gets the most recent history record for a player
+ */
+declare function getLatestOpprRankingHistory(playerId: string): Promise<OpprRankingHistory | null>;
+/**
+ * Counts ranking history records
+ */
+declare function countOpprRankingHistory(where?: Prisma.OpprRankingHistoryWhereInput): Promise<number>;
+
+/**
+ * Generates a unique player number with collision handling.
+ * Retries up to MAX_RETRIES times if collision occurs.
+ *
+ * @throws Error if unable to generate unique number after max retries
+ */
+declare function generateUniquePlayerNumber(): Promise<number>;
+/**
+ * Validates that a player number is in the valid range
+ */
+declare function isValidPlayerNumber(playerNumber: number): boolean;
+
 /**
  * Input for creating a new tournament
  */
 interface CreateTournamentInput {
     externalId?: string;
     name: string;
-    location?: string;
+    description?: string;
     date: Date;
+    locationId?: string;
+    organizerId?: string;
     tgpConfig?: Prisma.InputJsonValue;
     eventBooster?: EventBoosterType;
     allowsOptOut?: boolean;
@@ -221,8 +341,10 @@ interface CreateTournamentInput {
  */
 interface UpdateTournamentInput {
     name?: string;
-    location?: string;
+    description?: string | null;
     date?: Date;
+    locationId?: string | null;
+    organizerId?: string | null;
     tgpConfig?: Prisma.InputJsonValue;
     eventBooster?: EventBoosterType;
     allowsOptOut?: boolean;
@@ -289,31 +411,28 @@ declare function deleteTournament(id: string): Promise<Tournament>;
  */
 declare function countTournaments(where?: Prisma.TournamentWhereInput): Promise<number>;
 /**
- * Gets tournament with all results and player details
+ * Gets tournament with all standings and player details
  */
 declare function getTournamentWithResults(id: string): Promise<({
-    results: ({
+    standings: ({
         player: {
             name: string | null;
             id: string;
             createdAt: Date;
             updatedAt: Date;
             externalId: string | null;
-            rating: number;
-            ratingDeviation: number;
-            ranking: number | null;
-            isRated: boolean;
+            playerNumber: number;
             eventCount: number;
-            lastRatingUpdate: Date;
             lastEventDate: Date | null;
         };
     } & {
         id: string;
         createdAt: Date;
         updatedAt: Date;
-        playerId: string;
         tournamentId: string;
+        playerId: string;
         position: number;
+        isFinals: boolean;
         optedOut: boolean;
         linearPoints: number | null;
         dynamicPoints: number | null;
@@ -329,8 +448,75 @@ declare function getTournamentWithResults(id: string): Promise<({
     createdAt: Date;
     updatedAt: Date;
     externalId: string | null;
-    location: string | null;
+    description: string | null;
+    date: Date;
+    locationId: string | null;
+    organizerId: string | null;
+    tgpConfig: Prisma.JsonValue | null;
+    eventBooster: _prisma_client.$Enums.EventBoosterType;
+    allowsOptOut: boolean;
+    baseValue: number | null;
+    tvaRating: number | null;
+    tvaRanking: number | null;
+    totalTVA: number | null;
+    tgp: number | null;
+    eventBoosterMultiplier: number | null;
+    firstPlaceValue: number | null;
+}) | null>;
+/**
+ * Gets tournament with rounds, matches, and entries
+ */
+declare function getTournamentWithMatches(id: string): Promise<({
+    rounds: ({
+        matches: ({
+            entries: ({
+                player: {
+                    name: string | null;
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    externalId: string | null;
+                    playerNumber: number;
+                    eventCount: number;
+                    lastEventDate: Date | null;
+                };
+            } & {
+                result: _prisma_client.$Enums.MatchResult;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                playerId: string;
+                position: number | null;
+                matchId: string;
+            })[];
+        } & {
+            number: number | null;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            tournamentId: string;
+            roundId: string | null;
+            machineName: string | null;
+        })[];
+    } & {
+        number: number;
+        name: string | null;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        tournamentId: string;
+        isFinals: boolean;
+    })[];
+} & {
+    name: string;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    externalId: string | null;
+    description: string | null;
     date: Date;
+    locationId: string | null;
+    organizerId: string | null;
     tgpConfig: Prisma.JsonValue | null;
     eventBooster: _prisma_client.$Enums.EventBoosterType;
     allowsOptOut: boolean;
@@ -343,7 +529,7 @@ declare function getTournamentWithResults(id: string): Promise<({
     firstPlaceValue: number | null;
 }) | null>;
 /**
- * Searches tournaments by name or location
+ * Searches tournaments by name or location name
  */
 declare function searchTournaments(query: string, limit?: number): Promise<Tournament[]>;
 /**
@@ -351,28 +537,25 @@ declare function searchTournaments(query: string, limit?: number): Promise<Tourn
  */
 declare function getTournamentStats(id: string): Promise<{
     tournament: {
-        results: ({
+        standings: ({
             player: {
                 name: string | null;
                 id: string;
                 createdAt: Date;
                 updatedAt: Date;
                 externalId: string | null;
-                rating: number;
-                ratingDeviation: number;
-                ranking: number | null;
-                isRated: boolean;
+                playerNumber: number;
                 eventCount: number;
-                lastRatingUpdate: Date;
                 lastEventDate: Date | null;
             };
         } & {
             id: string;
             createdAt: Date;
             updatedAt: Date;
-            playerId: string;
             tournamentId: string;
+            playerId: string;
             position: number;
+            isFinals: boolean;
             optedOut: boolean;
             linearPoints: number | null;
             dynamicPoints: number | null;
@@ -388,8 +571,10 @@ declare function getTournamentStats(id: string): Promise<{
         createdAt: Date;
         updatedAt: Date;
         externalId: string | null;
-        location: string | null;
+        description: string | null;
         date: Date;
+        locationId: string | null;
+        organizerId: string | null;
         tgpConfig: Prisma.JsonValue | null;
         eventBooster: _prisma_client.$Enums.EventBoosterType;
         allowsOptOut: boolean;
@@ -409,12 +594,342 @@ declare function getTournamentStats(id: string): Promise<{
 } | null>;
 
 /**
- * Input for creating a tournament result
+ * Input for creating a new round
+ */
+interface CreateRoundInput {
+    tournamentId: string;
+    number: number;
+    name?: string;
+    isFinals?: boolean;
+}
+/**
+ * Input for updating a round
+ */
+interface UpdateRoundInput {
+    number?: number;
+    name?: string;
+    isFinals?: boolean;
+}
+/**
+ * Options for querying rounds
+ */
+interface FindRoundsOptions {
+    take?: number;
+    skip?: number;
+    orderBy?: Prisma.RoundOrderByWithRelationInput | Prisma.RoundOrderByWithRelationInput[];
+    where?: Prisma.RoundWhereInput;
+    include?: Prisma.RoundInclude;
+}
+/**
+ * Creates a new round
+ */
+declare function createRound(data: CreateRoundInput): Promise<Round>;
+/**
+ * Creates multiple rounds at once
+ */
+declare function createManyRounds(data: CreateRoundInput[]): Promise<Prisma.BatchPayload>;
+/**
+ * Finds a round by ID
  */
-interface CreateResultInput {
+declare function findRoundById(id: string, include?: Prisma.RoundInclude): Promise<Round | null>;
+/**
+ * Finds a round by tournament, number, and isFinals
+ */
+declare function findRoundByTournamentAndNumber(tournamentId: string, number: number, isFinals: boolean, include?: Prisma.RoundInclude): Promise<Round | null>;
+/**
+ * Finds multiple rounds with optional filters
+ */
+declare function findRounds(options?: FindRoundsOptions): Promise<Round[]>;
+/**
+ * Gets all rounds for a specific tournament
+ */
+declare function getTournamentRounds(tournamentId: string, options?: Omit<FindRoundsOptions, 'where'>): Promise<Round[]>;
+/**
+ * Gets qualifying rounds for a tournament
+ */
+declare function getQualifyingRounds(tournamentId: string, options?: Omit<FindRoundsOptions, 'where'>): Promise<Round[]>;
+/**
+ * Gets finals rounds for a tournament
+ */
+declare function getFinalsRounds(tournamentId: string, options?: Omit<FindRoundsOptions, 'where'>): Promise<Round[]>;
+/**
+ * Updates a round
+ */
+declare function updateRound(id: string, data: UpdateRoundInput): Promise<Round>;
+/**
+ * Deletes a round
+ */
+declare function deleteRound(id: string): Promise<Round>;
+/**
+ * Deletes all rounds for a tournament
+ */
+declare function deleteRoundsByTournament(tournamentId: string): Promise<Prisma.BatchPayload>;
+/**
+ * Counts total rounds
+ */
+declare function countRounds(where?: Prisma.RoundWhereInput): Promise<number>;
+/**
+ * Gets a round with all its matches
+ */
+declare function getRoundWithMatches(id: string): Promise<({
+    matches: ({
+        entries: ({
+            player: {
+                name: string | null;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                externalId: string | null;
+                playerNumber: number;
+                eventCount: number;
+                lastEventDate: Date | null;
+            };
+        } & {
+            result: _prisma_client.$Enums.MatchResult;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            playerId: string;
+            position: number | null;
+            matchId: string;
+        })[];
+    } & {
+        number: number | null;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        tournamentId: string;
+        roundId: string | null;
+        machineName: string | null;
+    })[];
+} & {
+    number: number;
+    name: string | null;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    tournamentId: string;
+    isFinals: boolean;
+}) | null>;
+
+/**
+ * Input for creating a new match
+ */
+interface CreateMatchInput {
+    tournamentId: string;
+    roundId?: string;
+    number?: number;
+    machineName?: string;
+}
+/**
+ * Input for updating a match
+ */
+interface UpdateMatchInput {
+    roundId?: string | null;
+    number?: number;
+    machineName?: string;
+}
+/**
+ * Options for querying matches
+ */
+interface FindMatchesOptions {
+    take?: number;
+    skip?: number;
+    orderBy?: Prisma.MatchOrderByWithRelationInput | Prisma.MatchOrderByWithRelationInput[];
+    where?: Prisma.MatchWhereInput;
+    include?: Prisma.MatchInclude;
+}
+/**
+ * Creates a new match
+ */
+declare function createMatch(data: CreateMatchInput): Promise<Match>;
+/**
+ * Creates multiple matches at once
+ */
+declare function createManyMatches(data: CreateMatchInput[]): Promise<Prisma.BatchPayload>;
+/**
+ * Finds a match by ID
+ */
+declare function findMatchById(id: string, include?: Prisma.MatchInclude): Promise<Match | null>;
+/**
+ * Finds multiple matches with optional filters
+ */
+declare function findMatches(options?: FindMatchesOptions): Promise<Match[]>;
+/**
+ * Gets all matches for a specific tournament
+ */
+declare function getTournamentMatches(tournamentId: string, options?: Omit<FindMatchesOptions, 'where'>): Promise<Match[]>;
+/**
+ * Gets all matches for a specific round
+ */
+declare function getRoundMatches(roundId: string, options?: Omit<FindMatchesOptions, 'where'>): Promise<Match[]>;
+/**
+ * Updates a match
+ */
+declare function updateMatch(id: string, data: UpdateMatchInput): Promise<Match>;
+/**
+ * Deletes a match
+ */
+declare function deleteMatch(id: string): Promise<Match>;
+/**
+ * Deletes all matches for a tournament
+ */
+declare function deleteMatchesByTournament(tournamentId: string): Promise<Prisma.BatchPayload>;
+/**
+ * Deletes all matches for a round
+ */
+declare function deleteMatchesByRound(roundId: string): Promise<Prisma.BatchPayload>;
+/**
+ * Counts total matches
+ */
+declare function countMatches(where?: Prisma.MatchWhereInput): Promise<number>;
+/**
+ * Gets a match with all its entries and player details
+ */
+declare function getMatchWithEntries(id: string): Promise<({
+    round: {
+        number: number;
+        name: string | null;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        tournamentId: string;
+        isFinals: boolean;
+    } | null;
+    entries: ({
+        player: {
+            name: string | null;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            externalId: string | null;
+            playerNumber: number;
+            eventCount: number;
+            lastEventDate: Date | null;
+        };
+    } & {
+        result: _prisma_client.$Enums.MatchResult;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        playerId: string;
+        position: number | null;
+        matchId: string;
+    })[];
+} & {
+    number: number | null;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    tournamentId: string;
+    roundId: string | null;
+    machineName: string | null;
+}) | null>;
+/**
+ * Gets matches for a player in a tournament
+ */
+declare function getPlayerTournamentMatches(playerId: string, tournamentId: string, include?: Prisma.MatchInclude): Promise<Match[]>;
+
+/**
+ * Input for creating a new entry
+ */
+interface CreateEntryInput {
+    matchId: string;
     playerId: string;
+    result: MatchResult;
+    position?: number;
+}
+/**
+ * Input for updating an entry
+ */
+interface UpdateEntryInput {
+    result?: MatchResult;
+    position?: number;
+}
+/**
+ * Options for querying entries
+ */
+interface FindEntriesOptions {
+    take?: number;
+    skip?: number;
+    orderBy?: Prisma.EntryOrderByWithRelationInput;
+    where?: Prisma.EntryWhereInput;
+    include?: Prisma.EntryInclude;
+}
+/**
+ * Creates a new entry
+ */
+declare function createEntry(data: CreateEntryInput): Promise<Entry>;
+/**
+ * Creates multiple entries at once
+ */
+declare function createManyEntries(data: CreateEntryInput[]): Promise<Prisma.BatchPayload>;
+/**
+ * Finds an entry by ID
+ */
+declare function findEntryById(id: string, include?: Prisma.EntryInclude): Promise<Entry | null>;
+/**
+ * Finds an entry by match and player
+ */
+declare function findEntryByMatchAndPlayer(matchId: string, playerId: string, include?: Prisma.EntryInclude): Promise<Entry | null>;
+/**
+ * Finds multiple entries with optional filters
+ */
+declare function findEntries(options?: FindEntriesOptions): Promise<Entry[]>;
+/**
+ * Gets all entries for a specific match
+ */
+declare function getMatchEntries(matchId: string, options?: Omit<FindEntriesOptions, 'where'>): Promise<Entry[]>;
+/**
+ * Gets all entries for a specific player
+ */
+declare function getPlayerEntries(playerId: string, options?: Omit<FindEntriesOptions, 'where'>): Promise<Entry[]>;
+/**
+ * Gets player entries in a tournament
+ */
+declare function getPlayerTournamentEntries(playerId: string, tournamentId: string, include?: Prisma.EntryInclude): Promise<Entry[]>;
+/**
+ * Updates an entry
+ */
+declare function updateEntry(id: string, data: UpdateEntryInput): Promise<Entry>;
+/**
+ * Deletes an entry
+ */
+declare function deleteEntry(id: string): Promise<Entry>;
+/**
+ * Deletes all entries for a match
+ */
+declare function deleteEntriesByMatch(matchId: string): Promise<Prisma.BatchPayload>;
+/**
+ * Counts total entries
+ */
+declare function countEntries(where?: Prisma.EntryWhereInput): Promise<number>;
+/**
+ * Gets player statistics from entries
+ */
+declare function getPlayerEntryStats(playerId: string): Promise<{
+    totalMatches: number;
+    wins: number;
+    losses: number;
+    ties: number;
+    winRate: number;
+} | null>;
+
+/**
+ * Merged standing with calculated position for points
+ */
+interface MergedStanding extends Standing {
+    mergedPosition: number;
+    isFinalist: boolean;
+}
+/**
+ * Input for creating a new standing
+ */
+interface CreateStandingInput {
     tournamentId: string;
+    playerId: string;
     position: number;
+    isFinals?: boolean;
     optedOut?: boolean;
     linearPoints?: number;
     dynamicPoints?: number;
@@ -425,9 +940,9 @@ interface CreateResultInput {
     efficiency?: number;
 }
 /**
- * Input for updating a tournament result
+ * Input for updating a standing
  */
-interface UpdateResultInput {
+interface UpdateStandingInput {
     position?: number;
     optedOut?: boolean;
     linearPoints?: number;
@@ -439,67 +954,80 @@ interface UpdateResultInput {
     efficiency?: number;
 }
 /**
- * Options for querying results
+ * Options for querying standings
  */
-interface FindResultsOptions {
+interface FindStandingsOptions {
     take?: number;
     skip?: number;
-    orderBy?: Prisma.TournamentResultOrderByWithRelationInput;
-    where?: Prisma.TournamentResultWhereInput;
-    include?: Prisma.TournamentResultInclude;
+    orderBy?: Prisma.StandingOrderByWithRelationInput;
+    where?: Prisma.StandingWhereInput;
+    include?: Prisma.StandingInclude;
 }
 /**
- * Creates a new tournament result
+ * Creates a new standing
+ */
+declare function createStanding(data: CreateStandingInput): Promise<Standing>;
+/**
+ * Creates multiple standings at once
+ */
+declare function createManyStandings(data: CreateStandingInput[]): Promise<Prisma.BatchPayload>;
+/**
+ * Finds a standing by ID
+ */
+declare function findStandingById(id: string, include?: Prisma.StandingInclude): Promise<Standing | null>;
+/**
+ * Finds a standing by player, tournament, and isFinals
  */
-declare function createResult(data: CreateResultInput): Promise<TournamentResult>;
+declare function findStandingByPlayerAndTournament(playerId: string, tournamentId: string, isFinals: boolean, include?: Prisma.StandingInclude): Promise<Standing | null>;
 /**
- * Creates multiple tournament results at once
+ * Finds multiple standings with optional filters
  */
-declare function createManyResults(data: CreateResultInput[]): Promise<Prisma.BatchPayload>;
+declare function findStandings(options?: FindStandingsOptions): Promise<Standing[]>;
 /**
- * Finds a result by ID
+ * Gets all standings for a specific player
  */
-declare function findResultById(id: string, include?: Prisma.TournamentResultInclude): Promise<TournamentResult | null>;
+declare function getPlayerStandings(playerId: string, options?: Omit<FindStandingsOptions, 'where'>): Promise<Standing[]>;
 /**
- * Finds a result by player and tournament
+ * Gets all standings for a specific tournament
  */
-declare function findResultByPlayerAndTournament(playerId: string, tournamentId: string, include?: Prisma.TournamentResultInclude): Promise<TournamentResult | null>;
+declare function getTournamentStandings(tournamentId: string, options?: Omit<FindStandingsOptions, 'where'>): Promise<Standing[]>;
 /**
- * Finds multiple results with optional filters
+ * Gets qualifying standings for a tournament
  */
-declare function findResults(options?: FindResultsOptions): Promise<TournamentResult[]>;
+declare function getQualifyingStandings(tournamentId: string, options?: Omit<FindStandingsOptions, 'where'>): Promise<Standing[]>;
 /**
- * Gets all results for a specific player
+ * Gets finals standings for a tournament
  */
-declare function getPlayerResults(playerId: string, options?: Omit<FindResultsOptions, 'where'>): Promise<TournamentResult[]>;
+declare function getFinalsStandings(tournamentId: string, options?: Omit<FindStandingsOptions, 'where'>): Promise<Standing[]>;
 /**
- * Gets all results for a specific tournament
+ * Gets merged standings for point calculation.
+ * Finalists get their finals position, non-finalists get qualifying position + finalist count
  */
-declare function getTournamentResults(tournamentId: string, options?: Omit<FindResultsOptions, 'where'>): Promise<TournamentResult[]>;
+declare function getMergedStandings(tournamentId: string): Promise<MergedStanding[]>;
 /**
  * Gets top N finishes for a player
  */
-declare function getPlayerTopFinishes(playerId: string, limit?: number): Promise<TournamentResult[]>;
+declare function getPlayerTopFinishes(playerId: string, limit?: number): Promise<Standing[]>;
 /**
- * Updates a tournament result
+ * Updates a standing
  */
-declare function updateResult(id: string, data: UpdateResultInput): Promise<TournamentResult>;
+declare function updateStanding(id: string, data: UpdateStandingInput): Promise<Standing>;
 /**
- * Updates result points and decay information
+ * Updates standing points and decay information
  */
-declare function updateResultPoints(id: string, linearPoints: number, dynamicPoints: number, totalPoints: number): Promise<TournamentResult>;
+declare function updateStandingPoints(id: string, linearPoints: number, dynamicPoints: number, totalPoints: number): Promise<Standing>;
 /**
- * Deletes a tournament result
+ * Deletes a standing
  */
-declare function deleteResult(id: string): Promise<TournamentResult>;
+declare function deleteStanding(id: string): Promise<Standing>;
 /**
- * Deletes all results for a tournament
+ * Deletes all standings for a tournament
  */
-declare function deleteResultsByTournament(tournamentId: string): Promise<Prisma.BatchPayload>;
+declare function deleteStandingsByTournament(tournamentId: string): Promise<Prisma.BatchPayload>;
 /**
- * Counts total results
+ * Counts total standings
  */
-declare function countResults(where?: Prisma.TournamentResultWhereInput): Promise<number>;
+declare function countStandings(where?: Prisma.StandingWhereInput): Promise<number>;
 /**
  * Gets player statistics across all tournaments
  */
@@ -517,7 +1045,7 @@ declare function getPlayerStats(playerId: string): Promise<{
     highestPoints: number;
 } | null>;
 /**
- * Calculates and updates time decay for all results
+ * Calculates and updates time decay for all standings
  * Based on OPPR time decay rules:
  * - 0-1 years: 100%
  * - 1-2 years: 75%
@@ -528,9 +1056,10 @@ declare function recalculateTimeDecay(referenceDate?: Date): Promise<{
     id: string;
     createdAt: Date;
     updatedAt: Date;
-    playerId: string;
     tournamentId: string;
+    playerId: string;
     position: number;
+    isFinals: boolean;
     optedOut: boolean;
     linearPoints: number | null;
     dynamicPoints: number | null;
@@ -549,6 +1078,9 @@ interface CreateUserInput {
     passwordHash: string;
     playerId?: string;
     role?: 'USER' | 'ADMIN';
+    tosAcceptedAt?: Date;
+    privacyPolicyAcceptedAt?: Date;
+    codeOfConductAcceptedAt?: Date;
 }
 /**
  * Input for updating a user
@@ -569,13 +1101,13 @@ interface UserWithPlayer {
     role: 'USER' | 'ADMIN';
     createdAt: Date;
     updatedAt: Date;
+    tosAcceptedAt: Date | null;
+    privacyPolicyAcceptedAt: Date | null;
+    codeOfConductAcceptedAt: Date | null;
     player: {
         id: string;
+        playerNumber: number;
         name: string | null;
-        rating: number;
-        ratingDeviation: number;
-        ranking: number | null;
-        isRated: boolean;
         eventCount: number;
     } | null;
 }
@@ -641,26 +1173,400 @@ declare function findUsers(params: {
  */
 declare function linkPlayerToUser(userId: string, playerId: string | null): Promise<UserWithPlayer>;
 
+/**
+ * Maximum number of API keys allowed per user
+ */
+declare const MAX_API_KEYS_PER_USER = 5;
+/**
+ * Input for creating a new API key
+ */
+interface CreateApiKeyInput {
+    name: string;
+    keyPrefix: string;
+    keyHash: string;
+    userId: string;
+    expiresAt?: Date | null;
+}
+/**
+ * API key with user info (for authentication)
+ */
+interface ApiKeyWithUser {
+    id: string;
+    name: string;
+    keyPrefix: string;
+    keyHash: string;
+    expiresAt: Date | null;
+    lastUsedAt: Date | null;
+    createdAt: Date;
+    userId: string;
+    user: {
+        id: string;
+        email: string;
+        role: 'USER' | 'ADMIN';
+    };
+}
+/**
+ * API key info for listing (without sensitive data)
+ */
+interface ApiKeyInfo {
+    id: string;
+    name: string;
+    keyPrefix: string;
+    expiresAt: Date | null;
+    lastUsedAt: Date | null;
+    createdAt: Date;
+}
+/**
+ * Creates a new API key
+ */
+declare function createApiKey(data: CreateApiKeyInput): Promise<ApiKey>;
+/**
+ * Finds an API key by ID
+ */
+declare function findApiKeyById(id: string): Promise<ApiKey | null>;
+/**
+ * Finds API keys by prefix with user data (for authentication)
+ * Returns all keys matching the prefix so we can verify the hash
+ */
+declare function findApiKeysByPrefix(keyPrefix: string): Promise<ApiKeyWithUser[]>;
+/**
+ * Gets all API keys for a user (without sensitive data)
+ */
+declare function getUserApiKeys(userId: string): Promise<ApiKeyInfo[]>;
+/**
+ * Counts API keys for a user
+ */
+declare function countUserApiKeys(userId: string): Promise<number>;
+/**
+ * Updates the lastUsedAt timestamp for an API key
+ */
+declare function updateApiKeyLastUsed(id: string): Promise<void>;
+/**
+ * Deletes an API key
+ */
+declare function deleteApiKey(id: string): Promise<ApiKey>;
+/**
+ * Deletes an API key only if it belongs to the specified user
+ * Returns null if the key doesn't exist or doesn't belong to the user
+ */
+declare function deleteUserApiKey(id: string, userId: string): Promise<ApiKey | null>;
+
+/**
+ * Input for creating a new location
+ */
+interface CreateLocationInput {
+    externalId?: string;
+    name: string;
+    address?: string;
+    city?: string;
+    state?: string;
+    country?: string;
+}
+/**
+ * Input for updating a location
+ */
+interface UpdateLocationInput {
+    name?: string;
+    address?: string | null;
+    city?: string | null;
+    state?: string | null;
+    country?: string | null;
+}
+/**
+ * Options for querying locations
+ */
+interface FindLocationsOptions {
+    take?: number;
+    skip?: number;
+    orderBy?: Prisma.LocationOrderByWithRelationInput;
+    where?: Prisma.LocationWhereInput;
+    include?: Prisma.LocationInclude;
+}
+/**
+ * Creates a new location
+ */
+declare function createLocation(data: CreateLocationInput): Promise<Location>;
+/**
+ * Finds a location by ID
+ */
+declare function findLocationById(id: string, include?: Prisma.LocationInclude): Promise<Location | null>;
+/**
+ * Finds a location by external ID
+ */
+declare function findLocationByExternalId(externalId: string, include?: Prisma.LocationInclude): Promise<Location | null>;
+/**
+ * Finds multiple locations with optional filters
+ */
+declare function findLocations(options?: FindLocationsOptions): Promise<Location[]>;
+/**
+ * Searches locations by name or city
+ */
+declare function searchLocations(query: string, limit?: number): Promise<Location[]>;
+/**
+ * Updates a location
+ */
+declare function updateLocation(id: string, data: UpdateLocationInput): Promise<Location>;
+/**
+ * Deletes a location
+ */
+declare function deleteLocation(id: string): Promise<Location>;
+/**
+ * Counts total locations
+ */
+declare function countLocations(where?: Prisma.LocationWhereInput): Promise<number>;
+/**
+ * Gets location with its tournaments
+ */
+declare function getLocationWithTournaments(id: string): Promise<({
+    tournaments: {
+        name: string;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        externalId: string | null;
+        description: string | null;
+        date: Date;
+        locationId: string | null;
+        organizerId: string | null;
+        tgpConfig: Prisma.JsonValue | null;
+        eventBooster: _prisma_client.$Enums.EventBoosterType;
+        allowsOptOut: boolean;
+        baseValue: number | null;
+        tvaRating: number | null;
+        tvaRanking: number | null;
+        totalTVA: number | null;
+        tgp: number | null;
+        eventBoosterMultiplier: number | null;
+        firstPlaceValue: number | null;
+    }[];
+} & {
+    name: string;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    externalId: string | null;
+    address: string | null;
+    city: string | null;
+    state: string | null;
+    country: string | null;
+}) | null>;
+
+/**
+ * BlogPost with author and tags included
+ */
+type BlogPostWithRelations = BlogPost & {
+    author: {
+        id: string;
+        email: string;
+    };
+    tags: {
+        id: string;
+        name: string;
+        slug: string;
+    }[];
+};
+/**
+ * Input for creating a new blog post
+ */
+interface CreateBlogPostInput {
+    title: string;
+    slug: string;
+    content: string;
+    excerpt?: string;
+    status?: PostStatus;
+    publishedAt?: Date;
+    featuredImageUrl?: string;
+    featuredImageAlt?: string;
+    metaTitle?: string;
+    metaDescription?: string;
+    ogTitle?: string;
+    ogDescription?: string;
+    ogImageUrl?: string;
+    authorId: string;
+    tagIds?: string[];
+}
+/**
+ * Input for updating a blog post
+ */
+interface UpdateBlogPostInput {
+    title?: string;
+    slug?: string;
+    content?: string;
+    excerpt?: string | null;
+    status?: PostStatus;
+    publishedAt?: Date | null;
+    featuredImageUrl?: string | null;
+    featuredImageAlt?: string | null;
+    metaTitle?: string | null;
+    metaDescription?: string | null;
+    ogTitle?: string | null;
+    ogDescription?: string | null;
+    ogImageUrl?: string | null;
+    tagIds?: string[];
+}
+/**
+ * Options for querying blog posts
+ */
+interface FindBlogPostsOptions {
+    take?: number;
+    skip?: number;
+    orderBy?: Prisma.BlogPostOrderByWithRelationInput;
+    where?: Prisma.BlogPostWhereInput;
+    include?: Prisma.BlogPostInclude;
+}
+/**
+ * Creates a new blog post
+ */
+declare function createBlogPost(data: CreateBlogPostInput): Promise<BlogPostWithRelations>;
+/**
+ * Finds a blog post by ID
+ */
+declare function findBlogPostById(id: string): Promise<BlogPostWithRelations | null>;
+/**
+ * Finds a blog post by slug
+ */
+declare function findBlogPostBySlug(slug: string): Promise<BlogPostWithRelations | null>;
+/**
+ * Finds multiple blog posts with optional filters
+ */
+declare function findBlogPosts(options?: FindBlogPostsOptions): Promise<BlogPostWithRelations[]>;
+/**
+ * Finds only published blog posts (for public access)
+ */
+declare function findPublishedBlogPosts(options?: Omit<FindBlogPostsOptions, 'where'> & {
+    tagSlug?: string;
+}): Promise<BlogPostWithRelations[]>;
+/**
+ * Searches blog posts by title or content
+ */
+declare function searchBlogPosts(query: string, limit?: number, publishedOnly?: boolean): Promise<BlogPostWithRelations[]>;
+/**
+ * Updates a blog post
+ */
+declare function updateBlogPost(id: string, data: UpdateBlogPostInput): Promise<BlogPostWithRelations>;
+/**
+ * Deletes a blog post
+ */
+declare function deleteBlogPost(id: string): Promise<BlogPost>;
+/**
+ * Counts total blog posts
+ */
+declare function countBlogPosts(where?: Prisma.BlogPostWhereInput): Promise<number>;
+/**
+ * Counts published blog posts (for public access)
+ */
+declare function countPublishedBlogPosts(tagSlug?: string): Promise<number>;
+
+/**
+ * Input for creating a new blog tag
+ */
+interface CreateBlogTagInput {
+    name: string;
+    slug: string;
+    description?: string;
+}
+/**
+ * Input for updating a blog tag
+ */
+interface UpdateBlogTagInput {
+    name?: string;
+    slug?: string;
+    description?: string | null;
+}
+/**
+ * Options for querying blog tags
+ */
+interface FindBlogTagsOptions {
+    take?: number;
+    skip?: number;
+    orderBy?: Prisma.BlogTagOrderByWithRelationInput;
+    where?: Prisma.BlogTagWhereInput;
+    include?: Prisma.BlogTagInclude;
+}
+/**
+ * Creates a new blog tag
+ */
+declare function createBlogTag(data: CreateBlogTagInput): Promise<BlogTag>;
+/**
+ * Finds a blog tag by ID
+ */
+declare function findBlogTagById(id: string): Promise<BlogTag | null>;
+/**
+ * Finds a blog tag by slug
+ */
+declare function findBlogTagBySlug(slug: string): Promise<BlogTag | null>;
+/**
+ * Finds multiple blog tags with optional filters
+ */
+declare function findBlogTags(options?: FindBlogTagsOptions): Promise<BlogTag[]>;
+/**
+ * Searches blog tags by name
+ */
+declare function searchBlogTags(query: string, limit?: number): Promise<BlogTag[]>;
+/**
+ * Updates a blog tag
+ */
+declare function updateBlogTag(id: string, data: UpdateBlogTagInput): Promise<BlogTag>;
+/**
+ * Deletes a blog tag
+ */
+declare function deleteBlogTag(id: string): Promise<BlogTag>;
+/**
+ * Counts total blog tags
+ */
+declare function countBlogTags(where?: Prisma.BlogTagWhereInput): Promise<number>;
+/**
+ * Gets blog tag with post count
+ */
+declare function getBlogTagWithPostCount(id: string): Promise<({
+    _count: {
+        posts: number;
+    };
+} & {
+    name: string;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    description: string | null;
+    slug: string;
+}) | null>;
+/**
+ * Gets all blog tags with post counts
+ */
+declare function getBlogTagsWithPostCounts(): Promise<({
+    _count: {
+        posts: number;
+    };
+} & {
+    name: string;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    description: string | null;
+    slug: string;
+})[]>;
+
 /**
  * Re-export Prisma generated types
  */
 
 /**
- * Player with full tournament results
+ * Player with full tournament standings
  */
 interface PlayerWithResults {
     player: Player;
-    results: TournamentResultWithTournament[];
+    results: StandingWithTournament[];
     stats: PlayerStatistics;
 }
 /**
- * Tournament result with tournament details
+ * Standing with tournament details
  */
-interface TournamentResultWithTournament {
+interface StandingWithTournament {
     id: string;
     position: number;
-    totalPoints: number;
-    decayedPoints: number;
+    isFinals: boolean;
+    totalPoints: number | null;
+    decayedPoints: number | null;
     tournament: {
         id: string;
         name: string;
@@ -700,4 +1606,4 @@ interface ConnectionStatus {
     error?: string;
 }
 
-export { type ConnectionStatus, type CreatePlayerInput, type CreateResultInput, type CreateTournamentInput, type CreateUserInput, type FindPlayersOptions, type FindResultsOptions, type FindTournamentsOptions, type PlayerStatistics, type PlayerWithResults, type TournamentResultWithTournament, type TournamentStatistics, type UpdatePlayerInput, type UpdateResultInput, type UpdateTournamentInput, type UpdateUserInput, type UserWithPlayer, connect, countPlayers, countResults, countTournaments, countUsers, createManyResults, createPlayer, createResult, createTournament, createUser, createUserWithPlayer, deletePlayer, deleteResult, deleteResultsByTournament, deleteTournament, deleteUser, disconnect, findPlayerByExternalId, findPlayerById, findPlayerByUserEmail, findPlayers, findResultById, findResultByPlayerAndTournament, findResults, findTournamentByExternalId, findTournamentById, findTournaments, findUserByEmail, findUserById, findUsers, getMajorTournaments, getPlayerResults, getPlayerStats, getPlayerTopFinishes, getPlayerWithResults, getRatedPlayers, getRecentTournaments, getTopPlayersByRanking, getTopPlayersByRating, getTournamentResults, getTournamentStats, getTournamentWithResults, getTournamentsByBoosterType, getTournamentsByDateRange, getUserByEmailWithPlayer, getUserWithPlayer, linkPlayerToUser, prisma, recalculateTimeDecay, searchPlayers, searchTournaments, testConnection, updatePlayer, updatePlayerRating, updateResult, updateResultPoints, updateTournament, updateUser, updateUserRefreshToken };
+export { type ApiKeyInfo, type ApiKeyWithUser, type BlogPostWithRelations, type ConnectionStatus, type CreateApiKeyInput, type CreateBlogPostInput, type CreateBlogTagInput, type CreateEntryInput, type CreateLocationInput, type CreateMatchInput, type CreateOpprPlayerRankingInput, type CreateOpprRankingHistoryInput, type CreatePlayerInput, type CreateRoundInput, type CreateStandingInput, type CreateTournamentInput, type CreateUserInput, type FindBlogPostsOptions, type FindBlogTagsOptions, type FindEntriesOptions, type FindLocationsOptions, type FindMatchesOptions, type FindOpprPlayerRankingsOptions, type FindPlayersOptions, type FindRoundsOptions, type FindStandingsOptions, type FindTournamentsOptions, MAX_API_KEYS_PER_USER, type MergedStanding, type PlayerStatistics, type PlayerWithResults, type StandingWithTournament, type TournamentStatistics, type UpdateBlogPostInput, type UpdateBlogTagInput, type UpdateEntryInput, type UpdateLocationInput, type UpdateMatchInput, type UpdateOpprPlayerRankingInput, type UpdatePlayerInput, type UpdateRoundInput, type UpdateStandingInput, type UpdateTournamentInput, type UpdateUserInput, type UserWithPlayer, applyRDDecayForInactivePlayers, connect, countBlogPosts, countBlogTags, countEntries, countLocations, countMatches, countOpprPlayerRankings, countOpprRankingHistory, countPlayers, countPublishedBlogPosts, countRounds, countStandings, countTournaments, countUserApiKeys, countUsers, createApiKey, createBlogPost, createBlogTag, createEntry, createLocation, createManyEntries, createManyMatches, createManyRounds, createManyStandings, createMatch, createOpprPlayerRanking, createOpprRankingHistory, createPlayer, createRound, createStanding, createTournament, createUser, createUserWithPlayer, deleteApiKey, deleteBlogPost, deleteBlogTag, deleteEntriesByMatch, deleteEntry, deleteLocation, deleteMatch, deleteMatchesByRound, deleteMatchesByTournament, deleteOpprPlayerRanking, deletePlayer, deleteRound, deleteRoundsByTournament, deleteStanding, deleteStandingsByTournament, deleteTournament, deleteUser, deleteUserApiKey, disconnect, findApiKeyById, findApiKeysByPrefix, findBlogPostById, findBlogPostBySlug, findBlogPosts, findBlogTagById, findBlogTagBySlug, findBlogTags, findEntries, findEntryById, findEntryByMatchAndPlayer, findLocationByExternalId, findLocationById, findLocations, findMatchById, findMatches, findOpprPlayerRankingById, findOpprPlayerRankingByPlayerId, findOpprPlayerRankings, findPlayerByExternalId, findPlayerById, findPlayerByPlayerNumber, findPlayerByUserEmail, findPlayers, findPublishedBlogPosts, findRoundById, findRoundByTournamentAndNumber, findRounds, findStandingById, findStandingByPlayerAndTournament, findStandings, findTournamentByExternalId, findTournamentById, findTournaments, findUserByEmail, findUserById, findUsers, generateUniquePlayerNumber, getBlogTagWithPostCount, getBlogTagsWithPostCounts, getFinalsRounds, getFinalsStandings, getLatestOpprRankingHistory, getLocationWithTournaments, getMajorTournaments, getMatchEntries, getMatchWithEntries, getMergedStandings, getOpprRankingHistory, getOpprRankingHistoryByDateRange, getOrCreateOpprPlayerRanking, getPlayerEntries, getPlayerEntryStats, getPlayerStandings, getPlayerStats, getPlayerTopFinishes, getPlayerTournamentEntries, getPlayerTournamentMatches, getPlayerWithResults, getQualifyingRounds, getQualifyingStandings, getRatedOpprPlayers, getRecentTournaments, getRoundMatches, getRoundWithMatches, getTopPlayersByOpprRanking, getTopPlayersByOpprRating, getTournamentMatches, getTournamentRounds, getTournamentStandings, getTournamentStats, getTournamentWithMatches, getTournamentWithResults, getTournamentsByBoosterType, getTournamentsByDateRange, getUserApiKeys, getUserByEmailWithPlayer, getUserWithPlayer, isValidPlayerNumber, linkPlayerToUser, prisma, recalculateTimeDecay, searchBlogPosts, searchBlogTags, searchLocations, searchPlayers, searchTournaments, testConnection, updateApiKeyLastUsed, updateBlogPost, updateBlogTag, updateEntry, updateLocation, updateMatch, updateOpprPlayerRanking, updateOpprRatingAfterTournament, updatePlayer, updateRound, updateStanding, updateStandingPoints, updateTournament, updateUser, updateUserRefreshToken, updateWorldRankings };