@johnmorrisdotca/kumimoji 1.2.1 → 1.3.0

package/dist/partySeats.d.ts

@@ -24,17 +24,90 @@ import type { PartyGame, PartySeat } from "./party.types.ts";
  * standing (`lastStanding`), and wins by laying a tile on a sound grid, as
  * when everybody else resigns — unless somebody joins first.
  */
-/** Why nobody can join now, or null when a hand can be dealt. */
+/** Why nobody can join now, or null when a hand can be dealt.
+ *
+ * @example
+ * ```ts
+ * import type { JoinRefusal } from "@johnmorrisdotca/kumimoji";
+ *
+ * const value: JoinRefusal = "full";
+ * console.log(value);
+ * ```
+ */
 export type JoinRefusal = "over" | "full" | "lastRound" | "bag";
-/** Why nobody can join the table now, or null when a hand can be dealt. */
+/** Why nobody can join the table now, or null when a hand can be dealt.
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @returns Why nobody can join the table now, or null when a hand can be dealt.
+ * @example
+ * ```ts
+ * import { joinRefused, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(joinRefused(game));
+ * ```
+ */
 export declare function joinRefused(game: PartyGame): JoinRefusal | null;
-/** A player, or a computer, sat down after the last seat with the next hand out of the bag. */
+/** A player, or a computer, sat down after the last seat with the next hand out of the bag.
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @param seat - The local name and computer flag for the joining player.
+ * @returns A player, or a computer, sat down after the last seat with the next hand out of the bag.
+ * @example
+ * ```ts
+ * import { joinParty, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(joinParty(game,{name:"Seat 3"}).players.length);
+ * ```
+ */
 export declare function joinParty(game: PartyGame, seat: PartySeat): PartyGame;
-/** Why this player cannot leave now, or null when they can. */
+/** Why this player cannot leave now, or null when they can.
+ *
+ * @example
+ * ```ts
+ * import type { LeaveRefusal } from "@johnmorrisdotca/kumimoji";
+ *
+ * const value: LeaveRefusal = "lastPerson";
+ * console.log(value);
+ * ```
+ */
 export type LeaveRefusal = "over" | "out" | "lastPerson";
-/** Why the player at seat `at` cannot leave now, or null when they can. */
+/** Why the player at seat `at` cannot leave now, or null when they can.
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @param at - The word offset, seat index or date specified by this signature.
+ * @returns Why the player at seat `at` cannot leave now, or null when they can.
+ * @example
+ * ```ts
+ * import { leaveRefused, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(leaveRefused(game,0));
+ * ```
+ */
 export declare function leaveRefused(game: PartyGame, at: number): LeaveRefusal | null;
-/** How many tiles a player would put back in the bag by leaving: their hand and their table. */
+/** How many tiles a player would put back in the bag by leaving: their hand and their table.
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @param at - The word offset, seat index or date specified by this signature.
+ * @returns How many tiles a player would put back in the bag by leaving: their hand and their table.
+ * @example
+ * ```ts
+ * import { startParty, tilesHeldBy } from "@johnmorrisdotca/kumimoji";
+ *
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(tilesHeldBy(game,0));
+ * ```
+ */
 export declare function tilesHeldBy(game: PartyGame, at: number): number;
 /**
  * A PLAYER LEAVES. Their tiles go back into the bag and the bag is shuffled
@@ -51,5 +124,18 @@ export declare function tilesHeldBy(game: PartyGame, at: number): number;
  * round to the next still to have their last turn; a last round with nobody
  * left to play ends. With nobody still in — everybody left has resigned —
  * the game ends tied between them.
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @param at - The word offset, seat index or date specified by this signature.
+ * @returns A PLAYER LEAVES. Their tiles go back into the bag and the bag is shuffled — with the game's own seed and how far it has gone, so the same game left the same way deals the same tiles after a reload. A wild goes back blank.
+ * @example
+ * ```ts
+ * import { leaveParty, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(leaveParty(game,0).players.length);
+ * ```
  */
 export declare function leaveParty(game: PartyGame, at: number): PartyGame;

package/dist/partySeats.js

@@ -2,7 +2,20 @@ import { seededRandom, shuffled } from "./random.js";
 import { computerName, isComputer, nextIn, partyTilesLeft, stillIn, tableTally, tidyName } from "./party.js";
 import { tileFace } from "./tileFace.js";
 import { KUMIMOJI_PARTY } from "./tiles.constants.js";
-/** Why nobody can join the table now, or null when a hand can be dealt. */
+/** Why nobody can join the table now, or null when a hand can be dealt.
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @returns Why nobody can join the table now, or null when a hand can be dealt.
+ * @example
+ * ```ts
+ * import { joinRefused, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(joinRefused(game));
+ * ```
+ */
 export function joinRefused(game) {
     if (game.ending !== null)
         return "over";
@@ -14,7 +27,21 @@ export function joinRefused(game) {
         return "bag";
     return null;
 }
-/** A player, or a computer, sat down after the last seat with the next hand out of the bag. */
+/** A player, or a computer, sat down after the last seat with the next hand out of the bag.
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @param seat - The local name and computer flag for the joining player.
+ * @returns A player, or a computer, sat down after the last seat with the next hand out of the bag.
+ * @example
+ * ```ts
+ * import { joinParty, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(joinParty(game,{name:"Seat 3"}).players.length);
+ * ```
+ */
 export function joinParty(game, seat) {
     if (joinRefused(game) !== null)
         return game;
@@ -33,7 +60,21 @@ function freePlayerName(players) {
         if (!taken.has(`Player ${number}`))
             return `Player ${number}`;
 }
-/** Why the player at seat `at` cannot leave now, or null when they can. */
+/** Why the player at seat `at` cannot leave now, or null when they can.
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @param at - The word offset, seat index or date specified by this signature.
+ * @returns Why the player at seat `at` cannot leave now, or null when they can.
+ * @example
+ * ```ts
+ * import { leaveRefused, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(leaveRefused(game,0));
+ * ```
+ */
 export function leaveRefused(game, at) {
     if (game.ending !== null || game.players[at] === undefined)
         return "over";
@@ -43,7 +84,21 @@ export function leaveRefused(game, at) {
         return "lastPerson";
     return null;
 }
-/** How many tiles a player would put back in the bag by leaving: their hand and their table. */
+/** How many tiles a player would put back in the bag by leaving: their hand and their table.
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @param at - The word offset, seat index or date specified by this signature.
+ * @returns How many tiles a player would put back in the bag by leaving: their hand and their table.
+ * @example
+ * ```ts
+ * import { startParty, tilesHeldBy } from "@johnmorrisdotca/kumimoji";
+ *
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(tilesHeldBy(game,0));
+ * ```
+ */
 export function tilesHeldBy(game, at) {
     const player = game.players[at];
     return player === undefined ? 0 : player.hand.length + player.tiles.size;
@@ -63,6 +118,19 @@ export function tilesHeldBy(game, at) {
  * round to the next still to have their last turn; a last round with nobody
  * left to play ends. With nobody still in — everybody left has resigned —
  * the game ends tied between them.
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @param at - The word offset, seat index or date specified by this signature.
+ * @returns A PLAYER LEAVES. Their tiles go back into the bag and the bag is shuffled — with the game's own seed and how far it has gone, so the same game left the same way deals the same tiles after a reload. A wild goes back blank.
+ * @example
+ * ```ts
+ * import { leaveParty, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(leaveParty(game,0).players.length);
+ * ```
  */
 export function leaveParty(game, at) {
     if (leaveRefused(game, at) !== null)

package/dist/partyTurns.d.ts

@@ -7,17 +7,72 @@ import type { TileWords } from "./tileWords.ts";
  * solo game's (`play.ts`), and the deal and the draw are `party.ts`'s. Pure:
  * each returns a new game, or the one it was given where the move is refused.
  */
-/** Whether the game is over. */
+/** Whether the game is over.
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @returns Whether the game is over.
+ * @example
+ * ```ts
+ * import { isOver, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(isOver(game));
+ * ```
+ */
 export declare function isOver(game: PartyGame): boolean;
 /**
  * Whether the player whose turn it is would go out with Done: their hand
  * used, their grid sound, and too few tiles in the bag for everybody still in
  * to draw.
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @param verdict - The native word and connectivity verdict for this grid.
+ * @returns Whether the player whose turn it is would go out with Done: their hand used, their grid sound, and too few tiles in the bag for everybody still in to draw.
+ * @example
+ * ```ts
+ * import { loadTileWordsFromModule } from "@johnmorrisdotca/kumimoji/words";
+ * import { goesOut, judgeWithWords, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const words = await loadTileWordsFromModule("english");
+ * const verdict = judgeWithWords(new Map([["0,0","c"],["0,1","a"],["0,2","t"]]),words);
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(goesOut(game,verdict));
+ * ```
  */
 export declare function goesOut(game: PartyGame, verdict: GridVerdict): boolean;
-/** Whether the player whose turn it is has laid a tile on their table this turn: more tiles there than when it began. */
+/** Whether the player whose turn it is has laid a tile on their table this turn: more tiles there than when it began.
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @returns Whether the player whose turn it is has laid a tile on their table this turn: more tiles there than when it began.
+ * @example
+ * ```ts
+ * import { laidThisTurn, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(laidThisTurn(game));
+ * ```
+ */
 export declare function laidThisTurn(game: PartyGame): boolean;
-/** Whether the player whose turn it is is the only one still in: everybody else has resigned. */
+/** Whether the player whose turn it is is the only one still in: everybody else has resigned.
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @returns Whether the player whose turn it is is the only one still in: everybody else has resigned.
+ * @example
+ * ```ts
+ * import { lastStanding, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(lastStanding(game));
+ * ```
+ */
 export declare function lastStanding(game: PartyGame): boolean;
 /**
  * A HAND THAT SPELLS NOTHING MUST BE TRADED. John, 2026-09-28: "If no words
@@ -26,14 +81,59 @@ export declare function lastStanding(game: PartyGame): boolean;
  * spell no word, has laid nothing on (or lifted nothing from) their table this
  * turn, and has not traded — unless the bag cannot give three, when there is
  * nothing to trade for. `handSpells` answers for a hand (`handCanSpell`).
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @param handSpells - Whether a hand can form any accepted word.
+ * @returns A HAND THAT SPELLS NOTHING MUST BE TRADED. John, 2026-09-28: "If no words can be formed which is possible, they must dump a tile to get 3 more. Easy rule." So Done waits while the player whose turn it is holds tiles that spell no word, has laid nothing on (or lifted nothing from) their table this turn, and has not traded — unless the bag cannot give three, when there is nothing to trade for. `handSpells` answers for a hand (`handCanSpell`).
+ * @example
+ * ```ts
+ * import { loadTileWordsFromModule } from "@johnmorrisdotca/kumimoji/words";
+ * import { handCanSpell, mustTradeFirst, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const words = await loadTileWordsFromModule("english");
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(mustTradeFirst(game,hand=>handCanSpell(hand,words)));
+ * ```
  */
 export declare function mustTradeFirst(game: PartyGame, handSpells: (hand: readonly string[]) => boolean): boolean;
-/** Whether a hand can spell a word from the list: any word of two tiles or more, a wild counting as able to be anything. */
+/** Whether a hand can spell a word from the list: any word of two tiles or more, a wild counting as able to be anything.
+ *
+ * @param hand - The hand size or tile codes, as declared by the function signature.
+ * @param words - The loaded native language word list and tile mappings.
+ * @returns Whether a hand can spell a word from the list: any word of two tiles or more, a wild counting as able to be anything.
+ * @example
+ * ```ts
+ * import { loadTileWordsFromModule } from "@johnmorrisdotca/kumimoji/words";
+ * import { handCanSpell } from "@johnmorrisdotca/kumimoji";
+ *
+ * const words = await loadTileWordsFromModule("english");
+ * console.log(handCanSpell(["c","a","t"],words));
+ * ```
+ */
 export declare function handCanSpell(hand: readonly string[], words: TileWords): boolean;
 /**
  * Why Done cannot be pressed now, or null when it can: a hand to trade first,
  * or, for the last one standing, no tile laid on a sound grid yet (a hand
  * already used on a sound grid has nothing left to lay, and wins as it is).
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @param verdict - The native word and connectivity verdict for this grid.
+ * @param handSpells - Whether a hand can form any accepted word.
+ * @returns Why Done cannot be pressed now, or null when it can: a hand to trade first, or, for the last one standing, no tile laid on a sound grid yet (a hand already used on a sound grid has nothing left to lay, and wins as it is).
+ * @example
+ * ```ts
+ * import { loadTileWordsFromModule } from "@johnmorrisdotca/kumimoji/words";
+ * import { doneRefused, handCanSpell, judgeWithWords, seatPlay, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const words = await loadTileWordsFromModule("english");
+ * const tiles = new Map([["0,0","c"],["0,1","a"],["0,2","t"]]);
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(doneRefused(game,judgeWithWords(seatPlay(game).tiles,words),hand=>handCanSpell(hand,words)));
+ * ```
  */
 export declare function doneRefused(game: PartyGame, verdict: GridVerdict, handSpells: (hand: readonly string[]) => boolean): "trade" | "standing" | null;
 /**
@@ -46,6 +146,23 @@ export declare function doneRefused(game: PartyGame, verdict: GridVerdict, handS
  * The last one standing, everybody else resigned, wins by laying a tile on a
  * sound grid and pressing Done. `verdict` is the grid of the player whose turn
  * it is. Refused, the game given back as it was, while `doneRefused` says so.
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @param verdict - The native word and connectivity verdict for this grid.
+ * @param handSpells - Whether a hand can form any accepted word.
+ * @returns DONE: the end of a turn, and the device passed on. Before anybody is out, to the next player still in. A player who goes out with it starts the last round: everybody else still in, in order from the next, has one last turn, and any of them who goes out on it shares the win (John, 2026-09-28: "Sharing the win is correct"). After the last of those, the game is over.
+ * @example
+ * ```ts
+ * import { loadTileWordsFromModule } from "@johnmorrisdotca/kumimoji/words";
+ * import { endTurn, handCanSpell, judgeWithWords, seatPlay, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const words = await loadTileWordsFromModule("english");
+ * const tiles = new Map([["0,0","c"],["0,1","a"],["0,2","t"]]);
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(endTurn(game,judgeWithWords(seatPlay(game).tiles,words),hand=>handCanSpell(hand,words)).turn);
+ * ```
  */
 export declare function endTurn(game: PartyGame, verdict: GridVerdict, handSpells: (hand: readonly string[]) => boolean): PartyGame;
 /**
@@ -53,6 +170,18 @@ export declare function endTurn(game: PartyGame, verdict: GridVerdict, handSpell
  * give a trade, so nothing more can be got from it. John, 2026-09-28:
  * "Perhaps we offer a resign button only when there are no remaining tiles
  * they can get from the bag."
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @returns Whether the player whose turn it is may resign: only once the bag cannot give a trade, so nothing more can be got from it. John, 2026-09-28: "Perhaps we offer a resign button only when there are no remaining tiles they can get from the bag."
+ * @example
+ * ```ts
+ * import { mayResign, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(mayResign(game));
+ * ```
  */
 export declare function mayResign(game: PartyGame): boolean;
 /**
@@ -63,13 +192,50 @@ export declare function mayResign(game: PartyGame): boolean;
  * resigned too — it ends tied between everybody who resigned since a player
  * still in last pressed Done. John: "if you resign, as the turns pass, if
  * someone else can't go and has to resign then they are tied."
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @returns RESIGN: the player whose turn it is is out of the game, their table kept for the finish, and their turn passed over from then on. In the last round it is their last turn ended without going out. Otherwise the game goes on with whoever is still in; and when nobody is — the last one standing resigned too — it ends tied between everybody who resigned since a player still in last pressed Done. John: "if you resign, as the turns pass, if someone else can't go and has to resign then they are tied."
+ * @example
+ * ```ts
+ * import { resign, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(resign(game));
+ * ```
  */
 export declare function resign(game: PartyGame): PartyGame;
 /**
  * The winners of a finished game, by place: everybody who went out; the last
  * one standing; or, tied, the final run of resignations. Empty while it is
  * played.
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @returns The winners of a finished game, by place: everybody who went out; the last one standing; or, tied, the final run of resignations. Empty while it is played.
+ * @example
+ * ```ts
+ * import { startParty, winnersOf } from "@johnmorrisdotca/kumimoji";
+ *
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(winnersOf(game));
+ * ```
  */
 export declare function winnersOf(game: PartyGame): readonly number[];
-/** Whether the turn now being played is a player's last. */
+/** Whether the turn now being played is a player's last.
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @returns Whether the turn now being played is a player's last.
+ * @example
+ * ```ts
+ * import { isLastTurn, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(isLastTurn(game));
+ * ```
+ */
 export declare function isLastTurn(game: PartyGame): boolean;