@nice2dev/game-engine 1.3.12 → 1.3.14

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

@@ -1,143 +0,0 @@
-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

@@ -1,218 +0,0 @@
-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

@@ -1,153 +0,0 @@
-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

@@ -1,190 +0,0 @@
-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;