import type { Blocked, CheckersRules, DrawLimit, GameSettings, Handicap, HeadStart, Hot, Point, Stone, Worm } from "./types.ts"; /** The black and white stone labels. * * @example * ```ts * import { STONES } from "@johnmorrisdotca/narabe"; * console.log(STONES); * ``` */ export declare const STONES: { readonly black: "black"; readonly white: "white"; }; /** The unavailable-cell marker. * * @example * ```ts * import { BLOCKED } from "@johnmorrisdotca/narabe"; * console.log(BLOCKED); * ``` */ export declare const BLOCKED: Blocked; /** The cell marker that counts as either colour in a line. * * @example * ```ts * import { HOT } from "@johnmorrisdotca/narabe"; * console.log(HOT); * ``` */ export declare const HOT: Hot; /** The linked wormhole-cell marker. * * @example * ```ts * import { WORM } from "@johnmorrisdotca/narabe"; * console.log(WORM); * ``` */ export declare const WORM: Worm; /** Seeds are 31-bit integers, small enough for every store and reproducible everywhere. * * @example * ```ts * import { SEED_RANGE } from "@johnmorrisdotca/narabe"; * console.log(SEED_RANGE); * ``` */ export declare const SEED_RANGE: number; /** The stable identifiers for all fifty-two rule variants. * * @example * ```ts * import { RULE_VARIANTS } from "@johnmorrisdotca/narabe"; * console.log(RULE_VARIANTS); * ``` */ export declare const RULE_VARIANTS: { readonly freestyle: "freestyle"; readonly standard: "standard"; readonly renju: "renju"; readonly omok: "omok"; readonly caro: "caro"; readonly ninuki: "ninuki"; readonly connect6: "connect6"; readonly tictactoe: "tictactoe"; readonly trapThree: "trapThree"; readonly dropFour: "dropFour"; readonly twistFive: "twistFive"; readonly twistFour: "twistFour"; readonly squareFour: "squareFour"; readonly nineMensMorris: "nineMensMorris"; readonly breakthrough: "breakthrough"; readonly linesOfAction: "linesOfAction"; readonly amazons: "amazons"; readonly ringDrop: "ringDrop"; readonly holeDrop: "holeDrop"; readonly hotDrop: "hotDrop"; readonly clearDrop: "clearDrop"; readonly giveawayDrop: "giveawayDrop"; readonly edgeDrop: "edgeDrop"; readonly dominoFive: "dominoFive"; readonly blockFive: "blockFive"; readonly sannuki: "sannuki"; readonly wormDrop: "wormDrop"; readonly misereFive: "misereFive"; readonly makerBreaker: "makerBreaker"; readonly wildTicTacToe: "wildTicTacToe"; readonly notakto: "notakto"; readonly toroidalFive: "toroidalFive"; readonly obstacleFive: "obstacleFive"; readonly rockfall: "rockfall"; readonly scatteredRocks: "scatteredRocks"; readonly reversi: "reversi"; readonly classicReversi: "classicReversi"; readonly antiReversi: "antiReversi"; readonly miniReversi: "miniReversi"; readonly grandReversi: "grandReversi"; readonly honeycomb: "honeycomb"; readonly halma: "halma"; readonly hex: "hex"; readonly hexFive: "hexFive"; readonly checkers: "checkers"; readonly internationalDraughts: "internationalDraughts"; readonly brazilianDraughts: "brazilianDraughts"; readonly canadianCheckers: "canadianCheckers"; readonly russianDraughts: "russianDraughts"; readonly poolCheckers: "poolCheckers"; readonly chineseCheckers: "chineseCheckers"; readonly go: "go"; }; /** The supported board edge-wrapping modes. * * @example * ```ts * import { WRAP_MODES } from "@johnmorrisdotca/narabe"; * console.log(WRAP_MODES); * ``` */ export declare const WRAP_MODES: { readonly none: "none"; readonly columns: "columns"; readonly both: "both"; }; /** The domino and tetromino queue identifiers. * * @example * ```ts * import { PIECE_QUEUES } from "@johnmorrisdotca/narabe"; * console.log(PIECE_QUEUES); * ``` */ export declare const PIECE_QUEUES: { readonly domino: "domino"; readonly tetro: "tetro"; }; /** How many queued pieces a player is shown ahead of the one in hand. * * @example * ```ts * import { PIECE_PREVIEW } from "@johnmorrisdotca/narabe"; * console.log(PIECE_PREVIEW); * ``` */ export declare const PIECE_PREVIEW = 3; /** A pass has no point on the board. * * @example * ```ts * import { NO_POINT } from "@johnmorrisdotca/narabe"; * console.log(NO_POINT); * ``` */ export declare const NO_POINT: Point; /** The variants in the order the browser and the filters list them. * * @example * ```ts * import { RULE_VARIANT_LIST } from "@johnmorrisdotca/narabe"; * console.log(RULE_VARIANT_LIST); * ``` */ export declare const RULE_VARIANT_LIST: readonly ["freestyle", "standard", "renju", "omok", "caro", "ninuki", "sannuki", "connect6", "misereFive", "toroidalFive", "obstacleFive", "scatteredRocks", "rockfall", "makerBreaker", "dominoFive", "blockFive", "dropFour", "ringDrop", "holeDrop", "hotDrop", "clearDrop", "giveawayDrop", "edgeDrop", "wormDrop", "twistFive", "twistFour", "trapThree", "squareFour", "nineMensMorris", "breakthrough", "linesOfAction", "amazons", "tictactoe", "wildTicTacToe", "notakto", "reversi", "classicReversi", "antiReversi", "miniReversi", "grandReversi", "honeycomb", "halma", "hex", "hexFive", "checkers", "internationalDraughts", "brazilianDraughts", "canadianCheckers", "russianDraughts", "poolCheckers", "chineseCheckers", "go"]; /** The free, dropped and supported-edge placement modes. * * @example * ```ts * import { PLACEMENTS } from "@johnmorrisdotca/narabe"; * console.log(PLACEMENTS); * ``` */ export declare const PLACEMENTS: { readonly free: "free"; readonly drop: "drop"; readonly edge: "edge"; }; /** Where a game's stones sit when it is drawn its own way: on the crossings, or in the squares. * * @example * ```ts * import { BOARD_GRIDS } from "@johnmorrisdotca/narabe"; * console.log(BOARD_GRIDS); * ``` */ export declare const BOARD_GRIDS: { readonly lines: "lines"; readonly cells: "cells"; }; /** The traditional head starts, see TraditionalHeadStart. * * @example * ```ts * import { TRADITIONAL_HEAD_STARTS } from "@johnmorrisdotca/narabe"; * console.log(TRADITIONAL_HEAD_STARTS); * ``` */ export declare const TRADITIONAL_HEAD_STARTS: { readonly stones: "stones"; readonly corners: "corners"; readonly men: "men"; }; /** The stable identifiers for supported opening protocols. * * @example * ```ts * import { OPENING_RULES } from "@johnmorrisdotca/narabe"; * console.log(OPENING_RULES); * ``` */ export declare const OPENING_RULES: { readonly free: "free"; readonly pro: "pro"; readonly longPro: "longPro"; readonly swap: "swap"; readonly swap2: "swap2"; readonly rif: "rif"; readonly sakata: "sakata"; readonly tarannikov: "tarannikov"; }; /** All supported opening identifiers in display order. * * @example * ```ts * import { OPENING_RULE_LIST } from "@johnmorrisdotca/narabe"; * console.log(OPENING_RULE_LIST); * ``` */ export declare const OPENING_RULE_LIST: readonly ["free", "pro", "longPro", "swap", "swap2", "rif", "sakata", "tarannikov"]; /** The at-least, exact and open-exact winning line modes. * * @example * ```ts * import { LINE_RULES } from "@johnmorrisdotca/narabe"; * console.log(LINE_RULES); * ``` */ export declare const LINE_RULES: { readonly atLeast: "atLeast"; readonly exact: "exact"; readonly exactOpen: "exactOpen"; }; /** The named forbidden shapes checked by line games. * * @example * ```ts * import { FORBIDDEN_PATTERNS } from "@johnmorrisdotca/narabe"; * console.log(FORBIDDEN_PATTERNS); * ``` */ export declare const FORBIDDEN_PATTERNS: { readonly doubleThree: "doubleThree"; readonly doubleFour: "doubleFour"; readonly overline: "overline"; }; /** The recorded reasons a game is won. * * @example * ```ts * import { WIN_REASONS } from "@johnmorrisdotca/narabe"; * console.log(WIN_REASONS); * ``` */ export declare const WIN_REASONS: { readonly line: "line"; readonly captures: "captures"; readonly time: "time"; readonly resign: "resign"; readonly trap: "trap"; readonly square: "square"; readonly full: "full"; readonly count: "count"; readonly camp: "camp"; readonly connection: "connection"; readonly blocked: "blocked"; readonly territory: "territory"; readonly reduced: "reduced"; readonly reached: "reached"; readonly joined: "joined"; }; /** The stages of the opening protocol. * * @example * ```ts * import { OPENING_STAGES } from "@johnmorrisdotca/narabe"; * console.log(OPENING_STAGES); * ``` */ export declare const OPENING_STAGES: { readonly placing: "placing"; readonly choosing: "choosing"; readonly extending: "extending"; readonly done: "done"; }; /** The one opening choice that is not a colour. * * @example * ```ts * import { OPENING_CHOICE_EXTEND } from "@johnmorrisdotca/narabe"; * console.log(OPENING_CHOICE_EXTEND); * ``` */ export declare const OPENING_CHOICE_EXTEND: "extend"; /** Stones in a line needed to win, unless a variant pins it. * * @example * ```ts * import { WIN_LENGTH } from "@johnmorrisdotca/narabe"; * console.log(WIN_LENGTH); * ``` */ export declare const WIN_LENGTH = 5; /** Line lengths a player may pick in the variants that leave it open. * * @example * ```ts * import { WIN_LENGTHS } from "@johnmorrisdotca/narabe"; * console.log(WIN_LENGTHS); * ``` */ export declare const WIN_LENGTHS: readonly [4, 5, 6]; /** Enemy stones to capture for a win in the capture game: five pairs. * * @example * ```ts * import { DEFAULT_CAPTURES_TO_WIN } from "@johnmorrisdotca/narabe"; * console.log(DEFAULT_CAPTURES_TO_WIN); * ``` */ export declare const DEFAULT_CAPTURES_TO_WIN = 10; /** The handicap toggles, in the order the settings list them. * * @example * ```ts * import { HANDICAP_RULES } from "@johnmorrisdotca/narabe"; * console.log(HANDICAP_RULES); * ``` */ export declare const HANDICAP_RULES: readonly ["doubleThree", "doubleFour", "overline", "exactLine", "openLine", "longerLine", "singleStone", "noCaptures"]; /** Half-widths of the central square a handicapped second stone must leave. * * @example * ```ts * import { SECOND_STONE_EXCLUSIONS } from "@johnmorrisdotca/narabe"; * console.log(SECOND_STONE_EXCLUSIONS); * ``` */ export declare const SECOND_STONE_EXCLUSIONS: readonly [0, 2, 3]; /** The default terms with no colour-bound rule restrictions. * * @example * ```ts * import { NO_HANDICAP } from "@johnmorrisdotca/narabe"; * console.log(NO_HANDICAP); * ``` */ export declare const NO_HANDICAP: Handicap; /** Nobody given a start: the even game, which is most games. * * @example * ```ts * import { NO_HEAD_START } from "@johnmorrisdotca/narabe"; * console.log(NO_HEAD_START); * ``` */ export declare const NO_HEAD_START: HeadStart; /** The free turns a head start may give, none included. John chose one to three. * * @example * ```ts * import { HEAD_START_FREE_TURNS } from "@johnmorrisdotca/narabe"; * console.log(HEAD_START_FREE_TURNS); * ``` */ export declare const HEAD_START_FREE_TURNS: readonly [0, 1, 2, 3]; /** The fixed, laid or absent starting-disc layouts. * * @example * ```ts * import { STARTING_DISCS } from "@johnmorrisdotca/narabe"; * console.log(STARTING_DISCS); * ``` */ export declare const STARTING_DISCS: { readonly none: "none"; readonly fixed: "fixed"; readonly laid: "laid"; }; /** The free-choice and maximum-capture draughts modes. * * @example * ```ts * import { CAPTURE_CHOICES } from "@johnmorrisdotca/narabe"; * console.log(CAPTURE_CHOICES); * ``` */ export declare const CAPTURE_CHOICES: { readonly free: "free"; readonly maximum: "maximum"; }; /** The supported promotion behavior during a capture chain. * * @example * ```ts * import { CROWN_MID_CAPTURE } from "@johnmorrisdotca/narabe"; * console.log(CROWN_MID_CAPTURE); * ``` */ export declare const CROWN_MID_CAPTURE: { readonly stops: "stops"; readonly continues: "continues"; readonly passes: "passes"; }; /** The specific-ending and material-balance draw count modes. * * @example * ```ts * import { ENDGAME_COUNT_KINDS } from "@johnmorrisdotca/narabe"; * console.log(ENDGAME_COUNT_KINDS); * ``` */ export declare const ENDGAME_COUNT_KINDS: { readonly endings: "endings"; readonly balance: "balance"; }; /** The reasons a move list is restricted to captures. * * @example * ```ts * import { MOVE_NARROWINGS } from "@johnmorrisdotca/narabe"; * console.log(MOVE_NARROWINGS); * ``` */ export declare const MOVE_NARROWINGS: { readonly capture: "capture"; readonly mostCaptured: "mostCaptured"; }; /** The piece-moving and stone-placement choice modes. * * @example * ```ts * import { TURN_CHOICE_KINDS } from "@johnmorrisdotca/narabe"; * console.log(TURN_CHOICE_KINDS); * ``` */ export declare const TURN_CHOICE_KINDS: { readonly move: "move"; readonly place: "place"; }; /** * English draughts, American checkers: three rows of men, a man takes forward * only, a king moves one square, any capture may be chosen, and a man crowned * by a capture ends the move there. Exactly what rules/checkers.ts did before * any of this was data, and the Checkers tests that predate it still say so. * * @example * ```ts * import { ENGLISH_CHECKERS_RULES } from "@johnmorrisdotca/narabe"; * console.log(ENGLISH_CHECKERS_RULES); * ``` */ export declare const ENGLISH_CHECKERS_RULES: CheckersRules; /** * International draughts, from the FMJD's official rules (Annex 1, 2018, and * the 2024 Annexes). Men take both ways (4.1), kings fly (3.9, 4.3), the * capture taking the most pieces is compulsory with a king counting as one * piece (4.13), a man crossing the far row mid-capture stays a man (4.15), and * taken pieces come off only once the capture is over and may not be jumped * twice (4.8, 4.11). * * The draws of article 6: a third repetition with the same side to move * (6.1); three pieces, one at least a king, against a lone king, sixteen more * moves each (6.3); two kings, a king and a man, or a king against a lone king, * five more moves each (6.4). The twenty-five-move kings-only count (6.2) is * the no-progress rule in rules/noProgress.ts. * * NOT APPLIED: the 2024 clause that cuts 6.3's sixteen moves to five when the * lone king "solely occupies" the long diagonal. The text does not say whether * the king must hold the diagonal from the start of the count or at its end, * nor what leaving it does, and a rule this site cannot read exactly must not * fire. Without it those endings run to sixteen moves each, which is the older * rule and the generous side of the new one. * * @example * ```ts * import { INTERNATIONAL_DRAUGHTS_RULES } from "@johnmorrisdotca/narabe"; * console.log(INTERNATIONAL_DRAUGHTS_RULES); * ``` */ export declare const INTERNATIONAL_DRAUGHTS_RULES: CheckersRules; /** * Brazilian draughts: the international rules of capture and crowning on 8×8, * with twelve men, and the draws of the Brazilian confederation's own rules * (CBJD, Regras Oficiais) rather than the FMJD's 8×8 set, which differs. A * third repetition (art. 98), and five moves each for the small endings of * art. 99: two kings against two, two kings against one, two kings against a * king and a man, a king against a king, a king against a king and a man. Its * twenty-move kings-only count is in rules/noProgress.ts. * * NOT APPLIED: art. 100, five moves for three pieces against a lone king on the * long diagonal, for the same reason as the FMJD's version of it above. With * it left out, those endings are bounded by the kings-only count instead. * * @example * ```ts * import { BRAZILIAN_DRAUGHTS_RULES } from "@johnmorrisdotca/narabe"; * console.log(BRAZILIAN_DRAUGHTS_RULES); * ``` */ export declare const BRAZILIAN_DRAUGHTS_RULES: CheckersRules; /** * Canadian checkers: the international rules on 12×12, thirty men a side in * five rows. No federation's draw rules for it could be found — the Quebec * association's own site did not answer — so its draws are the FMJD's, * borrowed, and its rules page says so. * * @example * ```ts * import { CANADIAN_CHECKERS_RULES } from "@johnmorrisdotca/narabe"; * console.log(CANADIAN_CHECKERS_RULES); * ``` */ export declare const CANADIAN_CHECKERS_RULES: CheckersRules; /** * Russian draughts (shashki), from the Russian Draughts Federation's rules * (ФШР, shashki.ru) and the FMJD/IDF rules for 8×8 draughts: men take both ways, * kings fly, any capture may be chosen whatever it takes (FMJD-64 4.13), and a * man that reaches the far row in the middle of a capture is crowned there and * carries on capturing as a king (4.14). * * Draws, as the federation writes them: a third repetition with the same side * to move; three kings or more that have not taken a lone king by their * fifteenth move, counted from when that balance arose; and any ending in which * both sides have a king and nothing is taken or crowned for five moves (two or * three pieces on the board), thirty (four or five) or sixty (six or seven). * Fifteen moves of kings alone is rules/noProgress.ts. * * NOT APPLIED: the five-move count for three pieces against a lone king on the * main road, for the reason given at INTERNATIONAL_DRAUGHTS_RULES; the "clearly * drawn position", which is an arbiter's judgement and not a count; and the * three-kings rule's "or kings and men", which the federation's own text leaves * unclear. It is read as kings alone, the narrower reading, so it never draws a * game it might not apply to. * * @example * ```ts * import { RUSSIAN_DRAUGHTS_RULES } from "@johnmorrisdotca/narabe"; * console.log(RUSSIAN_DRAUGHTS_RULES); * ``` */ export declare const RUSSIAN_DRAUGHTS_RULES: CheckersRules; /** * Pool checkers, from the American Pool Checker Association's Tournament Rules * of Play (2016): men take both ways (rule 14), kings fly (15, 18), any capture * may be chosen — "not compelled to take the greater or lesser number" (20) — * and a capture once begun is completed (21). A man that must jump on out of * the king row stays a man, and one whose move ends there is crowned (22, 23). * Black moves first (7). * * The one count of the APCA's this site can read is the thirteen count (27): * three kings against a lone king, all four kings, drawn once the lone king has * made thirteen moves. Counted here as thirteen moves each, which is that * exactly when the lone king moves second in the ending and one move later for * the stronger side when it moves first — the generous side. There is no * repetition rule: the APCA has none outside its thirty-move rule. * * NOT APPLIED: the thirty-move rule (26), which the weaker side announces and * counts, in endgames the players themselves identify. Nobody announces * anything here, and a count that fired unasked would be a different rule. Nor * the five-move count for a lone king on the long line (28), as above. A game * going nowhere is ended instead by the site's own forty-move count in * rules/noProgress.ts, the same as Checkers', and the rules page says so. * * @example * ```ts * import { POOL_CHECKERS_RULES } from "@johnmorrisdotca/narabe"; * console.log(POOL_CHECKERS_RULES); * ``` */ export declare const POOL_CHECKERS_RULES: CheckersRules; /** The playing, won and drawn outcome labels. * * @example * ```ts * import { GAME_STATUS } from "@johnmorrisdotca/narabe"; * console.log(GAME_STATUS); * ``` */ export declare const GAME_STATUS: { readonly playing: "playing"; readonly won: "won"; readonly draw: "draw"; }; /** The stable labels used in move records. * * @example * ```ts * import { MOVE_KINDS } from "@johnmorrisdotca/narabe"; * console.log(MOVE_KINDS); * ``` */ export declare const MOVE_KINDS: { readonly place: "place"; readonly skip: "skip"; readonly move: "move"; readonly piece: "piece"; readonly pass: "pass"; readonly forfeit: "forfeit"; readonly remove: "remove"; readonly shoot: "shoot"; }; /** How a written move list says the two moves that have no point. * * @example * ```ts * import { STONELESS_WORDS } from "@johnmorrisdotca/narabe"; * console.log(STONELESS_WORDS); * ``` */ export declare const STONELESS_WORDS: { readonly pass: "pass"; readonly forfeit: "timed out"; }; /** The first and second player seat labels. * * @example * ```ts * import { SEATS } from "@johnmorrisdotca/narabe"; * console.log(SEATS); * ``` */ export declare const SEATS: { readonly one: "one"; readonly two: "two"; }; /** The supported opening colours and random opener choice. * * @example * ```ts * import { FIRST_PLAYERS } from "@johnmorrisdotca/narabe"; * console.log(FIRST_PLAYERS); * ``` */ export declare const FIRST_PLAYERS: { readonly black: "black"; readonly white: "white"; readonly random: "random"; }; /** The native empty and star-point obstacle layouts. * * @example * ```ts * import { OBSTACLE_LAYOUTS } from "@johnmorrisdotca/narabe"; * console.log(OBSTACLE_LAYOUTS); * ``` */ export declare const OBSTACLE_LAYOUTS: { readonly none: "none"; readonly hoshi: "hoshi"; }; /** Board is `size` × `size`. The mini boards make for much shorter games. * * @example * ```ts * import { BOARD_SIZES } from "@johnmorrisdotca/narabe"; * console.log(BOARD_SIZES); * ``` */ export declare const BOARD_SIZES: readonly [9, 13, 15, 19]; /** Every size any game here is played on, for the schemas at the API edge. * * @example * ```ts * import { ALL_BOARD_SIZES } from "@johnmorrisdotca/narabe"; * console.log(ALL_BOARD_SIZES); * ``` */ export declare const ALL_BOARD_SIZES: readonly [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 17, 19]; /** The default side length for an unconstrained board. * * @example * ```ts * import { DEFAULT_BOARD_SIZE } from "@johnmorrisdotca/narabe"; * console.log(DEFAULT_BOARD_SIZE); * ``` */ export declare const DEFAULT_BOARD_SIZE = 15; /** The default seat-swap allowance for each player. * * @example * ```ts * import { DEFAULT_SWAPS_PER_SEAT } from "@johnmorrisdotca/narabe"; * console.log(DEFAULT_SWAPS_PER_SEAT); * ``` */ export declare const DEFAULT_SWAPS_PER_SEAT = 1; /** * The shares of the board a game may be called a draw at. * * A fraction rather than a number of moves, so one setting means the same * thing on every board: half of a 9x9 is forty moves and half of a 19x19 is * a hundred and eighty, and neither needs anybody to work it out. `none` is * the default and is how every game here behaved before this existed. * * @example * ```ts * import { DRAW_LIMITS } from "@johnmorrisdotca/narabe"; * console.log(DRAW_LIMITS); * ``` */ export declare const DRAW_LIMITS: { readonly none: "none"; readonly half: "half"; readonly threeQuarters: "threeQuarters"; }; /** The selectable configured game-length limits. * * @example * ```ts * import { DRAW_LIMIT_LIST } from "@johnmorrisdotca/narabe"; * console.log(DRAW_LIMIT_LIST); * ``` */ export declare const DRAW_LIMIT_LIST: readonly DrawLimit[]; /** * The rule: what share of the board's points may be played before a game * with no winner is a draw. Null plays it out. Kept apart from the words for * it, which belong to the app that shows them, the way every game's rules are * kept apart from its name and its rules text: one decides what happens, the * other only says it. */ /** * The smallest board a length means anything on, in points. * * Nine by nine. Below it a game is over long before any share of the board * could matter — a 3×3 has nine points and is finished in nine moves, so * "half the board" is four, and cutting a game of noughts and crosses short * at four moves is not a rule, it is a bug with a setting in front of it. * The whole reason for a length is a board big enough that two careful * players can fail to resolve it, and that starts here. * * @example * ```ts * import { DRAW_LIMIT_MIN_POINTS } from "@johnmorrisdotca/narabe"; * console.log(DRAW_LIMIT_MIN_POINTS); * ``` */ export declare const DRAW_LIMIT_MIN_POINTS = 81; /** The board fractions used by configured draw limits. * * @example * ```ts * import { DRAW_LIMIT_SHARE } from "@johnmorrisdotca/narabe"; * console.log(DRAW_LIMIT_SHARE); * ``` */ export declare const DRAW_LIMIT_SHARE: Record; /** The defaults used when creating a game without overrides. * * @example * ```ts * import { DEFAULT_SETTINGS } from "@johnmorrisdotca/narabe"; * console.log(DEFAULT_SETTINGS); * ``` */ export declare const DEFAULT_SETTINGS: GameSettings; /** Black opens unless the settings say otherwise. * * @example * ```ts * import { FIRST_STONE } from "@johnmorrisdotca/narabe"; * console.log(FIRST_STONE); * ``` */ export declare const FIRST_STONE: Stone; export { COLUMN_LETTERS, DIRECTIONS, HEX_LINE_DIRECTIONS, lineDirectionsFor, STAR_POINTS } from "./board.constants.ts";