chess4js 1.0.0-beta.7 → 1.0.0-beta.9

package/chess4js.d.mts

@@ -72,13 +72,25 @@ export declare class Game {
     toAnalysis(idSupplier?: () => Nullable<any>): Game;
     deleteFromExclusive(node: Node): Node;
     deleteFromInclusive(node: Node): Node;
-    deleteBefore(_this_: Game, node: Node): Node;
+    deleteBefore(node: Node): Node;
     updateEco(): void;
 }
 /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
 export declare namespace Game.$metadata$ {
     const constructor: abstract new () => Game;
 }
+export declare class Match {
+    private constructor();
+    get white(): Nullable<Player>;
+    get black(): Nullable<Player>;
+    get outcome(): string;
+    set outcome(value: string);
+    toString(): string;
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace Match.$metadata$ {
+    const constructor: abstract new () => Match;
+}
 export declare class Move {
     private constructor();
     get backedMove(): any/* Move */;
@@ -95,6 +107,7 @@ export declare namespace Move.$metadata$ {
 }
 export declare class Node {
     private constructor();
+    get id(): number;
     get position(): Position;
     get move(): Nullable<Move>;
     get children(): ReadonlyArray<Node>;
@@ -178,6 +191,27 @@ export declare namespace Piece {
         }
     }
 }
+export declare class Player {
+    private constructor();
+    get name(): string;
+    get initialElo(): number;
+    get currentElo(): number;
+    set currentElo(value: number);
+    get score(): Score;
+    set score(value: Score);
+    get blackScore(): number;
+    set blackScore(value: number);
+    get against(): ReadonlySet<Player>;
+    get active(): boolean;
+    set active(value: boolean);
+    get roundScores(): ReadonlyArray<Score>;
+    get matches(): ReadonlyArray<Match>;
+    toString(): string;
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace Player.$metadata$ {
+    const constructor: abstract new () => Player;
+}
 export declare class Position {
     private constructor();
     get bitboards(): ReadonlyArray<Bitboard>;
@@ -211,6 +245,7 @@ export declare class Position {
     move(move: Move): Position;
     moveFromString(move: string, notation?: Notation): Position;
     flipSide(): Position;
+    transpositionId(): string;
     hashCode(): number;
     equals(other: Nullable<any>): boolean;
     toString(): string;
@@ -219,6 +254,18 @@ export declare class Position {
 export declare namespace Position.$metadata$ {
     const constructor: abstract new () => Position;
 }
+export declare class Score /* implements Comparable<Score> */ {
+    private constructor();
+    toNumber(): number;
+    addScore(other: Score): Score;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+    toString(): string;
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace Score.$metadata$ {
+    const constructor: abstract new () => Score;
+}
 export declare const WHITE: { get(): Side; };
 export declare const BLACK: { get(): Side; };
 export declare class Side {
@@ -331,6 +378,29 @@ export declare namespace Square {
         }
     }
 }
+export declare class Tournament {
+    private constructor();
+    get impactFactor(): number;
+    set impactFactor(value: number);
+    get rangeFactor(): number;
+    set rangeFactor(value: number);
+    get logisticBase(): number;
+    set logisticBase(value: number);
+    get tiebreakers(): Array<string>;
+    set tiebreakers(value: Array<string>);
+    get leaderboard(): ReadonlyArray<Player>;
+    get completed(): boolean;
+    set completed(value: boolean);
+    get activeMatches(): ReadonlyArray<Match>;
+    get finishedMatches(): ReadonlyArray<Match>;
+    addPlayer(player: Player): void;
+    removePlayer(player: Player): void;
+    nextRound(): ReadonlyArray<Match>;
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace Tournament.$metadata$ {
+    const constructor: abstract new () => Tournament;
+}
 export declare class Tuple {
     private constructor();
     get position(): Position;
@@ -363,4 +433,8 @@ export declare function analysisGame(idSupplier?: () => Nullable<any>): Game;
 export declare function strictMatch(idSupplier?: () => Nullable<any>): Game;
 export declare function customGame(gameMode: string, threeRepetitionsMode: string, fiftyMovesRuleMode: string, initialFen?: Nullable<string>, idSupplier?: () => Nullable<any>): Game;
 export declare function parseGames(pgnInput: string, idSupplier?: () => Nullable<any>): ReadonlyArray<Game>;
+export declare function scoreOf(score: string): Score;
+export declare function playerOf(name: string, initialElo: number): Player;
+export declare function matchOf(white: Player, black: Player, impactFactor?: number, rangeFactor?: number, logisticBase?: number): Match;
+export declare function tournament(type: string, tiebreakers?: Array<string>, impactFactor?: number, rangeFactor?: number, logisticBase?: number): Tournament;
 export declare function visibleSquares(piece: string, square: string, position: Position): Bitboard;