ruTournament data model and TypeScript interfaces reference

// src/common/db.ts
export interface TournamentLocal {
  id?: string;
  name: string;
  description: string;
  location: string;
  status: string; // 'activo' | 'proximamente' | 'finalizado'
  date: string;   // ISO date string YYYY-MM-DD
  logo?: string;  // base64 image or SVG string
  categories: CategoryLocal[];
  competitors: CompetitorLocal[];
}

// src/common/db.ts
export interface CategoryLocal {
  id?: string;
  name: string;
  format: string;        // 'wca' | 'redbull'
  startTime?: string;    // HH:MM
  endTime?: string;      // HH:MM
  room?: string;
  rounds: RoundLocal[];
  hasSeeding?: boolean;
  seedingFormat?: 'ao3' | 'ao5';
  bracketMode?: 'random' | 'manual';
}

// src/common/db.ts
export interface RoundLocal {
  id?: string;
  num: number;
  format: string;                   // 'ao3' | 'ao5' | 'rb'
  results: ResultLocal[];
  competitorsToAdvance: number | 'all';
  scrambles?: ScrambleRecord[];
  groups?: GroupLocal[];
  matches?: RedBullMatchLocal[];    // Red Bull format only
  bracketMode?: 'random' | 'manual';
  isSeeding?: boolean;
}

// src/common/db.ts
export interface GroupLocal {
  id: string;
  name: string;
  startTime: string;
  endTime: string;
  competitors: string[];   // competitor IDs
  staff: {
    judge: string[];       // competitor IDs acting as judges
    runner: string[];
    scrambler: string[];
  };
  scrambles?: ScrambleRecord[];
}

// src/common/db.ts
export interface CompetitorLocal {
  id?: string;
  name?: string;
  categories: string[];                        // category IDs
  roles?: string[];                            // available global roles
  assignedRoles?: Record<string, string[]>;    // { categoryId: ['judge', 'runner'] }
}

// src/common/db.ts
export interface ResultLocal {
  idCompetitor: string;
  times: (number | TimeRecord)[];
  media: string;
}

// src/common/db.ts
export type Penalty = '' | '+2' | 'DNF';

export interface TimeRecord {
  base: number;     // raw solve time in seconds (floating-point)
  penalty: Penalty;
}

// src/common/db.ts
export interface ScrambleRecord {
  text: string;   // scramble notation (e.g. "R U R' U'")
  svg: string;    // SVG markup of the resulting puzzle state
}

// src/common/db.ts
export interface RedBullMatchLocal {
  id: string;
  competitor1Id: string;
  competitor2Id: string;
  winner?: string;
  times: {
    competitor1: (TimeRecord | null)[];
    competitor2: (TimeRecord | null)[];
  };
  wins: {
    competitor1: number;
    competitor2: number;
  };
}

import { db } from './common/db';

// Retrieve a single tournament by ID
const tournament = await db.tournaments.get(id);

// Persist an updated tournament (replaces the existing record)
await db.tournaments.put(updatedTournament as any);

// Insert a new tournament
await db.tournaments.add(newTournament as any);

// List all tournaments
const all = await db.tournaments.toArray();

// Query by status
const active = await db.tournaments.where('status').equals('activo').toArray();

// src/pages/Tournament/ResultsWCA.tsx
export const normalizeTime = (t: any): TimeRecord

// src/pages/Tournament/ResultsWCA.tsx
export const calculateRulesStats = (
  times: TimeRecord[],
  format: 'ao3' | 'ao5'
): { best: number; average: number }

// src/pages/Tournament/ResultsWCA.tsx
export const sortWCA = (a: any, b: any): number

// src/pages/Tournament/ResultsWCA.tsx
export const parseTimeToSeconds = (val: string | number): number

// src/common/validation.ts
export const isDuplicateName = (
  name: string,
  existingNames: string[],
  excludeIndex?: number
): boolean

// src/common/validation.ts
export const findDuplicateNames = (names: string[]): string[]