@opprs/db-prisma 2.2.1-canary.ccb79aa → 2.2.1-canary.cd8b178

package/dist/index.d.ts

@@ -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 } 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>;
 /**
@@ -27,23 +27,15 @@ 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;
 }
 /**
@@ -80,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
  */
@@ -109,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: ({
@@ -119,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;
@@ -136,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;
@@ -148,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;
@@ -172,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;
@@ -190,12 +172,7 @@ declare function getPlayerWithResults(id: string): Promise<{
     updatedAt: Date;
     externalId: string | null;
     playerNumber: number;
-    rating: number;
-    ratingDeviation: number;
-    ranking: number | null;
-    isRated: boolean;
     eventCount: number;
-    lastRatingUpdate: Date;
     lastEventDate: Date | null;
 } | null>;
 /**
@@ -203,6 +180,129 @@ 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.
@@ -221,8 +321,10 @@ declare function isValidPlayerNumber(playerNumber: number): boolean;
 interface CreateTournamentInput {
     externalId?: string;
     name: string;
-    location?: string;
+    description?: string;
     date: Date;
+    locationId?: string;
+    organizerId?: string;
     tgpConfig?: Prisma.InputJsonValue;
     eventBooster?: EventBoosterType;
     allowsOptOut?: boolean;
@@ -239,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;
@@ -307,10 +411,10 @@ 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;
@@ -318,21 +422,17 @@ declare function getTournamentWithResults(id: string): Promise<({
             updatedAt: Date;
             externalId: string | null;
             playerNumber: number;
-            rating: number;
-            ratingDeviation: number;
-            ranking: number | null;
-            isRated: boolean;
             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;
@@ -348,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;
@@ -362,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[]>;
 /**
@@ -370,7 +537,7 @@ declare function searchTournaments(query: string, limit?: number): Promise<Tourn
  */
 declare function getTournamentStats(id: string): Promise<{
     tournament: {
-        results: ({
+        standings: ({
             player: {
                 name: string | null;
                 id: string;
@@ -378,21 +545,17 @@ declare function getTournamentStats(id: string): Promise<{
                 updatedAt: Date;
                 externalId: string | null;
                 playerNumber: number;
-                rating: number;
-                ratingDeviation: number;
-                ranking: number | null;
-                isRated: boolean;
                 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;
@@ -408,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;
@@ -429,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
+ */
+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 CreateResultInput {
+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;
@@ -445,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;
@@ -459,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 createResult(data: CreateResultInput): Promise<TournamentResult>;
+declare function createStanding(data: CreateStandingInput): Promise<Standing>;
 /**
- * Creates multiple tournament results at once
+ * Creates multiple standings at once
  */
-declare function createManyResults(data: CreateResultInput[]): Promise<Prisma.BatchPayload>;
+declare function createManyStandings(data: CreateStandingInput[]): Promise<Prisma.BatchPayload>;
 /**
- * Finds a result by ID
+ * Finds a standing by ID
  */
-declare function findResultById(id: string, include?: Prisma.TournamentResultInclude): Promise<TournamentResult | null>;
+declare function findStandingById(id: string, include?: Prisma.StandingInclude): Promise<Standing | null>;
 /**
- * Finds a result by player and tournament
+ * Finds a standing by player, tournament, and isFinals
  */
-declare function findResultByPlayerAndTournament(playerId: string, tournamentId: string, include?: Prisma.TournamentResultInclude): Promise<TournamentResult | null>;
+declare function findStandingByPlayerAndTournament(playerId: string, tournamentId: string, isFinals: boolean, include?: Prisma.StandingInclude): Promise<Standing | null>;
 /**
- * Finds multiple results with optional filters
+ * Finds multiple standings with optional filters
  */
-declare function findResults(options?: FindResultsOptions): Promise<TournamentResult[]>;
+declare function findStandings(options?: FindStandingsOptions): Promise<Standing[]>;
 /**
- * Gets all results for a specific player
+ * Gets all standings for a specific player
  */
-declare function getPlayerResults(playerId: string, options?: Omit<FindResultsOptions, 'where'>): Promise<TournamentResult[]>;
+declare function getPlayerStandings(playerId: string, options?: Omit<FindStandingsOptions, 'where'>): Promise<Standing[]>;
 /**
- * Gets all results for a specific tournament
+ * Gets all standings for a specific tournament
  */
-declare function getTournamentResults(tournamentId: string, options?: Omit<FindResultsOptions, 'where'>): Promise<TournamentResult[]>;
+declare function getTournamentStandings(tournamentId: string, options?: Omit<FindStandingsOptions, 'where'>): Promise<Standing[]>;
+/**
+ * Gets qualifying standings for a tournament
+ */
+declare function getQualifyingStandings(tournamentId: string, options?: Omit<FindStandingsOptions, 'where'>): Promise<Standing[]>;
+/**
+ * Gets finals standings for a tournament
+ */
+declare function getFinalsStandings(tournamentId: string, options?: Omit<FindStandingsOptions, 'where'>): Promise<Standing[]>;
+/**
+ * Gets merged standings for point calculation.
+ * Finalists get their finals position, non-finalists get qualifying position + finalist count
+ */
+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
  */
@@ -537,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%
@@ -548,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;
@@ -569,6 +1078,9 @@ interface CreateUserInput {
     passwordHash: string;
     playerId?: string;
     role?: 'USER' | 'ADMIN';
+    tosAcceptedAt?: Date;
+    privacyPolicyAcceptedAt?: Date;
+    codeOfConductAcceptedAt?: Date;
 }
 /**
  * Input for updating a user
@@ -589,14 +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;
 }
@@ -662,26 +1173,205 @@ 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>;
+
 /**
  * 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;
@@ -721,4 +1411,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, findPlayerByPlayerNumber, findPlayerByUserEmail, findPlayers, findResultById, findResultByPlayerAndTournament, findResults, findTournamentByExternalId, findTournamentById, findTournaments, findUserByEmail, findUserById, findUsers, generateUniquePlayerNumber, getMajorTournaments, getPlayerResults, getPlayerStats, getPlayerTopFinishes, getPlayerWithResults, getRatedPlayers, getRecentTournaments, getTopPlayersByRanking, getTopPlayersByRating, getTournamentResults, getTournamentStats, getTournamentWithResults, getTournamentsByBoosterType, getTournamentsByDateRange, getUserByEmailWithPlayer, getUserWithPlayer, isValidPlayerNumber, linkPlayerToUser, prisma, recalculateTimeDecay, searchPlayers, searchTournaments, testConnection, updatePlayer, updatePlayerRating, updateResult, updateResultPoints, updateTournament, updateUser, updateUserRefreshToken };
+export { type ApiKeyInfo, type ApiKeyWithUser, type ConnectionStatus, type CreateApiKeyInput, type CreateEntryInput, type CreateLocationInput, type CreateMatchInput, type CreateOpprPlayerRankingInput, type CreateOpprRankingHistoryInput, type CreatePlayerInput, type CreateRoundInput, type CreateStandingInput, type CreateTournamentInput, type CreateUserInput, 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 UpdateEntryInput, type UpdateLocationInput, type UpdateMatchInput, type UpdateOpprPlayerRankingInput, type UpdatePlayerInput, type UpdateRoundInput, type UpdateStandingInput, type UpdateTournamentInput, type UpdateUserInput, type UserWithPlayer, applyRDDecayForInactivePlayers, connect, countEntries, countLocations, countMatches, countOpprPlayerRankings, countOpprRankingHistory, countPlayers, countRounds, countStandings, countTournaments, countUserApiKeys, countUsers, createApiKey, createEntry, createLocation, createManyEntries, createManyMatches, createManyRounds, createManyStandings, createMatch, createOpprPlayerRanking, createOpprRankingHistory, createPlayer, createRound, createStanding, createTournament, createUser, createUserWithPlayer, deleteApiKey, deleteEntriesByMatch, deleteEntry, deleteLocation, deleteMatch, deleteMatchesByRound, deleteMatchesByTournament, deleteOpprPlayerRanking, deletePlayer, deleteRound, deleteRoundsByTournament, deleteStanding, deleteStandingsByTournament, deleteTournament, deleteUser, deleteUserApiKey, disconnect, findApiKeyById, findApiKeysByPrefix, findEntries, findEntryById, findEntryByMatchAndPlayer, findLocationByExternalId, findLocationById, findLocations, findMatchById, findMatches, findOpprPlayerRankingById, findOpprPlayerRankingByPlayerId, findOpprPlayerRankings, findPlayerByExternalId, findPlayerById, findPlayerByPlayerNumber, findPlayerByUserEmail, findPlayers, findRoundById, findRoundByTournamentAndNumber, findRounds, findStandingById, findStandingByPlayerAndTournament, findStandings, findTournamentByExternalId, findTournamentById, findTournaments, findUserByEmail, findUserById, findUsers, generateUniquePlayerNumber, 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, searchLocations, searchPlayers, searchTournaments, testConnection, updateApiKeyLastUsed, updateEntry, updateLocation, updateMatch, updateOpprPlayerRanking, updateOpprRatingAfterTournament, updatePlayer, updateRound, updateStanding, updateStandingPoints, updateTournament, updateUser, updateUserRefreshToken, updateWorldRankings };