Types

Import from @workspace/bridge/types. The sub-path is type-only except for three runtime values: PLAY_CONTEXT_INFOS, EMPTY_PAR_DATA and EMPTY_PAR_HINT.

const declarer: Player = "S";
const card: Card = "SA";
const contract: Contract = new ContractBuilder().fromCompact("4H").build();
// => { level: 4, suit: "H", trump: "H", declarer: "S", doubled: "none" }

Player

Hands

A hand of full cards is HandData<Card>, four of them HandsData<Card>. The stored rank-string hands, Hand and Hands, are under Deal.

Bid

RegularBidComposite

SpecialBidComposite

Contract

The final contract after the auction. trump is derivable from suit and may be omitted.

ContractResult

DisplayContract

A contract without declarer, for strings such as "3NT" or "4SX".

Contract

ContractLevel classifies a contract: "partial" | "game" | "small_slam" | "grand_slam".

Auction

The auction is stored and passed around as an Auction (see Deal and Canonical forms). BidInfo is the per-call view auctionEntries derives from it: the seat and position come from the dealer and the call's index, they are never stored.

BidInfo

Generic over TComment (defaults to unknown).

const auction: Auction = new AuctionBuilder().fromCompact("N / 1H pass 2H AP").build();
const entries: BidInfo[] = auctionEntries(auction);
entries[0]; // { bid: "1H", player: "N", position: 0 }

AuctionBidCell

One cell of an auction display. Same content as BidInfo with the position named index; auctionMovesToBidCells (Format) builds it.

Deal

The storage shape of a deal. Hands use rank strings per suit ("AKQ2"), not Card[].

Sequence

DealMetadata

result is stored verbatim: a trick count, a RESULT_EXPECTED sentinel, or "" as a transient marker.

Deal

Generic over TAuctionComment, TPlayComment and TReview, all defaulting to unknown.

const deal: Deal = makeDeal({ contract, player: declarer });
deal.cards.N.S; // rank string, e.g. "AKQ2"
deal.auction.first; // dealer
deal.play.moves; // chronological PlayMove[]

Play

PlayEntry

Trick

PlayAnnotation

Canonical forms

Scalars have one canonical form and one input union: Card / CardInput and Bid / BidInput, normalised by toCard and toBid at the public boundary (Card, Auction). Aggregates do not get an input union: a union on a hand, auction or trick shape costs a discriminant on every call, degrades inference and is ambiguous at runtime (an array of strings may hold cards or ranks).

Each aggregate has instead one stored form, named without a Deal prefix. Data that can be derived from it, such as a call's seat and position or a trick's winner, lives in a view that a named function produces. A view is never stored, and never passed around as a second canonical form.

Crossing points:

• Hands: handsToHandsData and handsDataToHands (@workspace/bridge/hands).
• Play: buildTricks turns a Play into Trick[]; PlayMoveLike ({ card: string }) is the minimal move shape it and engine.play.validateTricks accept.
• Auction: auctionEntries turns an Auction into BidInfo[]; nothing turns a view back into the stored form.
• Legacy input: the per-seat auction arrays ({ first, N, E, S, W }) still served by the legacy deal endpoint are parsed into an Auction where the player maps its DTO. Rows read straight from the database go through deriveContractResultFromAuction and deriveFinalDeclarerFromAuction, which accept unbranded bid strings.

createRandomAuction from @workspace/bridge/testing and createBoardGame from @workspace/bridge/factories both return an Auction.

Config

SuitOrderContext

CoreConfig

Game rules for a teaching mode. Resolved from the mode inside the engine and exposed as engine.hands.config; not meant to be assembled by hand.

PLAY_CONTEXT_INFOS

Runtime tuple of every PlayContextInfo, in canonical order.

const infos: readonly PlayContextInfo[] = PLAY_CONTEXT_INFOS;
// => ["lead", "trump", "objective", "contract", "scoring", "sequence"]
const hint: ParHint = { ...EMPTY_PAR_HINT, loading: true };

Par

ParData is what a synchronous solver returns. ParHint adds the async flags and the residual trick count. NSParHint expresses the bound in the NS frame for reachability checks.

ParData

ParHint

NSParHint

PBN

Types for the Portable Bridge Notation parser. PBNPlay is the wire format in column order per seat, not chronological order.

PBNCard

PBNParseData

PBNNote

PBNNotes

PBNAuction

PBNPlay

PBNDeal

ParserState

Scoring

TeachingMode

TeachingMode is the union of the 12 modes a deal can be in: "auction", "show-trump-goal", "no-auction", "show-trump", "show-contract", "h", "hd", "hld", "tht", "sequence", "petit-bridge", "no-dummy". See Game Modes for what each one enables.

Vulnerability

Locale

Locale is the union of the LOCALES tuple from @workspace/bridge/constants: "en" | "fr" | "es" | "it" | "ca" | "de" | "pt" | "el" | "nl" | "sv" | "pl".

Analysis

HandAnalysis

Notation and PBN helpers

These types belong to other modules and are imported from them: RankMapping and RankFormatter from @workspace/bridge/notation, DealCommentSummary from @workspace/bridge/pbn.

DealCommentSummary

Returned by engine.pbn.detectDealComments and engine.pbn.detectDealsComments.