@nice2dev/game-engine 1.1.5 → 1.1.7

package/dist/types/systems/NiceTerrain.d.ts

@@ -0,0 +1,143 @@
+import { EventEmitter } from 'events';
+export type TerrainId = string;
+export type LayerId = string;
+export interface Vector2 {
+    x: number;
+    y: number;
+}
+export interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface TerrainLayer {
+    id: LayerId;
+    name: string;
+    texture: string;
+    normalMap?: string;
+    tileSize: number;
+    metallic?: number;
+    smoothness?: number;
+    minSlope?: number;
+    maxSlope?: number;
+    minHeight?: number;
+    maxHeight?: number;
+}
+export interface DetailPrototype {
+    id: string;
+    mesh?: string;
+    texture?: string;
+    minWidth: number;
+    maxWidth: number;
+    minHeight: number;
+    maxHeight: number;
+    noiseSpread: number;
+    healthyColor: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    dryColor: {
+        r: number;
+        g: number;
+        b: number;
+    };
+}
+export interface TreePrototype {
+    id: string;
+    mesh: string;
+    bendFactor: number;
+    navMeshObstacle?: boolean;
+}
+export interface TerrainData {
+    id: TerrainId;
+    width: number;
+    height: number;
+    resolution: number;
+    heightMap: Float32Array;
+    splatMap: Float32Array[];
+    holeMap?: Uint8Array;
+    detailMaps?: Uint16Array[];
+    treePlacements?: TreePlacement[];
+    minHeight: number;
+    maxHeight: number;
+}
+export interface TreePlacement {
+    prototypeId: string;
+    position: Vector3;
+    rotation: number;
+    scale: Vector3;
+    color?: {
+        r: number;
+        g: number;
+        b: number;
+    };
+}
+export interface Brush {
+    size: number;
+    falloff: number;
+    strength: number;
+    shape: 'circle' | 'square' | 'custom';
+    customMask?: Float32Array;
+}
+export type TerrainEventType = 'height-modified' | 'splat-modified' | 'detail-modified' | 'tree-added' | 'tree-removed' | 'hole-created' | 'hole-filled' | 'terrain-created' | 'terrain-destroyed';
+export interface TerrainEvent {
+    type: TerrainEventType;
+    terrainId: TerrainId;
+    position?: Vector2;
+    radius?: number;
+}
+export interface TerrainConfig {
+    defaultResolution?: number;
+    defaultMinHeight?: number;
+    defaultMaxHeight?: number;
+    lodLevels?: number;
+    lodDistances?: number[];
+}
+export declare const DEFAULT_TERRAIN_CONFIG: TerrainConfig;
+export declare class NiceTerrain extends EventEmitter {
+    private terrains;
+    private layers;
+    private detailPrototypes;
+    private treePrototypes;
+    private nextTerrainId;
+    private config;
+    constructor(config?: Partial<TerrainConfig>);
+    registerLayer(layer: TerrainLayer): void;
+    unregisterLayer(layerId: LayerId): boolean;
+    getLayer(layerId: LayerId): TerrainLayer | undefined;
+    getAllLayers(): TerrainLayer[];
+    registerDetailPrototype(prototype: DetailPrototype): void;
+    registerTreePrototype(prototype: TreePrototype): void;
+    create(width: number, height: number, options?: {
+        resolution?: number;
+        minHeight?: number;
+        maxHeight?: number;
+    }): TerrainId;
+    destroy(terrainId: TerrainId): boolean;
+    get(terrainId: TerrainId): TerrainData | undefined;
+    getHeight(terrainId: TerrainId, x: number, y: number): number;
+    private sampleHeightMap;
+    setHeight(terrainId: TerrainId, x: number, y: number, height: number): void;
+    modifyHeight(terrainId: TerrainId, centerX: number, centerY: number, brush: Brush, delta: number): void;
+    private calculateFalloff;
+    flatten(terrainId: TerrainId, centerX: number, centerY: number, brush: Brush, targetHeight: number): void;
+    smooth(terrainId: TerrainId, centerX: number, centerY: number, brush: Brush): void;
+    getNormal(terrainId: TerrainId, x: number, y: number): Vector3;
+    getSlope(terrainId: TerrainId, x: number, y: number): number;
+    addSplatLayer(terrainId: TerrainId): number;
+    paintLayer(terrainId: TerrainId, layerIndex: number, centerX: number, centerY: number, brush: Brush): void;
+    getSplatWeights(terrainId: TerrainId, x: number, y: number): number[];
+    createHole(terrainId: TerrainId, centerX: number, centerY: number, brush: Brush): void;
+    fillHole(terrainId: TerrainId, centerX: number, centerY: number, brush: Brush): void;
+    isHole(terrainId: TerrainId, x: number, y: number): boolean;
+    placeTree(terrainId: TerrainId, prototypeId: string, position: Vector3, options?: {
+        rotation?: number;
+        scale?: Vector3;
+    }): void;
+    removeTree(terrainId: TerrainId, x: number, z: number, radius: number): number;
+    getTrees(terrainId: TerrainId): TreePlacement[];
+}
+export declare function createTerrainSystem(config?: Partial<TerrainConfig>): NiceTerrain;
+export declare function createBrush(options?: Partial<Brush>): Brush;
+export default NiceTerrain;

package/dist/types/systems/NiceTilemap.d.ts

@@ -0,0 +1,218 @@
+import { EventEmitter } from 'events';
+export interface TilePosition {
+    x: number;
+    y: number;
+}
+export interface WorldPosition {
+    worldX: number;
+    worldY: number;
+}
+export interface TileRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface TileData {
+    id: number;
+    tilesetId: string;
+    localId: number;
+    flipH?: boolean;
+    flipV?: boolean;
+    rotation?: 0 | 90 | 180 | 270;
+}
+export interface TileProperties {
+    [key: string]: string | number | boolean;
+}
+export interface Tile {
+    id: number;
+    name?: string;
+    collision?: boolean;
+    collisionShape?: 'full' | 'half-top' | 'half-bottom' | 'half-left' | 'half-right' | 'slope-left' | 'slope-right' | 'custom';
+    customCollision?: Array<{
+        x: number;
+        y: number;
+    }>;
+    animation?: TileAnimation;
+    properties: TileProperties;
+}
+export interface TileAnimation {
+    frames: number[];
+    duration: number;
+    loop: boolean;
+    currentFrame: number;
+    timer: number;
+}
+export interface TilesetConfig {
+    id: string;
+    name: string;
+    imageUrl: string;
+    tileWidth: number;
+    tileHeight: number;
+    spacing?: number;
+    margin?: number;
+    columns?: number;
+    rows?: number;
+    firstGid: number;
+}
+export declare class Tileset {
+    readonly id: string;
+    readonly name: string;
+    readonly imageUrl: string;
+    readonly tileWidth: number;
+    readonly tileHeight: number;
+    readonly spacing: number;
+    readonly margin: number;
+    readonly columns: number;
+    readonly rows: number;
+    readonly firstGid: number;
+    private tiles;
+    private image;
+    private loaded;
+    constructor(config: TilesetConfig);
+    load(): Promise<void>;
+    isLoaded(): boolean;
+    getImage(): HTMLImageElement | null;
+    getTile(localId: number): Tile | undefined;
+    setTile(localId: number, tile: Tile): void;
+    containsGid(gid: number): boolean;
+    gidToLocal(gid: number): number;
+    localToGid(localId: number): number;
+    getTileUV(localId: number): {
+        u: number;
+        v: number;
+        u2: number;
+        v2: number;
+    };
+    getTileRect(localId: number): TileRect;
+}
+export interface LayerConfig {
+    id: string;
+    name: string;
+    width: number;
+    height: number;
+    visible?: boolean;
+    opacity?: number;
+    offsetX?: number;
+    offsetY?: number;
+    parallaxX?: number;
+    parallaxY?: number;
+    tintColor?: string;
+}
+export declare class TilemapLayer {
+    readonly id: string;
+    readonly name: string;
+    readonly width: number;
+    readonly height: number;
+    visible: boolean;
+    opacity: number;
+    offsetX: number;
+    offsetY: number;
+    parallaxX: number;
+    parallaxY: number;
+    tintColor: string | null;
+    private tiles;
+    constructor(config: LayerConfig);
+    isInBounds(x: number, y: number): boolean;
+    getTile(x: number, y: number): TileData | null;
+    setTile(x: number, y: number, tile: TileData | null): void;
+    fill(tile: TileData | null): void;
+    fillRect(startX: number, startY: number, width: number, height: number, tile: TileData | null): void;
+    clear(): void;
+    forEach(callback: (tile: TileData | null, x: number, y: number) => void): void;
+    toArray(): (number | null)[][];
+}
+export declare const AUTOTILE_BLOB_47: Record<number, number>;
+export type AutoTileRule = {
+    mask: number;
+    result: number;
+};
+export interface AutoTileConfig {
+    tilesetId: string;
+    baseTile: number;
+    rules?: AutoTileRule[];
+    type: '4bit' | '8bit' | 'blob47' | 'custom';
+}
+export type TilemapEventType = 'tile-changed' | 'layer-added' | 'layer-removed' | 'tileset-added' | 'loaded' | 'chunk-loaded' | 'chunk-unloaded';
+export interface TilemapEvent {
+    type: TilemapEventType;
+    x?: number;
+    y?: number;
+    layerId?: string;
+    tilesetId?: string;
+    chunkX?: number;
+    chunkY?: number;
+}
+export interface Chunk {
+    x: number;
+    y: number;
+    layers: Map<string, (TileData | null)[][]>;
+    dirty: boolean;
+    lastAccess: number;
+}
+export interface TilemapConfig {
+    width: number;
+    height: number;
+    tileWidth: number;
+    tileHeight: number;
+    infinite?: boolean;
+    chunkSize?: number;
+    orientation?: 'orthogonal' | 'isometric' | 'hexagonal';
+    staggerAxis?: 'x' | 'y';
+    staggerIndex?: 'odd' | 'even';
+}
+export declare class NiceTilemap extends EventEmitter {
+    readonly width: number;
+    readonly height: number;
+    readonly tileWidth: number;
+    readonly tileHeight: number;
+    readonly infinite: boolean;
+    readonly chunkSize: number;
+    readonly orientation: 'orthogonal' | 'isometric' | 'hexagonal';
+    private tilesets;
+    private layers;
+    private layerOrder;
+    private chunks;
+    private autoTileConfigs;
+    private animatedTiles;
+    constructor(config: TilemapConfig);
+    addTileset(config: TilesetConfig): Tileset;
+    getTileset(id: string): Tileset | undefined;
+    getTilesetForGid(gid: number): Tileset | undefined;
+    loadTilesets(): Promise<void>;
+    addLayer(config: LayerConfig): TilemapLayer;
+    getLayer(id: string): TilemapLayer | undefined;
+    removeLayer(id: string): boolean;
+    getLayers(): TilemapLayer[];
+    moveLayer(id: string, newIndex: number): void;
+    setTile(layerId: string, x: number, y: number, gid: number): void;
+    getTile(layerId: string, x: number, y: number): TileData | null;
+    getTileProperties(layerId: string, x: number, y: number): TileProperties | null;
+    isCollision(x: number, y: number): boolean;
+    tileToWorld(tileX: number, tileY: number): WorldPosition;
+    worldToTile(worldX: number, worldY: number): TilePosition;
+    registerAutoTile(id: string, config: AutoTileConfig): void;
+    applyAutoTile(layerId: string, autoTileId: string, x: number, y: number, updateNeighbors?: boolean): void;
+    private calculateAutoTileMask;
+    private getAutoTileResult;
+    registerAnimatedTile(tilesetId: string, localId: number, frames: number[], duration: number, loop?: boolean): void;
+    updateAnimations(deltaTime: number): void;
+    getCurrentAnimationFrame(tilesetId: string, localId: number): number;
+    getVisibleTiles(viewX: number, viewY: number, viewWidth: number, viewHeight: number): Array<{
+        layerId: string;
+        tile: TileData;
+        x: number;
+        y: number;
+        worldX: number;
+        worldY: number;
+    }>;
+    toJSON(): object;
+    loadFromJSON(data: {
+        layers: Record<string, (number | null)[][]>;
+    }): void;
+    getWalkableNeighbors(x: number, y: number, includeDiagonals?: boolean): TilePosition[];
+}
+export declare function createTilemap(width: number, height: number, tileWidth: number, tileHeight: number): NiceTilemap;
+export declare function createIsometricTilemap(width: number, height: number, tileWidth: number, tileHeight: number): NiceTilemap;
+export declare function createHexTilemap(width: number, height: number, tileWidth: number, tileHeight: number): NiceTilemap;
+export default NiceTilemap;

package/dist/types/systems/NiceTimer.d.ts

@@ -0,0 +1,153 @@
+export type TimerId = string;
+export type TimerGroupId = string;
+export type TimerCallback = (elapsed: number, remaining: number) => void;
+export type TimerCompleteCallback = () => void;
+export interface TimerConfig {
+    /** Duration in seconds */
+    duration: number;
+    /** Repeat count (-1 = infinite, 0 = once) */
+    repeat: number;
+    /** Delay before first execution */
+    delay: number;
+    /** Callback on each tick */
+    onTick?: TimerCallback;
+    /** Callback on complete */
+    onComplete?: TimerCompleteCallback;
+    /** Group for batch operations */
+    group?: TimerGroupId;
+    /** Time scale (0-1 for slow, >1 for fast) */
+    timeScale: number;
+    /** Pause on creation */
+    paused: boolean;
+    /** Auto-destroy when complete */
+    autoDestroy: boolean;
+    /** Tags for filtering */
+    tags?: string[];
+}
+export declare const DEFAULT_TIMER_CONFIG: Partial<TimerConfig>;
+export interface TimerState {
+    id: TimerId;
+    config: TimerConfig;
+    /** Current elapsed time */
+    elapsed: number;
+    /** Current delay remaining */
+    delayRemaining: number;
+    /** Number of times completed */
+    completions: number;
+    /** Is paused */
+    paused: boolean;
+    /** Is running (not paused, started) */
+    running: boolean;
+    /** Is finished */
+    finished: boolean;
+    /** Creation time */
+    createdAt: number;
+}
+export interface ScheduledTask {
+    id: string;
+    /** Execute at this time (ms) */
+    executeAt: number;
+    /** Callback */
+    callback: () => void;
+    /** Priority (lower = sooner) */
+    priority: number;
+    /** Has been executed */
+    executed: boolean;
+    /** Cancelled */
+    cancelled: boolean;
+}
+export type SequenceStep = {
+    type: 'wait';
+    duration: number;
+} | {
+    type: 'call';
+    callback: () => void;
+} | {
+    type: 'parallel';
+    steps: SequenceStep[];
+} | {
+    type: 'loop';
+    count: number;
+    steps: SequenceStep[];
+} | {
+    type: 'condition';
+    check: () => boolean;
+    then: SequenceStep[];
+    else?: SequenceStep[];
+};
+export type TimerEventType = 'timer-created' | 'timer-started' | 'timer-tick' | 'timer-paused' | 'timer-resumed' | 'timer-completed' | 'timer-destroyed' | 'group-paused' | 'group-resumed';
+export interface TimerEvent {
+    type: TimerEventType;
+    timestamp: number;
+    timerId?: TimerId;
+    data?: unknown;
+}
+export type TimerEventCallback = (event: TimerEvent) => void;
+export declare class NiceTimer {
+    private timers;
+    private groups;
+    private scheduledTasks;
+    private activeSequences;
+    private eventListeners;
+    private globalTimeScale;
+    private globalPaused;
+    private totalElapsed;
+    private idCounter;
+    on(event: TimerEventType, callback: TimerEventCallback): () => void;
+    private emit;
+    create(config: Partial<TimerConfig> & {
+        duration: number;
+    }): TimerId;
+    /** Create a one-shot timer */
+    after(duration: number, callback: TimerCompleteCallback, group?: TimerGroupId): TimerId;
+    /** Create a repeating timer */
+    every(interval: number, callback: TimerCallback, options?: {
+        count?: number;
+        group?: TimerGroupId;
+    }): TimerId;
+    /** Create a delayed call (alias) */
+    delay(duration: number, callback: TimerCompleteCallback): TimerId;
+    /** Schedule at specific time */
+    schedule(executeAt: Date | number, callback: () => void, priority?: number): string;
+    pause(id: TimerId): void;
+    resume(id: TimerId): void;
+    reset(id: TimerId): void;
+    cancel(id: TimerId): void;
+    pauseGroup(groupId: TimerGroupId): void;
+    resumeGroup(groupId: TimerGroupId): void;
+    cancelGroup(groupId: TimerGroupId): void;
+    setGlobalTimeScale(scale: number): void;
+    getGlobalTimeScale(): number;
+    pauseAll(): void;
+    resumeAll(): void;
+    /** Slow-motion effect */
+    slowMotion(scale: number, duration: number): TimerId;
+    sequence(steps: SequenceStep[], _group?: TimerGroupId): string;
+    private flattenSequence;
+    private updateSequences;
+    get(id: TimerId): TimerState | undefined;
+    isRunning(id: TimerId): boolean;
+    isPaused(id: TimerId): boolean;
+    isFinished(id: TimerId): boolean;
+    getElapsed(id: TimerId): number;
+    getRemaining(id: TimerId): number;
+    getProgress(id: TimerId): number;
+    getActiveCount(): number;
+    findByTag(tag: string): TimerId[];
+    update(deltaTime: number): void;
+    cancelScheduled(taskId: string): void;
+    cancelSequence(sequenceId: string): void;
+    getTotalElapsed(): number;
+    destroy(): void;
+}
+export declare function createTimerSystem(): NiceTimer;
+export declare class SequenceBuilder {
+    private steps;
+    wait(duration: number): this;
+    call(callback: () => void): this;
+    loop(count: number, builder: (seq: SequenceBuilder) => void): this;
+    parallel(...callbacks: (() => void)[]): this;
+    condition(check: () => boolean, thenBuilder: (seq: SequenceBuilder) => void, elseBuilder?: (seq: SequenceBuilder) => void): this;
+    build(): SequenceStep[];
+}
+export declare function buildSequence(builder: (seq: SequenceBuilder) => void): SequenceStep[];

package/dist/types/systems/NiceTournament.d.ts

@@ -0,0 +1,190 @@
+export type TournamentId = string;
+export type MatchId = string;
+export type ParticipantId = string;
+export type BracketId = string;
+export type TournamentFormat = 'single-elimination' | 'double-elimination' | 'round-robin' | 'swiss' | 'group-stage' | 'battle-royale' | 'league' | 'custom';
+export type TournamentStatus = 'draft' | 'registration' | 'check-in' | 'seeding' | 'in-progress' | 'finals' | 'completed' | 'cancelled';
+export type MatchStatus = 'pending' | 'ready' | 'in-progress' | 'score-reported' | 'disputed' | 'completed' | 'forfeit';
+export interface Participant {
+    id: ParticipantId;
+    tournamentId: TournamentId;
+    playerId?: string;
+    teamId?: string;
+    name: string;
+    seed?: number;
+    registeredAt: number;
+    checkedIn: boolean;
+    checkedInAt?: number;
+    eliminated: boolean;
+    eliminatedAt?: number;
+    placement?: number;
+    wins: number;
+    losses: number;
+    draws: number;
+    pointsFor: number;
+    pointsAgainst: number;
+    tiebreaker?: number;
+}
+export interface MatchParticipant {
+    participantId: ParticipantId | null;
+    score: number;
+    isWinner: boolean;
+    reportedScore?: number;
+    reportedAt?: number;
+}
+export interface TournamentMatch {
+    id: MatchId;
+    tournamentId: TournamentId;
+    bracketId?: BracketId;
+    round: number;
+    matchNumber: number;
+    bestOf: number;
+    participants: [MatchParticipant, MatchParticipant];
+    status: MatchStatus;
+    scheduledAt?: number;
+    startedAt?: number;
+    completedAt?: number;
+    winnerId?: ParticipantId;
+    loserId?: ParticipantId;
+    nextMatchId?: MatchId;
+    nextLoserMatchId?: MatchId;
+    previousMatchIds?: MatchId[];
+    streamUrl?: string;
+    notes?: string;
+    disputeReason?: string;
+    adminNotes?: string;
+}
+export interface Bracket {
+    id: BracketId;
+    tournamentId: TournamentId;
+    name: string;
+    type: 'winners' | 'losers' | 'grand-finals' | 'group' | 'main';
+    rounds: number;
+    matches: MatchId[];
+}
+export interface PrizePlacement {
+    minPlace: number;
+    maxPlace: number;
+    currency?: string;
+    amount?: number;
+    items?: Array<{
+        itemId: string;
+        quantity: number;
+    }>;
+    title?: string;
+    badge?: string;
+}
+export interface PrizePool {
+    totalValue: number;
+    currency: string;
+    placements: PrizePlacement[];
+    distributed: boolean;
+}
+export interface TournamentDefinition {
+    id: TournamentId;
+    name: string;
+    description: string;
+    format: TournamentFormat;
+    minParticipants: number;
+    maxParticipants: number;
+    teamSize?: number;
+    registrationStart?: number;
+    registrationEnd?: number;
+    checkInStart?: number;
+    checkInEnd?: number;
+    tournamentStart?: number;
+    bestOf: number;
+    matchTimeout?: number;
+    rounds?: number;
+    groupCount?: number;
+    advancePerGroup?: number;
+    rules?: string;
+    seedingMethod?: 'random' | 'rating' | 'manual';
+    prizePool?: PrizePool;
+    gameId?: string;
+    tags?: string[];
+    imageUrl?: string;
+}
+export interface TournamentInstance {
+    definition: TournamentDefinition;
+    status: TournamentStatus;
+    participants: Map<ParticipantId, Participant>;
+    matches: Map<MatchId, TournamentMatch>;
+    brackets: Map<BracketId, Bracket>;
+    currentRound: number;
+    createdAt: number;
+    startedAt?: number;
+    completedAt?: number;
+    standings?: ParticipantId[];
+}
+export type TournamentEventType = 'tournament-created' | 'registration-opened' | 'registration-closed' | 'check-in-opened' | 'check-in-closed' | 'player-registered' | 'player-checked-in' | 'player-withdrawn' | 'bracket-generated' | 'tournament-started' | 'match-ready' | 'match-started' | 'score-reported' | 'score-disputed' | 'match-completed' | 'round-completed' | 'player-eliminated' | 'tournament-completed' | 'prizes-distributed';
+export interface TournamentEvent {
+    type: TournamentEventType;
+    timestamp: number;
+    tournamentId: TournamentId;
+    matchId?: MatchId;
+    participantId?: ParticipantId;
+    data?: unknown;
+}
+export type TournamentEventCallback = (event: TournamentEvent) => void;
+export interface TournamentConfig {
+    checkInDuration: number;
+    matchReadyTimeout: number;
+    scoreReportTimeout: number;
+    allowSelfReport: boolean;
+    requireBothReports: boolean;
+    autoResolveScores: boolean;
+    storageKey: string;
+}
+export declare const DEFAULT_TOURNAMENT_CONFIG: TournamentConfig;
+export declare class NiceTournament {
+    private config;
+    private tournaments;
+    private eventListeners;
+    private idCounter;
+    constructor(config?: Partial<TournamentConfig>);
+    on(event: TournamentEventType, callback: TournamentEventCallback): () => void;
+    private emit;
+    createTournament(definition: TournamentDefinition): TournamentInstance;
+    getTournament(tournamentId: TournamentId): TournamentInstance | undefined;
+    getAllTournaments(): TournamentInstance[];
+    getTournamentsByStatus(status: TournamentStatus): TournamentInstance[];
+    openRegistration(tournamentId: TournamentId): boolean;
+    closeRegistration(tournamentId: TournamentId): boolean;
+    register(tournamentId: TournamentId, name: string, playerId?: string, teamId?: string): Participant | null;
+    withdraw(tournamentId: TournamentId, participantId: ParticipantId): boolean;
+    checkIn(tournamentId: TournamentId, participantId: ParticipantId): boolean;
+    closeCheckIn(tournamentId: TournamentId, removeNoShows?: boolean): boolean;
+    generateBracket(tournamentId: TournamentId): boolean;
+    private seedParticipants;
+    private shuffleArray;
+    private generateSingleElimination;
+    private generateDoubleElimination;
+    private generateRoundRobin;
+    private generateSwissRound;
+    private generateSwissRoundMatches;
+    private generateGroupStage;
+    private createMatch;
+    startTournament(tournamentId: TournamentId): boolean;
+    reportScore(matchId: MatchId, reporterId: ParticipantId, score1: number, score2: number): boolean;
+    disputeMatch(matchId: MatchId, reason: string): boolean;
+    completeMatch(matchId: MatchId, score1: number, score2: number): boolean;
+    private advanceWinner;
+    private checkProgress;
+    private completeTournament;
+    private calculateStandings;
+    private distributePrizes;
+    getMatch(matchId: MatchId): TournamentMatch | undefined;
+    getMatchesForParticipant(participantId: ParticipantId): TournamentMatch[];
+    getUpcomingMatches(tournamentId: TournamentId): TournamentMatch[];
+    getBracketData(tournamentId: TournamentId): {
+        brackets: Bracket[];
+        matches: TournamentMatch[];
+        participants: Participant[];
+    } | null;
+    private save;
+    private load;
+    reset(): void;
+    destroy(): void;
+}
+export declare function createTournamentSystem(config?: Partial<TournamentConfig>): NiceTournament;