@betorigami/game-calculations 9.0.0 → 9.0.2

package/dist/index.d.cts

@@ -0,0 +1,1255 @@
+import Big$1, { Big } from "big.js";
+//#region src/cards/types.d.ts
+export declare const MIN_CARD_VALUE = 0;
+export declare const MAX_CARD_VALUE = 51;
+export declare const CARD_VALUES: number[];
+export declare const CARD_SUITS: readonly ["Spades", "Hearts", "Diamonds", "Clubs"];
+export type CardSuit = (typeof CARD_SUITS)[number];
+export declare const CARD_RANKS: readonly ["Ace", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King"];
+export type CardRank = (typeof CARD_RANKS)[number];
+export declare const FACE_CARD_RANKS: readonly CardRank[];
+export type CardValue = (typeof CARD_VALUES)[number];
+export type CardDto = {
+  rank: CardRank;
+  suit: CardSuit;
+  cardValue: CardValue;
+};
+export declare const CARD_SUIT_COLORS: Record<CardSuit, 'red' | 'black'>;
+//#endregion
+//#region src/errors/game.error.d.ts
+export declare enum GameErrorCode {
+  UNSUPPORTED_EDGE = "UNSUPPORTED_EDGE",
+  INPUT_VALIDATION_ERROR = "INPUT_VALIDATION_ERROR"
+}
+export declare class GameError extends Error {
+  static createUnsupportedEdgeError(message: string): GameError;
+  static createValidationError(message: string): GameError;
+  static isGameError(error: unknown): error is GameError;
+  errorCode: GameErrorCode;
+  constructor(errorCode: GameErrorCode, message?: string);
+}
+//#endregion
+//#region src/games/origami-game.d.ts
+export declare enum OrigamiGame {
+  DICE = "DICE",
+  MINES = "MINES",
+  KENO = "KENO",
+  LIMBO = "LIMBO",
+  ADVANCED_DICE = "ADVANCED_DICE",
+  BACCARAT = "BACCARAT",
+  DIAMONDS = "DIAMONDS",
+  PLINKO = "PLINKO",
+  ROULETTE = "ROULETTE",
+  WHEEL = "WHEEL",
+  BLACKJACK = "BLACKJACK",
+  BLITZ = "BLITZ",
+  DARTS = "DARTS"
+}
+//#endregion
+//#region src/games/game.d.ts
+export interface Game {
+  gameId: OrigamiGame;
+  supportedEdgeConfigurations: [number, ...number[]];
+}
+//#endregion
+//#region src/games/random.d.ts
+export type Proof = {
+  proofHash: string;
+  proofString: string;
+};
+export type SingleRandomValue = {
+  value: number;
+  values: number[];
+  count: 1;
+  min: number;
+  max: number;
+} & Proof;
+export type MultipleRandomValues = {
+  values: number[];
+  count: number;
+  min: number;
+  max: number;
+} & Proof;
+export interface RandomNumberGenerator {
+  getRandomInt({ min, max }: {
+    min: number;
+    max: number;
+  }): SingleRandomValue;
+  getUniqueRandomInts({ min, max, count }: {
+    min: number;
+    max: number;
+    count: number;
+  }): MultipleRandomValues;
+  getRandomIntsWithReplacement({ min, max, count }: {
+    min: number;
+    max: number;
+    count: number;
+  }): MultipleRandomValues;
+}
+//#endregion
+//#region src/games/payout.d.ts
+/**
+ * A single exact payout amount from a game round.
+ *
+ * A round returns zero or more legs. Neither their order nor their count is
+ * significant: a leg is not tied to a particular bet, an amount may be zero,
+ * and the number of legs need not match the number of bets placed. The only
+ * supported operation is summing them.
+ *
+ * Amounts are gross — they include returned stake — and unrounded. Rounding to
+ * a currency's precision is the consuming service's decision, not this
+ * package's.
+ */
+export type PayoutLeg = Readonly<{
+  amount: Big$1;
+}>;
+/**
+ * A round's payout, expressed as its constituent legs.
+ */
+export type Payout = Readonly<{
+  legs: readonly PayoutLeg[];
+}>;
+/**
+ * Totals a round's payout.
+ *
+ * Summing the legs is lossless; reconstructing the total from a rounded
+ * payout multiplier is not, so this is the only supported way to arrive at
+ * what a round pays.
+ */
+export declare const sumPayout: (payout: Payout) => Big$1;
+//#endregion
+//#region src/games/single-action-game.d.ts
+export type EmptyGameOutput = {};
+export interface GetGameResultRequest<TGameInputs> {
+  generator: RandomNumberGenerator;
+  edge: number;
+  gameInputs: TGameInputs;
+}
+export interface GameResult<TGameOutputs = EmptyGameOutput> {
+  isFinished: boolean;
+  payout: Payout;
+  payoutMultiplier: Big$1;
+  outputs: TGameOutputs & {
+    result: number[];
+  };
+  randomValues: SingleRandomValue | MultipleRandomValues;
+}
+export declare abstract class SingleActionGame<TGameInputs, TGameOutputs = EmptyGameOutput> implements Game {
+  readonly gameId: OrigamiGame;
+  protected constructor(gameId: OrigamiGame);
+  abstract get supportedEdgeConfigurations(): [number, ...number[]];
+  abstract getBetAmount(gameInputs: TGameInputs): Big$1;
+  getGameResult(request: GetGameResultRequest<TGameInputs>): GameResult<TGameOutputs>;
+  protected abstract determineGameResult(request: GetGameResultRequest<TGameInputs>): GameResult<TGameOutputs>;
+}
+//#endregion
+//#region src/games/advanced-dice/advanced-dice.d.ts
+export type Bounds = {
+  lower: number;
+  upper: number;
+};
+export declare const RANDOM_MIN_VALUE = 0;
+export declare const RANDOM_MAX_VALUE = 10000;
+export declare const EFFECTIVE_RANGE: number;
+export declare const MIN_WIN_CHANCE = 0.01;
+export declare const MAX_WIN_CHANCE = 98;
+export declare const advancedDiceIsWithinBoundsInclusive: (bounds: Bounds, result: number) => boolean;
+export declare const advancedDiceGetInclusiveBoundsRange: (bounds: Bounds) => number;
+export declare const advancedDiceIsWithinBoundsExclusive: (bounds: Bounds, result: number) => boolean;
+export declare const advancedDiceGetExclusiveBoundsRange: (bounds: Bounds) => number;
+export declare enum RollType {
+  ROLL_BETWEEN = "ROLL_BETWEEN",
+  ROLL_OUTSIDE = "ROLL_OUTSIDE",
+  ROLL_BETWEEN_TWO = "ROLL_BETWEEN_TWO"
+}
+export type RollBetween = {
+  mode: RollType.ROLL_BETWEEN;
+  bounds: Bounds;
+  betAmount: Big;
+};
+export type RollOutside = {
+  mode: RollType.ROLL_OUTSIDE;
+  bounds: Bounds;
+  betAmount: Big;
+};
+export type RollBetweenTwo = {
+  mode: RollType.ROLL_BETWEEN_TWO;
+  firstBounds: Bounds;
+  secondBounds: Bounds;
+  betAmount: Big;
+};
+export type AdvancedDiceInputs = RollBetween | RollOutside | RollBetweenTwo;
+export type AdvancedDiceSelection = Pick<RollBetween, 'mode' | 'bounds'> | Pick<RollOutside, 'mode' | 'bounds'> | Pick<RollBetweenTwo, 'mode' | 'firstBounds' | 'secondBounds'>;
+export declare const calculateAdvancedDiceWinChance: (gameInputs: AdvancedDiceSelection) => Big;
+export declare const validateAdvancedDiceInputs: (gameInputs: AdvancedDiceSelection) => void;
+export declare class AdvancedDice extends SingleActionGame<AdvancedDiceInputs> {
+  constructor();
+  get supportedEdgeConfigurations(): [number, ...number[]];
+  getBetAmount(gameInputs: AdvancedDiceInputs): Big;
+  protected determineGameResult({ generator, edge, gameInputs }: GetGameResultRequest<AdvancedDiceInputs>): GameResult;
+}
+//#endregion
+//#region src/games/baccarat/baccarat.d.ts
+export interface Bet {
+  amount: Big$1;
+  type: BaccaratBetType;
+}
+export interface BaccaratGameInputs {
+  bets: Bet[];
+}
+export declare const VALID_SUITS: readonly ["Clubs", "Diamonds", "Hearts", "Spades"];
+export declare const VALID_RANKS: readonly ["Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King"];
+export type Suit = (typeof VALID_SUITS)[number];
+export type Rank = (typeof VALID_RANKS)[number];
+export interface Card {
+  suit: Suit;
+  rank: Rank;
+}
+export declare enum BaccaratOutcome {
+  PLAYER_WIN = "PLAYER_WIN",
+  TIE = "TIE",
+  BANKER_WIN = "BANKER_WIN"
+}
+export declare enum BaccaratBetType {
+  PLAYER = "PLAYER",
+  TIE = "TIE",
+  BANKER = "BANKER"
+}
+export interface BaccaratGameOutputs {
+  playerCards: Card[];
+  playerHandValue: number;
+  bankerCards: Card[];
+  bankerHandValue: number;
+  gameOutcome: BaccaratOutcome;
+}
+export declare const calculateBaccaratBetAmount: (gameInputs: BaccaratGameInputs) => Big$1;
+export declare class Baccarat extends SingleActionGame<BaccaratGameInputs, BaccaratGameOutputs> {
+  constructor();
+  get supportedEdgeConfigurations(): [number, ...number[]];
+  getBetAmount(gameInputs: BaccaratGameInputs): Big$1;
+  protected determineGameResult({ generator, gameInputs }: GetGameResultRequest<BaccaratGameInputs>): GameResult<BaccaratGameOutputs>;
+  private validateGameInputs;
+  private mapRandomValueToCard;
+  private isNaturalWin;
+  private mapRandomValueToCardValue;
+  private shouldDrawThirdPlayerCard;
+  private shouldDrawThirdBankerCard;
+}
+//#endregion
+//#region src/games/blackjack/blackjack.types.d.ts
+export interface BlackjackHandDto {
+  cards: ReadonlyArray<CardDto>;
+  value: number;
+}
+export declare enum BlackjackOutcome {
+  WIN = "WIN",
+  LOSE = "LOSE",
+  PUSH = "PUSH",
+  PLAYER_BLACKJACK = "PLAYER_BLACKJACK"
+}
+export declare enum InsuranceOutcome {
+  WON = "WON",
+  LOST = "LOST"
+}
+export declare enum BlackjackActionType {
+  START = "START",
+  HIT = "BLACKJACK_HIT",
+  STAND = "BLACKJACK_STAND",
+  BUY_INSURANCE = "BLACKJACK_BUY_INSURANCE",
+  REJECT_INSURANCE = "BLACKJACK_REJECT_INSURANCE",
+  DOUBLE_DOWN = "BLACKJACK_DOUBLE_DOWN",
+  SPLIT = "BLACKJACK_SPLIT"
+}
+export declare enum PairBonusType {
+  EXACT_PAIR = "EXACT_PAIR",
+  COLORED_PAIR = "COLORED_PAIR",
+  MIXED_PAIR = "MIXED_PAIR",
+  LOSS = "LOSS"
+}
+export declare enum ThreeCardBonusType {
+  SUITED_TRIPS = "SUITED_TRIPS",
+  STRAIGHT_FLUSH = "STRAIGHT_FLUSH",
+  THREE_OF_A_KIND = "THREE_OF_A_KIND",
+  STRAIGHT = "STRAIGHT",
+  FLUSH = "FLUSH",
+  LOSS = "LOSS"
+}
+export type BetAmounts = Readonly<{
+  mainBetAmount: Big$1;
+  pairBonusAmount: Big$1;
+  threeCardBonusAmount: Big$1;
+}>;
+export type PairBonusResult = Readonly<{
+  betAmount: string;
+  payoutMultiplier: number;
+  result: PairBonusType;
+}>;
+export type ThreeCardBonusResult = Readonly<{
+  betAmount: string;
+  payoutMultiplier: number;
+  result: ThreeCardBonusType;
+}>;
+export type SideBetResults = Readonly<{
+  pairBonus: PairBonusResult | null;
+  threeCardBonus: ThreeCardBonusResult | null;
+}>;
+//#endregion
+//#region src/games/blackjack/blackjack.constants.d.ts
+export declare const BLACKJACK_MULTIPLIER = 2.5;
+export declare const WIN_MULTIPLIER = 2;
+export declare const PUSH_MULTIPLIER = 1;
+export declare const LOSE_MULTIPLIER = 0;
+export declare const DEALER_STAND_VALUE = 17;
+export declare const BUST_VALUE = 21;
+export declare const BLACKJACK_VALUE = 21;
+export declare const MAX_CARDS_PER_ROUND = 63;
+export declare const INSURANCE_BET_SIZE_FACTOR = 0.5;
+export declare const INSURANCE_WIN_MULTIPLIER = 3;
+export declare const DOUBLE_DOWN_BET_SIZE_FACTOR = 1;
+export declare const SPLIT_BET_SIZE_FACTOR = 1;
+export declare const CARDS_PER_SUIT = 13;
+export declare const ACE_SOFT_BONUS = 10;
+export declare const FACE_CARD_VALUE = 10;
+export declare const BASE_PAYOUT_MULTIPLIERS: Record<BlackjackOutcome, number>;
+export declare const PAIR_BONUS_PAYOUTS: Record<PairBonusType, number>;
+export declare const THREE_CARD_BONUS_PAYOUTS: Record<ThreeCardBonusType, number>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/primitive.d.ts
+/**
+Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+
+@category Type
+*/
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/internal/type.d.ts
+/**
+Matches any primitive, `void`, `Date`, or `RegExp` value.
+*/
+type BuiltIns = Primitive | void | Date | RegExp;
+/**
+Test if the given function has multiple call signatures.
+
+Needed to handle the case of a single call signature with properties.
+
+Multiple call signatures cannot currently be supported due to a TypeScript limitation.
+@see https://github.com/microsoft/TypeScript/issues/29732
+*/
+type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> = T extends {
+  (...arguments_: infer A): unknown;
+  (...arguments_: infer B): unknown;
+} ? B extends A ? A extends B ? false : true : true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/simplify.d.ts
+/**
+Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
+};
+
+type SizeProps = {
+	width: number;
+	height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+interface SomeInterface {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+}
+
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+};
+
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+declare function fn(object: Record<string, unknown>): void;
+
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+// @ts-expect-error
+fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
+fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
+```
+
+@link https://github.com/microsoft/TypeScript/issues/15300
+@see {@link SimplifyDeep}
+@category Object
+*/
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType]; } & {};
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/readonly-deep.d.ts
+/**
+Create a deeply immutable version of another type.
+
+This is useful when a deeply nested structure needs to be exposed as completely immutable, for example, an imported JSON module or when receiving an API response that is passed around.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/13923) if you want to have this type as a built-in in TypeScript.
+
+Use [`Readonly<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#readonlytype) if you only need one level deep.
+
+@example
+```
+import type {ReadonlyDeep} from 'type-fest';
+
+declare const foo: {
+	a: string;
+	b: {c: number};
+	d: Array<{e: number}>;
+};
+
+foo.a = 'bar'; // Allowed
+
+foo.b = {c: 3}; // Allowed
+
+foo.b.c = 4; // Allowed
+
+foo.d = [{e: 5}]; // Allowed
+
+foo.d.push({e: 6}); // Allowed
+
+const last = foo.d.at(-1);
+if (last) {
+	last.e = 7; // Allowed
+}
+
+declare const readonlyFoo: ReadonlyDeep<typeof foo>;
+
+// @ts-expect-error
+readonlyFoo.a = 'bar';
+// Error: Cannot assign to 'a' because it is a read-only property.
+
+// @ts-expect-error
+readonlyFoo.b = {c: 3};
+// Error: Cannot assign to 'b' because it is a read-only property.
+
+// @ts-expect-error
+readonlyFoo.b.c = 4;
+// Error: Cannot assign to 'c' because it is a read-only property.
+
+// @ts-expect-error
+readonlyFoo.d = [{e: 5}];
+// Error: Cannot assign to 'd' because it is a read-only property.
+
+// @ts-expect-error
+readonlyFoo.d.push({e: 6});
+// Error: Property 'push' does not exist on type 'ReadonlyArray<{readonly e: number}>'.
+
+const readonlyLast = readonlyFoo.d.at(-1);
+if (readonlyLast) {
+	// @ts-expect-error
+	readonlyLast.e = 8;
+	// Error: Cannot assign to 'e' because it is a read-only property.
+}
+```
+
+Note that types containing overloaded functions are not made deeply readonly due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/29732).
+
+@category Object
+@category Array
+@category Set
+@category Map
+*/
+type ReadonlyDeep<T> = T extends BuiltIns ? T : T extends (new (...arguments_: any[]) => unknown) ? T // Skip class constructors
+ : T extends ((...arguments_: any[]) => unknown) ? {} extends _ReadonlyObjectDeep<T> ? T : HasMultipleCallSignatures<T> extends true ? T : ((...arguments_: Parameters<T>) => ReturnType<T>) & _ReadonlyObjectDeep<T> : T extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>> ? ReadonlyMapDeep<KeyType, ValueType> : T extends Readonly<ReadonlySet<infer ItemType>> ? ReadonlySetDeep<ItemType> :
+// Identify tuples to avoid converting them to arrays inadvertently; special case `readonly [...never[]]`, as it emerges undesirably from recursive invocations of ReadonlyDeep below.
+T extends readonly [] | readonly [...never[]] ? readonly [] : T extends readonly [infer U, ...infer V] ? readonly [ReadonlyDeep<U>, ...ReadonlyDeep<V>] : T extends readonly [...infer U, infer V] ? readonly [...ReadonlyDeep<U>, ReadonlyDeep<V>] : T extends ReadonlyArray<infer ItemType> ? ReadonlyArray<ReadonlyDeep<ItemType>> : T extends object ? _ReadonlyObjectDeep<T> : unknown;
+/**
+Same as `ReadonlyDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `ReadonlyDeep`.
+*/
+type ReadonlyMapDeep<KeyType, ValueType> = {} & Readonly<ReadonlyMap<ReadonlyDeep<KeyType>, ReadonlyDeep<ValueType>>>;
+/**
+Same as `ReadonlyDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `ReadonlyDeep`.
+*/
+type ReadonlySetDeep<ItemType> = {} & Readonly<ReadonlySet<ReadonlyDeep<ItemType>>>;
+/**
+Same as `ReadonlyDeep`, but accepts only `object`s as inputs. Internal helper for `ReadonlyDeep`.
+*/
+type _ReadonlyObjectDeep<ObjectType extends object> = { readonly [KeyType in keyof ObjectType]: ReadonlyDeep<ObjectType[KeyType]>; };
+//#endregion
+//#region src/cards/card.d.ts
+declare class Card$1 {
+  readonly value: CardValue;
+  constructor(rawValue: number);
+  get suit(): CardSuit;
+  get rank(): CardRank;
+  toDto(): CardDto;
+}
+//#endregion
+//#region src/games/blackjack/card/blackjack-card.d.ts
+declare class BlackjackCard extends Card$1 {
+  get numericRank(): number;
+  static fromValue(value: CardValue): BlackjackCard;
+}
+//#endregion
+//#region src/games/blackjack/hand/blackjack-hand-value.d.ts
+declare class BlackjackHandValue {
+  readonly cards: ReadonlyArray<BlackjackCard>;
+  readonly hardHandValue: number;
+  readonly softHandValue: number | null;
+  constructor(cards: ReadonlyArray<BlackjackCard>);
+  get cardCount(): number;
+  get hasSoftHandValue(): boolean;
+  get isBusted(): boolean;
+  get isBlackjack(): boolean;
+  get highestHandValue(): number;
+}
+//#endregion
+//#region src/games/blackjack/hand/blackjack-hand.d.ts
+declare abstract class BlackjackHand {
+  readonly cards: ReadonlyArray<BlackjackCard>;
+  protected readonly value: BlackjackHandValue;
+  protected constructor(rawCards: ReadonlyArray<CardValue>);
+  abstract addDrawnCards(newCards: ReadonlyArray<CardValue>): BlackjackHand;
+  get isBusted(): boolean;
+  get isBlackjack(): boolean;
+  get highestHandValue(): number;
+  get rawValues(): ReadonlyArray<CardValue>;
+  toDto(): BlackjackHandDto;
+}
+//#endregion
+//#region src/games/blackjack/hand/dealer-hand.d.ts
+declare class DealerHand extends BlackjackHand {
+  private readonly otherCards;
+  readonly upCard: BlackjackCard;
+  readonly holeCard: BlackjackCard;
+  private constructor();
+  static withInitialDeal(params: {
+    upCard: CardValue;
+    holeCard: CardValue;
+  }): DealerHand;
+  addDrawnCards(newCards: ReadonlyArray<CardValue>): DealerHand;
+  toDto(revealHoleCard?: boolean): BlackjackHandDto;
+}
+//#endregion
+//#region src/games/blackjack/hand/player-hand.d.ts
+declare class PlayerHand extends BlackjackHand {
+  static withInitialDeal(initialCards: readonly [CardValue, CardValue]): PlayerHand;
+  addDrawnCards(newCards: ReadonlyArray<CardValue>): PlayerHand;
+}
+//#endregion
+//#region src/games/random-value-pool.d.ts
+export declare class RandomValuePool {
+  private readonly source;
+  private index;
+  private constructor();
+  static from(result: MultipleRandomValues, count: number): RandomValuePool;
+  get consumedValues(): number[];
+  toMultipleRandomValues(): MultipleRandomValues;
+  takeOne(): number;
+  take(count: number): ReadonlyArray<number>;
+}
+//#endregion
+//#region src/games/multi-action-game.d.ts
+export type BaseInProgressState = Readonly<{
+  isFinished: false;
+  multiplier: Big$1;
+}>;
+export type BaseFinishedState = Readonly<{
+  isFinished: true;
+  payout: Payout;
+  multiplier: Big$1;
+  randomValues: number[];
+}>;
+export type BaseGameState = BaseInProgressState | BaseFinishedState;
+export type GameContext<TAction, TState extends BaseGameState, TConfig> = {
+  readonly playerArgument: TAction;
+  readonly state: TState;
+  readonly config: TConfig;
+  readonly additionalBetAmount?: Big$1;
+};
+export type RandomValuePoolEvent = Readonly<{
+  randomValuePool: RandomValuePool;
+}>;
+export type UntypedGameContext = GameContext<{
+  readonly type: string;
+}, BaseGameState, unknown>;
+export type PlayResult = UntypedGameContext & {
+  readonly proof: Proof;
+};
+export interface GameStore<TInternalState extends BaseGameState, TAction, TConfig> {
+  send(event: {
+    readonly type: string;
+  } & RandomValuePoolEvent & Record<string, unknown>): void;
+  getSnapshot(): {
+    readonly context: GameContext<TAction, TInternalState, TConfig>;
+  };
+}
+export declare abstract class MultiActionGame<TInternalState extends BaseGameState, TExternalState extends BaseGameState, TAction extends {
+  readonly type: string;
+}, TConfig> implements Game {
+  readonly gameId: OrigamiGame;
+  readonly edge: number;
+  protected constructor(gameId: OrigamiGame, edge: number);
+  abstract get supportedEdgeConfigurations(): [number, ...number[]];
+  abstract getValidNextActionTypes(state: TExternalState): ReadonlyArray<TAction['type']>;
+  protected abstract createGameStore(): GameStore<TInternalState, TAction, TConfig>;
+  protected abstract generateRandomValues(generator: RandomNumberGenerator): RandomValuePool;
+  protected abstract toExternalState(internal: TInternalState): TExternalState;
+  play(generator: RandomNumberGenerator, action: {
+    readonly type: string;
+  } & Record<string, unknown>, previousActions?: readonly UntypedGameContext[]): PlayResult;
+  private validateEdge;
+}
+//#endregion
+//#region src/games/blackjack/insurance-stake.d.ts
+export type RoundInsuranceStake = (unroundedStake: Big$1) => Big$1;
+export declare const calculateInsuranceStake: (mainBetAmount: Big$1, roundInsuranceStake: RoundInsuranceStake) => Big$1;
+//#endregion
+//#region src/games/blackjack/blackjack.d.ts
+type BlackjackStartAction = Readonly<{
+  type: BlackjackActionType.START;
+  mainBetAmount: string;
+  pairBonusAmount: string;
+  threeCardBonusAmount: string;
+}>;
+type BlackjackHitAction = Readonly<{
+  type: BlackjackActionType.HIT;
+}>;
+type BlackjackStandAction = Readonly<{
+  type: BlackjackActionType.STAND;
+}>;
+type BlackjackBuyInsuranceAction = Readonly<{
+  type: BlackjackActionType.BUY_INSURANCE;
+}>;
+type BlackjackRejectInsuranceAction = Readonly<{
+  type: BlackjackActionType.REJECT_INSURANCE;
+}>;
+type BlackjackDoubleDownAction = Readonly<{
+  type: BlackjackActionType.DOUBLE_DOWN;
+}>;
+type BlackjackSplitAction = Readonly<{
+  type: BlackjackActionType.SPLIT;
+}>;
+type BlackjackAction = BlackjackStartAction | BlackjackHitAction | BlackjackStandAction | BlackjackBuyInsuranceAction | BlackjackRejectInsuranceAction | BlackjackDoubleDownAction | BlackjackSplitAction;
+type BlackjackSingleHandStateBase = Readonly<{
+  playerHand: BlackjackHandDto;
+  dealerHand: BlackjackHandDto;
+  sideBetResults: SideBetResults;
+}>;
+type BlackjackAwaitingInsuranceState = Simplify<BlackjackSingleHandStateBase & BaseInProgressState & {
+  phase: 'awaiting-insurance';
+}>;
+type BlackjackPlayerTurnState = Simplify<BlackjackSingleHandStateBase & BaseInProgressState & {
+  phase: 'player-turn';
+}>;
+type BlackjackSplitHandStateBase = Readonly<{
+  mainHand: BlackjackHandDto;
+  splitHand: BlackjackHandDto;
+  dealerHand: BlackjackHandDto;
+  sideBetResults: SideBetResults;
+}>;
+type BlackjackPlayingMainHandState = Simplify<BlackjackSplitHandStateBase & BaseInProgressState & {
+  phase: 'playing-main-hand';
+}>;
+type BlackjackPlayingSplitHandState = Simplify<BlackjackSplitHandStateBase & BaseInProgressState & {
+  phase: 'playing-split-hand';
+}>;
+type BlackjackFinishedState = Simplify<BlackjackSingleHandStateBase & BaseFinishedState & {
+  outcome: BlackjackOutcome;
+  insuranceOutcome?: InsuranceOutcome;
+}>;
+type BlackjackSplitFinishedState = Simplify<BlackjackSplitHandStateBase & BaseFinishedState & {
+  mainOutcome: BlackjackOutcome;
+  splitOutcome: BlackjackOutcome;
+  insuranceOutcome?: InsuranceOutcome;
+}>;
+export type BlackjackState = BlackjackAwaitingInsuranceState | BlackjackPlayerTurnState | BlackjackPlayingMainHandState | BlackjackPlayingSplitHandState | BlackjackFinishedState | BlackjackSplitFinishedState;
+type BlackjackConfig = Record<string, never>;
+type BlackjackInternalUninitialisedState = BaseInProgressState & {
+  readonly phase: 'uninitialised';
+};
+type BlackjackInternalAwaitingInsuranceState = BaseInProgressState & {
+  readonly phase: 'awaiting-insurance';
+  readonly playerHand: PlayerHand;
+  readonly dealerHand: DealerHand;
+  readonly betAmounts: BetAmounts;
+  readonly sideBetResults: SideBetResults;
+};
+type BlackjackInternalInProgressState = BaseInProgressState & {
+  readonly phase: 'in-progress';
+  readonly playerHand: PlayerHand;
+  readonly dealerHand: DealerHand;
+  readonly insuranceOutcome: InsuranceOutcome | undefined;
+  readonly betAmounts: BetAmounts;
+  readonly sideBetResults: SideBetResults;
+};
+type BlackjackInternalPlayingMainHandState = BaseInProgressState & {
+  readonly phase: 'playing-main-hand';
+  readonly mainHand: PlayerHand;
+  readonly splitHand: PlayerHand;
+  readonly dealerHand: DealerHand;
+  readonly insuranceOutcome: InsuranceOutcome | undefined;
+  readonly mainHandDoubledDown: boolean;
+  readonly betAmounts: BetAmounts;
+  readonly sideBetResults: SideBetResults;
+};
+type BlackjackInternalPlayingSplitHandState = BaseInProgressState & {
+  readonly phase: 'playing-split-hand';
+  readonly mainHand: PlayerHand;
+  readonly splitHand: PlayerHand;
+  readonly dealerHand: DealerHand;
+  readonly insuranceOutcome: InsuranceOutcome | undefined;
+  readonly mainHandDoubledDown: boolean;
+  readonly splitHandDoubledDown: boolean;
+  readonly betAmounts: BetAmounts;
+  readonly sideBetResults: SideBetResults;
+};
+type BlackjackInternalFinishedState = BaseFinishedState & {
+  readonly phase: 'finished';
+  readonly playerHand: PlayerHand;
+  readonly dealerHand: DealerHand;
+  readonly outcome: BlackjackOutcome;
+  readonly insuranceOutcome?: InsuranceOutcome;
+  readonly sideBetResults: SideBetResults;
+};
+type BlackjackInternalSplitFinishedState = BaseFinishedState & {
+  readonly phase: 'split-finished';
+  readonly mainHand: PlayerHand;
+  readonly splitHand: PlayerHand;
+  readonly dealerHand: DealerHand;
+  readonly mainOutcome: BlackjackOutcome;
+  readonly splitOutcome: BlackjackOutcome;
+  readonly insuranceOutcome?: InsuranceOutcome;
+  readonly sideBetResults: SideBetResults;
+};
+type BlackjackInternalState = BlackjackInternalUninitialisedState | BlackjackInternalAwaitingInsuranceState | BlackjackInternalInProgressState | BlackjackInternalPlayingMainHandState | BlackjackInternalPlayingSplitHandState | BlackjackInternalFinishedState | BlackjackInternalSplitFinishedState;
+export type BlackjackGameContext = GameContext<BlackjackAction, BlackjackState, BlackjackConfig>;
+export declare class Blackjack extends MultiActionGame<BlackjackInternalState, BlackjackState, BlackjackAction, BlackjackConfig> {
+  private readonly roundInsuranceStake;
+  constructor(edge: number, roundInsuranceStake: RoundInsuranceStake);
+  get supportedEdgeConfigurations(): [number, ...number[]];
+  protected generateRandomValues(generator: RandomNumberGenerator): RandomValuePool;
+  protected toExternalState(internal: BlackjackInternalState): BlackjackState;
+  protected createGameStore(): GameStore<BlackjackInternalState, BlackjackAction, BlackjackConfig>;
+  getValidNextActionTypes(state: BlackjackState): readonly BlackjackActionType[];
+}
+//#endregion
+//#region src/games/blitz/blitz.d.ts
+export interface BlitzGameInputs {
+  pickCount: number;
+  betAmount: Big$1;
+}
+export interface BlitzGameOutputs {
+  cards: CardDto[];
+  result: number[];
+}
+export declare const getBlitzDefaults: () => {
+  minPicks: number;
+  maxPicks: number;
+};
+export declare const hasBlitzWon: (drawnCards: number[]) => boolean;
+/** Returns the probability of winning a Blitz game with a given number of picks between 0-1 */
+export declare const calculateBlitzWinChance: (picks: number) => Big$1;
+export declare class Blitz extends SingleActionGame<BlitzGameInputs, BlitzGameOutputs> {
+  constructor();
+  get supportedEdgeConfigurations(): [number, ...number[]];
+  getBetAmount(gameInputs: BlitzGameInputs): Big$1;
+  protected determineGameResult({ generator, gameInputs, edge }: GetGameResultRequest<BlitzGameInputs>): GameResult<BlitzGameOutputs>;
+}
+//#endregion
+//#region src/games/blitz/blitz.constants.d.ts
+export declare const BLITZ_MIN_CARD_RANGE = 0;
+export declare const BLITZ_MAX_CARD_RANGE = 51;
+export declare const BLITZ_CARD_COUNT = 52;
+export declare const BLITZ_RANDOM_NUMBER_COUNT = 52;
+//#endregion
+//#region src/games/darts/darts.constants.d.ts
+export declare const DARTS_MIN_VALUE = 0;
+export declare const DARTS_MAX_VALUE = 4294967295;
+export declare enum DARTS_DIFFICULTY_LEVEL {
+  EASY = "EASY",
+  MEDIUM = "MEDIUM",
+  HARD = "HARD",
+  EXPERT = "EXPERT"
+}
+//#endregion
+//#region src/games/darts/darts.d.ts
+export interface DartsGameInputs {
+  difficultyLevel: DARTS_DIFFICULTY_LEVEL;
+  betAmount: Big$1;
+}
+export declare class Darts extends SingleActionGame<DartsGameInputs> {
+  constructor();
+  get supportedEdgeConfigurations(): [number, ...number[]];
+  getBetAmount(gameInputs: DartsGameInputs): Big$1;
+  protected determineGameResult({ generator, gameInputs }: GetGameResultRequest<DartsGameInputs>): GameResult;
+}
+//#endregion
+//#region src/games/darts/darts-difficulty-config.d.ts
+export type Segment = 'YELLOW' | 'ORANGE' | 'RED';
+export type DartboardConfig = ReadonlyDeep<{
+  distanceBoundaries: {
+    bullseye: number;
+    ringOne: number;
+    ringTwo: number;
+    ringThree: number;
+  };
+  multipliers: {
+    bullseye: number;
+    ringOne: number;
+    ringTwo: number;
+    ringThree: Readonly<Record<Segment, number>>;
+    ringFour: number;
+  };
+  segments: ReadonlyArray<Segment>;
+}>;
+export declare const getMaxMultiplierForDifficulty: (difficultyLevel: DARTS_DIFFICULTY_LEVEL) => number;
+export declare const DARTS_BOARD_CONFIGS: Record<DARTS_DIFFICULTY_LEVEL, DartboardConfig>;
+//#endregion
+//#region src/games/infrastructure/multiplier.container.d.ts
+declare class MultiplierContainer<TMultipliers> {
+  readonly multipliers: Map<number, TMultipliers>;
+  constructor(multipliers: Map<number, TMultipliers>);
+  getMultipliers(edge: number): TMultipliers;
+  getAllMultipliers(): {
+    edge: number;
+    multipliers: TMultipliers;
+  }[];
+}
+//#endregion
+//#region src/games/diamonds/diamonds.d.ts
+export interface DiamondsGameInputs {
+  betAmount: Big$1;
+}
+export declare enum DiamondsResultType {
+  PAIR = "PAIR",
+  TWO_PAIR = "TWO_PAIR",
+  THREE_OF_A_KIND = "THREE_OF_A_KIND",
+  FULL_HOUSE = "FULL_HOUSE",
+  FOUR_OF_A_KIND = "FOUR_OF_A_KIND",
+  FIVE_OF_A_KIND = "FIVE_OF_A_KIND"
+}
+export type DiamondsMultipliers = Record<keyof typeof DiamondsResultType, number>;
+export declare const diamondsMultipliers: MultiplierContainer<DiamondsMultipliers>;
+export declare class Diamonds extends SingleActionGame<DiamondsGameInputs> {
+  constructor();
+  get supportedEdgeConfigurations(): [number, ...number[]];
+  getBetAmount(gameInputs: DiamondsGameInputs): Big$1;
+  protected determineGameResult({ generator, edge, gameInputs }: GetGameResultRequest<DiamondsGameInputs>): GameResult;
+  private calculatePayoutMultiplier;
+  private classifyResult;
+}
+//#endregion
+//#region src/games/dice/dice.d.ts
+export declare enum DiceDirection {
+  ABOVE = "ABOVE",
+  BELOW = "BELOW"
+}
+export interface DiceGameInputs {
+  direction: DiceDirection;
+  selectedValue: number;
+  betAmount: Big$1;
+}
+export type DiceSelection = Pick<DiceGameInputs, 'direction' | 'selectedValue'>;
+export declare const DICE_MIN_ROLL = 0;
+export declare const DICE_MAX_ROLL = 10000;
+export declare const DICE_EFFECTIVE_RANGE: number;
+export declare const calculateDiceWinChance: (gameInputs: DiceSelection) => Big$1;
+export declare const hasDiceWon: (gameInputs: DiceSelection, rolledValue: number) => boolean;
+export declare class Dice extends SingleActionGame<DiceGameInputs> {
+  constructor();
+  get supportedEdgeConfigurations(): [number, ...number[]];
+  getBetAmount(gameInputs: DiceGameInputs): Big$1;
+  protected determineGameResult({ generator, edge, gameInputs }: GetGameResultRequest<DiceGameInputs>): GameResult;
+}
+//#endregion
+//#region src/games/keno/keno.constants.d.ts
+export declare enum KenoRiskLevel {
+  CLASSIC = "CLASSIC",
+  LOW_RISK = "LOW_RISK",
+  MEDIUM_RISK = "MEDIUM_RISK",
+  HIGH_RISK = "HIGH_RISK"
+}
+export declare const TILE_COUNTS: readonly [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+export type TileCount = (typeof TILE_COUNTS)[number];
+export declare const isTileCount: (value: number) => value is TileCount;
+//#endregion
+//#region src/games/keno/keno.d.ts
+export interface KenoGameInputs {
+  riskLevel: KenoRiskLevel;
+  selectedNumbers: number[];
+  betAmount: Big$1;
+}
+export declare class Keno extends SingleActionGame<KenoGameInputs> {
+  constructor();
+  get supportedEdgeConfigurations(): [number, ...number[]];
+  getBetAmount(gameInputs: KenoGameInputs): Big$1;
+  protected determineGameResult({ generator, edge, gameInputs }: GetGameResultRequest<KenoGameInputs>): GameResult;
+}
+//#endregion
+//#region src/games/keno/keno.multipliers.d.ts
+export type KenoMultipliers = Record<TileCount, Record<KenoRiskLevel, number[]>>;
+export declare const rtp99Multipliers: KenoMultipliers;
+export declare const rtp98Multipliers: KenoMultipliers;
+export declare const rtp97Multipliers: KenoMultipliers;
+export declare const rtp96Multipliers: KenoMultipliers;
+export declare const rtp92Multipliers: KenoMultipliers;
+export declare const kenoMultipliers: MultiplierContainer<KenoMultipliers>;
+//#endregion
+//#region src/games/limbo/limbo.d.ts
+export interface LimboGameInputs {
+  targetMultiplier: number;
+  betAmount: Big$1;
+}
+export interface LimboGameOutputs {
+  randomMultiplier: Big$1;
+}
+export declare class Limbo extends SingleActionGame<LimboGameInputs, LimboGameOutputs> {
+  constructor();
+  get supportedEdgeConfigurations(): [number, ...number[]];
+  getBetAmount(gameInputs: LimboGameInputs): Big$1;
+  protected determineGameResult({ generator, edge, gameInputs }: GetGameResultRequest<LimboGameInputs>): GameResult<LimboGameOutputs>;
+}
+//#endregion
+//#region src/games/mines/mines.d.ts
+export interface MinesGameInputs {
+  minesCount: number;
+  selectedTiles: number[];
+  hasCashedOut: boolean;
+  betAmount: Big$1;
+}
+export declare class Mines extends SingleActionGame<MinesGameInputs> {
+  constructor();
+  get supportedEdgeConfigurations(): [number, ...number[]];
+  getBetAmount(gameInputs: MinesGameInputs): Big$1;
+  protected determineGameResult({ generator, edge, gameInputs }: GetGameResultRequest<MinesGameInputs>): GameResult;
+}
+//#endregion
+//#region src/games/plinko/plinko.constants.d.ts
+export declare enum PlinkoRiskLevel {
+  LOW_RISK = "LOW_RISK",
+  MEDIUM_RISK = "MEDIUM_RISK",
+  HIGH_RISK = "HIGH_RISK"
+}
+//#endregion
+//#region src/games/plinko/plinko.d.ts
+export interface PlinkoGameInputs {
+  numberOfRows: number;
+  riskLevel: PlinkoRiskLevel;
+  betAmount: Big;
+}
+export declare class Plinko extends SingleActionGame<PlinkoGameInputs> {
+  constructor();
+  get supportedEdgeConfigurations(): [number, ...number[]];
+  getBetAmount(gameInputs: PlinkoGameInputs): Big;
+  protected determineGameResult({ generator, gameInputs, edge }: GetGameResultRequest<PlinkoGameInputs>): GameResult;
+}
+//#endregion
+//#region src/games/plinko/plinko.multipliers.d.ts
+export declare const PLINKO_ROW_COUNTS: readonly [8, 9, 10, 11, 12, 13, 14, 15, 16];
+export type PlinkoRowCount = (typeof PLINKO_ROW_COUNTS)[number];
+export type PlinkoMultiplierSet = Record<PlinkoRowCount, number[]>;
+export type PlinkoMultipliers = Record<PlinkoRiskLevel, PlinkoMultiplierSet>;
+export declare const plinkoMultipliers: MultiplierContainer<PlinkoMultipliers>;
+//#endregion
+//#region src/games/roulette/roulette.types.d.ts
+export declare const VALID_EUROPEAN_STRAIGHTS: readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36];
+export type EuropeanStraight = (typeof VALID_EUROPEAN_STRAIGHTS)[number];
+export declare const VALID_AMERICAN_STRAIGHTS: readonly [37, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36];
+export type AmericanStraight = (typeof VALID_AMERICAN_STRAIGHTS)[number];
+export interface EuropeanStraightBet extends BaseBet {
+  value: EuropeanStraight;
+}
+export interface AmericanStraightBet extends BaseBet {
+  value: AmericanStraight;
+}
+export declare const VALID_EUROPEAN_SPLITS: readonly [readonly [0, 1], readonly [0, 2], readonly [0, 3], readonly [1, 2], readonly [1, 4], readonly [2, 3], readonly [2, 5], readonly [3, 6], readonly [4, 5], readonly [4, 7], readonly [5, 6], readonly [5, 8], readonly [6, 9], readonly [7, 8], readonly [7, 10], readonly [8, 9], readonly [8, 11], readonly [9, 12], readonly [10, 11], readonly [10, 13], readonly [11, 12], readonly [11, 14], readonly [12, 15], readonly [13, 14], readonly [13, 16], readonly [14, 15], readonly [14, 17], readonly [15, 18], readonly [16, 17], readonly [16, 19], readonly [17, 18], readonly [17, 20], readonly [18, 21], readonly [19, 20], readonly [19, 22], readonly [20, 21], readonly [20, 23], readonly [21, 24], readonly [22, 23], readonly [22, 25], readonly [23, 24], readonly [23, 26], readonly [24, 27], readonly [25, 26], readonly [25, 28], readonly [26, 27], readonly [26, 29], readonly [27, 30], readonly [28, 29], readonly [28, 31], readonly [29, 30], readonly [29, 32], readonly [30, 33], readonly [31, 32], readonly [31, 34], readonly [32, 33], readonly [32, 35], readonly [33, 36], readonly [34, 35], readonly [35, 36]];
+export type EuropeanSplit = (typeof VALID_EUROPEAN_SPLITS)[number];
+export interface EuropeanSplitBet extends BaseBet {
+  values: EuropeanSplit;
+}
+export declare const VALID_AMERICAN_SPLITS: readonly [readonly [0, 1], readonly [0, 37], readonly [3, 37], readonly [1, 2], readonly [1, 4], readonly [2, 3], readonly [2, 5], readonly [3, 6], readonly [4, 5], readonly [4, 7], readonly [5, 6], readonly [5, 8], readonly [6, 9], readonly [7, 8], readonly [7, 10], readonly [8, 9], readonly [8, 11], readonly [9, 12], readonly [10, 11], readonly [10, 13], readonly [11, 12], readonly [11, 14], readonly [12, 15], readonly [13, 14], readonly [13, 16], readonly [14, 15], readonly [14, 17], readonly [15, 18], readonly [16, 17], readonly [16, 19], readonly [17, 18], readonly [17, 20], readonly [18, 21], readonly [19, 20], readonly [19, 22], readonly [20, 21], readonly [20, 23], readonly [21, 24], readonly [22, 23], readonly [22, 25], readonly [23, 24], readonly [23, 26], readonly [24, 27], readonly [25, 26], readonly [25, 28], readonly [26, 27], readonly [26, 29], readonly [27, 30], readonly [28, 29], readonly [28, 31], readonly [29, 30], readonly [29, 32], readonly [30, 33], readonly [31, 32], readonly [31, 34], readonly [32, 33], readonly [32, 35], readonly [33, 36], readonly [34, 35], readonly [35, 36]];
+export type AmericanSplit = (typeof VALID_AMERICAN_SPLITS)[number];
+export interface AmericanSplitBet extends BaseBet {
+  values: AmericanSplit;
+}
+export declare const VALID_EUROPEAN_STREETS: readonly [readonly [0, 1, 2], readonly [0, 2, 3], readonly [1, 2, 3], readonly [4, 5, 6], readonly [7, 8, 9], readonly [10, 11, 12], readonly [13, 14, 15], readonly [16, 17, 18], readonly [19, 20, 21], readonly [22, 23, 24], readonly [25, 26, 27], readonly [28, 29, 30], readonly [31, 32, 33], readonly [34, 35, 36]];
+export type EuropeanStreet = (typeof VALID_EUROPEAN_STREETS)[number];
+export interface BaseBet {
+  amount: Big;
+}
+export interface EuropeanStreetBet extends BaseBet {
+  values: EuropeanStreet;
+}
+export declare const VALID_AMERICAN_STREETS: readonly [readonly [0, 1, 2], readonly [0, 2, 37], readonly [1, 2, 3], readonly [2, 3, 37], readonly [4, 5, 6], readonly [7, 8, 9], readonly [10, 11, 12], readonly [13, 14, 15], readonly [16, 17, 18], readonly [19, 20, 21], readonly [22, 23, 24], readonly [25, 26, 27], readonly [28, 29, 30], readonly [31, 32, 33], readonly [34, 35, 36]];
+export type AmericanStreet = (typeof VALID_AMERICAN_STREETS)[number];
+export interface AmericanStreetBet extends BaseBet {
+  values: AmericanStreet;
+}
+export declare const VALID_EUROPEAN_CORNERS: readonly [readonly [0, 1, 2, 3], readonly [1, 2, 4, 5], readonly [2, 3, 5, 6], readonly [4, 5, 7, 8], readonly [5, 6, 8, 9], readonly [7, 8, 10, 11], readonly [8, 9, 11, 12], readonly [10, 11, 13, 14], readonly [11, 12, 14, 15], readonly [13, 14, 16, 17], readonly [14, 15, 17, 18], readonly [16, 17, 19, 20], readonly [17, 18, 20, 21], readonly [19, 20, 22, 23], readonly [20, 21, 23, 24], readonly [22, 23, 25, 26], readonly [23, 24, 26, 27], readonly [25, 26, 28, 29], readonly [26, 27, 29, 30], readonly [28, 29, 31, 32], readonly [29, 30, 32, 33], readonly [31, 32, 34, 35], readonly [32, 33, 35, 36]];
+export type EuropeanCorner = (typeof VALID_EUROPEAN_CORNERS)[number];
+export interface EuropeanCornerBet extends BaseBet {
+  values: EuropeanCorner;
+}
+export declare const VALID_AMERICAN_CORNERS: readonly [readonly [1, 2, 4, 5], readonly [2, 3, 5, 6], readonly [4, 5, 7, 8], readonly [5, 6, 8, 9], readonly [7, 8, 10, 11], readonly [8, 9, 11, 12], readonly [10, 11, 13, 14], readonly [11, 12, 14, 15], readonly [13, 14, 16, 17], readonly [14, 15, 17, 18], readonly [16, 17, 19, 20], readonly [17, 18, 20, 21], readonly [19, 20, 22, 23], readonly [20, 21, 23, 24], readonly [22, 23, 25, 26], readonly [23, 24, 26, 27], readonly [25, 26, 28, 29], readonly [26, 27, 29, 30], readonly [28, 29, 31, 32], readonly [29, 30, 32, 33], readonly [31, 32, 34, 35], readonly [32, 33, 35, 36]];
+export type AmericanCorner = (typeof VALID_AMERICAN_CORNERS)[number];
+export interface AmericanCornerBet extends BaseBet {
+  values: AmericanCorner;
+}
+export declare const AMERICAN_BASKET: readonly [0, 1, 2, 3, 37];
+export interface AmericanBasketBet extends BaseBet {}
+export declare const VALID_EUROPEAN_DOUBLE_STREETS: readonly [readonly [1, 2, 3, 4, 5, 6], readonly [4, 5, 6, 7, 8, 9], readonly [7, 8, 9, 10, 11, 12], readonly [10, 11, 12, 13, 14, 15], readonly [13, 14, 15, 16, 17, 18], readonly [16, 17, 18, 19, 20, 21], readonly [19, 20, 21, 22, 23, 24], readonly [22, 23, 24, 25, 26, 27], readonly [25, 26, 27, 28, 29, 30], readonly [28, 29, 30, 31, 32, 33], readonly [31, 32, 33, 34, 35, 36]];
+export type EuropeanDoubleStreet = (typeof VALID_EUROPEAN_DOUBLE_STREETS)[number];
+export interface EuropeanDoubleStreetBet extends BaseBet {
+  values: EuropeanDoubleStreet;
+}
+export declare const VALID_AMERICAN_DOUBLE_STREETS: readonly [readonly [1, 2, 3, 4, 5, 6], readonly [4, 5, 6, 7, 8, 9], readonly [7, 8, 9, 10, 11, 12], readonly [10, 11, 12, 13, 14, 15], readonly [13, 14, 15, 16, 17, 18], readonly [16, 17, 18, 19, 20, 21], readonly [19, 20, 21, 22, 23, 24], readonly [22, 23, 24, 25, 26, 27], readonly [25, 26, 27, 28, 29, 30], readonly [28, 29, 30, 31, 32, 33], readonly [31, 32, 33, 34, 35, 36]];
+export type AmericanDoubleStreet = (typeof VALID_AMERICAN_DOUBLE_STREETS)[number];
+export interface AmericanDoubleStreetBet extends BaseBet {
+  values: AmericanDoubleStreet;
+}
+export declare enum Parity {
+  EVEN = "EVEN",
+  ODD = "ODD"
+}
+export interface ParityBet extends BaseBet {
+  parity: Parity;
+}
+export declare enum Color {
+  RED = "RED",
+  BLACK = "BLACK"
+}
+export interface ColorBet extends BaseBet {
+  color: Color;
+}
+export declare enum Half {
+  LOW = "LOW",
+  HIGH = "HIGH"
+}
+export interface HalfBet extends BaseBet {
+  half: Half;
+}
+export declare enum Column {
+  TOP = "TOP",
+  MIDDLE = "MIDDLE",
+  BOTTOM = "BOTTOM"
+}
+export interface ColumnBet extends BaseBet {
+  column: Column;
+}
+export declare enum Dozen {
+  FIRST = "FIRST",
+  SECOND = "SECOND",
+  THIRD = "THIRD"
+}
+export interface DozenBet extends BaseBet {
+  dozen: Dozen;
+}
+export interface EuropeanRouletteGameInputs {
+  straightBets: EuropeanStraightBet[];
+  splitBets: EuropeanSplitBet[];
+  streetBets: EuropeanStreetBet[];
+  cornerBets: EuropeanCornerBet[];
+  doubleStreetBets: EuropeanDoubleStreetBet[];
+  parityBets: ParityBet[];
+  colorBets: ColorBet[];
+  halfBets: HalfBet[];
+  columnBets: ColumnBet[];
+  dozenBets: DozenBet[];
+}
+export interface AmericanRouletteGameInputs {
+  straightBets: AmericanStraightBet[];
+  splitBets: AmericanSplitBet[];
+  streetBets: AmericanStreetBet[];
+  cornerBets: AmericanCornerBet[];
+  basketBets: AmericanBasketBet[];
+  doubleStreetBets: AmericanDoubleStreetBet[];
+  parityBets: ParityBet[];
+  colorBets: ColorBet[];
+  halfBets: HalfBet[];
+  columnBets: ColumnBet[];
+  dozenBets: DozenBet[];
+}
+export declare enum RouletteType {
+  AMERICAN = "AMERICAN",
+  EUROPEAN = "EUROPEAN"
+}
+export declare const EUROPEAN_HOUSE_EDGE = 2.7;
+export declare const AMERICAN_HOUSE_EDGE = 5.3;
+export type RouletteGameInputs = {
+  type: RouletteType.EUROPEAN;
+  inputs: EuropeanRouletteGameInputs;
+} | {
+  type: RouletteType.AMERICAN;
+  inputs: AmericanRouletteGameInputs;
+};
+export interface EuropeanRouletteBetOutcomes {
+  winningBets: EuropeanRouletteGameInputs;
+  losingBets: EuropeanRouletteGameInputs;
+}
+export interface AmericanRouletteBetOutcomes {
+  winningBets: AmericanRouletteGameInputs;
+  losingBets: AmericanRouletteGameInputs;
+}
+export interface EuropeanRouletteGameOutputs {
+  betOutcomes: EuropeanRouletteBetOutcomes;
+  result: number[];
+}
+export interface AmericanRouletteGameOutputs {
+  betOutcomes: AmericanRouletteBetOutcomes;
+  result: number[];
+}
+export type RouletteGameOutputs = {
+  type: 'european';
+  betOutcomes: EuropeanRouletteBetOutcomes;
+  result: number[];
+} | {
+  type: 'american';
+  betOutcomes: AmericanRouletteBetOutcomes;
+  result: number[];
+};
+//#endregion
+//#region src/games/roulette/roulette.d.ts
+export declare const PAYOUT_MULTIPLIERS: Record<keyof EuropeanRouletteGameInputs | keyof AmericanRouletteGameInputs, number>;
+export declare const TOP_COLUMN: number[];
+export declare const MIDDLE_COLUMN: number[];
+export declare const BOTTOM_COLUMN: number[];
+export declare const RED_NUMBERS: number[];
+export declare const BLACK_NUMBERS: number[];
+type BetPredicate = (bet: BaseBet, result: number) => boolean;
+declare abstract class BaseRoulette<TInputs extends {
+  straightBets: BaseBet[];
+  splitBets: BaseBet[];
+  streetBets: BaseBet[];
+  cornerBets: BaseBet[];
+  doubleStreetBets: BaseBet[];
+  parityBets: BaseBet[];
+  colorBets: BaseBet[];
+  halfBets: BaseBet[];
+  columnBets: BaseBet[];
+  dozenBets: BaseBet[];
+}, TOutputs extends {
+  betOutcomes: {
+    winningBets: TInputs;
+    losingBets: TInputs;
+  };
+  result: number[];
+}> extends SingleActionGame<TInputs, TOutputs> {
+  protected abstract readonly maxNumber: number;
+  constructor();
+  determineGameResult({ generator, gameInputs }: GetGameResultRequest<TInputs>): GameResult<TOutputs>;
+  getBetAmount(gameInputs: TInputs): Big;
+  getPayoutDetails(gameInputs: TInputs, gameResult: number): {
+    payoutMultiplier: Big;
+    payout: Payout;
+  };
+  protected determineBetOutcomes(inputs: TInputs, result: number): {
+    winningBets: TInputs;
+    losingBets: TInputs;
+  };
+  protected calculateTotalAmount(bets: {
+    amount: Big;
+  }[]): Big;
+  protected isWinningStraightBet(bet: BaseBet, gameResult: number): boolean;
+  protected isWinningSplitBet(bet: BaseBet, gameResult: number): boolean;
+  protected isWinningStreetBet(bet: BaseBet, gameResult: number): boolean;
+  protected isWinningCornerBet(bet: BaseBet, gameResult: number): boolean;
+  protected isWinningDoubleStreetBet(bet: BaseBet, gameResult: number): boolean;
+  protected isWinningColorBet(bet: BaseBet, gameResult: number): boolean;
+  protected isWinningHalfBet(bet: BaseBet, gameResult: number): boolean;
+  protected isWinningColumnBet(bet: BaseBet, gameResult: number): boolean;
+  protected isWinningDozenBet(bet: BaseBet, gameResult: number): boolean;
+  protected isWinningParityBet(bet: BaseBet, gameResult: number): boolean;
+  protected getBetTotals(inputs: TInputs): Record<keyof TInputs, Big>;
+  protected calculateTotalBetAmount(totals: Record<keyof TInputs, Big>): Big;
+  protected abstract validateInputs(inputs: TInputs): void;
+  protected abstract readonly betPredicates: Record<keyof TInputs, BetPredicate>;
+  private partitionBets;
+  /**
+   * One leg per bet actually placed, in the order the inputs list them. A bet type the player
+   * left empty contributes nothing, so an untouched part of the table produces no leg at all.
+   */
+  protected calculatePayoutLegs(inputs: TInputs, result: number): PayoutLeg[];
+}
+export declare class EuropeanRoulette extends BaseRoulette<EuropeanRouletteGameInputs, EuropeanRouletteGameOutputs> {
+  protected readonly maxNumber = 36;
+  protected readonly betPredicates: Record<keyof EuropeanRouletteGameInputs, BetPredicate>;
+  get supportedEdgeConfigurations(): [number, ...number[]];
+  protected validateInputs(inputs: EuropeanRouletteGameInputs): void;
+}
+export declare class AmericanRoulette extends BaseRoulette<AmericanRouletteGameInputs, AmericanRouletteGameOutputs> {
+  protected readonly maxNumber = 37;
+  protected readonly betPredicates: Record<keyof AmericanRouletteGameInputs, BetPredicate>;
+  get supportedEdgeConfigurations(): [number, ...number[]];
+  protected validateInputs(inputs: AmericanRouletteGameInputs): void;
+  protected isWinningBasketBet(_bet: BaseBet, gameResult: number): boolean;
+}
+export declare class Roulette extends SingleActionGame<RouletteGameInputs, RouletteGameOutputs> {
+  private readonly europeanGame;
+  private readonly americanGame;
+  constructor();
+  get supportedEdgeConfigurations(): [number, ...number[]];
+  getBetAmount(gameInputs: RouletteGameInputs): Big;
+  protected determineGameResult(request: GetGameResultRequest<RouletteGameInputs>): GameResult<RouletteGameOutputs>;
+}
+export declare const calculateRouletteBetAmount: (gameInputs: RouletteGameInputs) => Big;
+//#endregion
+//#region src/games/roulette/roulette.validation.d.ts
+export declare const validateRouletteGameInputs: (gameInputs: RouletteGameInputs, edge: number) => void;
+//#endregion
+//#region src/games/wheel/wheel.constants.d.ts
+export declare enum WheelRiskLevel {
+  LOW_RISK = "LOW_RISK",
+  MEDIUM_RISK = "MEDIUM_RISK",
+  HIGH_RISK = "HIGH_RISK"
+}
+export declare enum WheelSegments {
+  TEN = 10,
+  TWENTY = 20,
+  THIRTY = 30,
+  FORTY = 40,
+  FIFTY = 50
+}
+//#endregion
+//#region src/games/wheel/wheel.d.ts
+export interface WheelGameInputs {
+  segments: WheelSegments;
+  riskLevel: WheelRiskLevel;
+  betAmount: Big;
+}
+export declare class Wheel extends SingleActionGame<WheelGameInputs> {
+  constructor();
+  get supportedEdgeConfigurations(): [number, ...number[]];
+  getBetAmount(gameInputs: WheelGameInputs): Big;
+  protected determineGameResult({ generator, gameInputs, edge }: GetGameResultRequest<WheelGameInputs>): GameResult;
+}
+//#endregion
+//#region src/utils/big-max.d.ts
+export declare const bigMax: (a: Big$1, b: Big$1) => Big$1;
+//#endregion
+//#region src/utils/big-min.d.ts
+export declare const bigMin: (a: Big$1, b: Big$1) => Big$1;
+//#endregion
+//#region src/utils/multiplier-calculator.d.ts
+export declare abstract class MultiplierCalculator {
+  static withMultiplier(multiplier: Big$1, edge: number): Big$1;
+  static withWinChance(edge: number, winChance: Big$1): Big$1;
+}
+//#endregion
+//#region src/utils/ncr.d.ts
+export declare const nCr: (n: number, r: number) => number;
+//#endregion