@dreamboard-games/ui-sdk 0.0.41

package/dist/ui-sdk.d.ts

@@ -0,0 +1,3409 @@
+import { PlayerId as PlayerId$1, BoardId, SpaceId, SpaceTypeId, EdgeTypeId, VertexTypeId, PieceId, PieceTypeId, BoardBaseId, PerPlayer, DieId, CardIdsByDeckId, CardId, CardProperties, ResourceId } from '@dreamboard/manifest-contract';
+export { BoardRef, PerPlayer, PerPlayerBoardRef, SharedBoardRef } from '@dreamboard/manifest-contract';
+import { GameView, PhaseName } from '@dreamboard/ui-contract';
+import * as React$1 from 'react';
+import React__default, { ReactNode, CSSProperties, AriaAttributes, HTMLAttributes, JSX, ReactElement, ButtonHTMLAttributes, InputHTMLAttributes, RefObject, Component, ErrorInfo, ComponentType, ComponentProps } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { HTMLMotionProps } from 'framer-motion';
+
+declare function useActivePlayers(): readonly PlayerId$1[];
+
+type ActionName = string;
+interface SeatAssignment {
+    playerId: PlayerId$1;
+    controllerUserId?: string;
+    displayName: string;
+    playerColor?: string;
+    isHost?: boolean;
+}
+interface HistoryEntrySummary {
+    id: string;
+    version: number;
+    timestamp: string;
+    description: string;
+    playerId?: PlayerId$1;
+    actionType?: ActionName;
+    isCurrent: boolean;
+}
+
+interface LobbyState {
+    
+    seats: SeatAssignment[];
+    
+    canStart: boolean;
+    
+    hostUserId: string;
+}
+
+type NotificationType = "YOUR_TURN" | "PROMPT_OPENED" | "ACTION_EXECUTED" | "ACTION_REJECTED" | "TURN_CHANGED" | "STATE_CHANGED" | "GAME_ENDED" | "ERROR";
+
+interface YourTurnPayload {
+    type: "YOUR_TURN";
+    activePlayers: PlayerId$1[];
+}
+
+interface PromptOpenedPayload {
+    type: "PROMPT_OPENED";
+    promptId: string;
+    promptInstanceId: string;
+    targetPlayer: PlayerId$1;
+    title?: string;
+}
+
+interface ActionExecutedPayload {
+    type: "ACTION_EXECUTED";
+    playerId: PlayerId$1;
+    actionType: string;
+}
+
+interface ActionRejectedPayload {
+    type: "ACTION_REJECTED";
+    reason: string;
+    targetPlayer?: string;
+}
+
+interface StateChangedPayload {
+    type: "STATE_CHANGED";
+    newState: string;
+}
+
+interface TurnChangedPayload {
+    type: "TURN_CHANGED";
+    previousPlayers: PlayerId$1[];
+    currentPlayers: PlayerId$1[];
+}
+
+interface GameEndedPayload {
+    type: "GAME_ENDED";
+    winner?: string;
+    finalScores: Record<string, number>;
+    reason: string;
+}
+
+interface ErrorPayload {
+    type: "ERROR";
+    message: string;
+    code?: string;
+}
+
+type NotificationPayload = YourTurnPayload | PromptOpenedPayload | ActionExecutedPayload | ActionRejectedPayload | TurnChangedPayload | StateChangedPayload | GameEndedPayload | ErrorPayload;
+
+interface Notification {
+    
+    id: string;
+    
+    type: NotificationType;
+    
+    payload: NotificationPayload;
+    
+    timestamp: number;
+    
+    read: boolean;
+}
+
+interface PluginSessionState$1 {
+    
+    sessionId: string | null;
+    
+    controllablePlayerIds: PlayerId$1[];
+    
+    controllingPlayerId: PlayerId$1 | null;
+    
+    userId: string | null;
+}
+
+interface HistoryState {
+    
+    entries: HistoryEntrySummary[];
+    
+    currentIndex: number;
+    
+    canGoBack: boolean;
+    
+    canGoForward: boolean;
+}
+interface GameplayPromptOption {
+    id: string;
+    label: string;
+}
+
+interface InteractionContextOption {
+    id: string;
+    label?: string;
+    data?: unknown;
+}
+
+interface InteractionContext {
+    
+    to: string;
+    title?: string;
+    
+    payload?: Record<string, unknown>;
+    
+    options?: readonly InteractionContextOption[];
+}
+
+type InteractionKind = "action" | "prompt";
+type InteractionCommitPolicy = {
+    mode: "manual";
+} | {
+    mode: "autoWhenReady";
+};
+interface InputSelection {
+    mode: "single" | "many";
+    min?: number;
+    max?: number;
+    distinct?: boolean;
+}
+interface InputDomain {
+    type: "target" | "resourceMap" | "boundedNumber" | "choice" | "choiceList";
+    targetKind?: string;
+    boardId?: string;
+    zoneId?: string;
+    zoneIds?: readonly string[];
+    eligibleTargets?: readonly string[];
+    resources?: ReadonlyArray<{
+        resourceId: string;
+        label?: string;
+        icon?: string;
+        min: number;
+        max: number;
+    }>;
+    min?: number;
+    max?: number;
+    step?: number;
+    choices?: readonly InteractionChoiceOption[];
+    selection?: InputSelection;
+}
+interface InteractionChoiceOption {
+    value: string;
+    label: string;
+    icon?: string;
+    badge?: string;
+    description?: string;
+    disabled?: boolean;
+    disabledReason?: string;
+}
+interface InteractionInputDescriptor {
+    key: string;
+    kind: string;
+    domain: InputDomain;
+    defaultValue?: unknown;
+}
+interface InteractionDescriptor<Key extends string = string> {
+    phaseName: string;
+    interactionKey: Key;
+    interactionId: string;
+    
+    kind: InteractionKind;
+    
+    commit: InteractionCommitPolicy;
+    
+    zoneId?: string;
+    
+    zoneIds?: readonly string[];
+    
+    inputs: readonly InteractionInputDescriptor[];
+    
+    cost?: Record<string, unknown>;
+    
+    currentResources?: Record<string, unknown>;
+    
+    available: boolean;
+    unavailableReason?: string;
+    
+    context?: InteractionContext;
+}
+
+interface ZoneHandlesSnapshot<InteractionType extends string = string> {
+    cardIds: readonly string[];
+    cardsById: Readonly<Record<string, string>>;
+    playableByCardId: Readonly<Record<string, ReadonlyArray<InteractionDescriptor<InteractionType>>>>;
+}
+interface SimultaneousPhaseSnapshot {
+    phaseName: string;
+    interactionId: string;
+    actorIds: PlayerId$1[];
+    sealedPlayerIds: PlayerId$1[];
+    pendingPlayerIds: PlayerId$1[];
+}
+interface GameplaySnapshot$1<PhaseType extends string = string, StageType extends string = string, InteractionType extends string = string> {
+    currentPhase: PhaseType | null;
+    currentStage: StageType | null;
+    activePlayers: PlayerId$1[];
+    simultaneousPhase?: SimultaneousPhaseSnapshot | null;
+    availableInteractions: ReadonlyArray<InteractionDescriptor<InteractionType>>;
+    
+    zones: Readonly<Record<string, ZoneHandlesSnapshot<InteractionType>>>;
+}
+
+interface PluginStateSnapshot<View = unknown, PhaseType extends string = string, StageType extends string = string, InteractionType extends string = string> {
+    
+    view: View | null;
+    
+    gameplay: GameplaySnapshot$1<PhaseType, StageType, InteractionType>;
+    
+    lobby: LobbyState | null;
+    
+    notifications: Notification[];
+    
+    session: PluginSessionState$1;
+    
+    history: HistoryState | null;
+    
+    syncId: number;
+}
+
+declare function useSimultaneousPhase(): SimultaneousPhaseSnapshot | null;
+
+declare function usePlayerTurnOrder(): readonly PlayerId$1[];
+
+type EqualityFn<T> = (left: T, right: T) => boolean;
+
+declare function useGameSelector<T>(selector: (state: GameView) => T, equalityFn?: EqualityFn<T>): T;
+
+declare function useIsMyTurn(): boolean;
+
+interface ViewCard<CardIdValue extends string = string, CardTypeValue extends string = string, Properties extends Record<string, unknown> = Record<string, unknown>> {
+    id: CardIdValue;
+    cardType: CardTypeValue;
+    name?: string;
+    text?: string;
+    properties: Properties;
+}
+interface CardCollection<CardIdValue extends string = string, Card extends ViewCard<CardIdValue> = ViewCard<CardIdValue>> {
+    cardIds: readonly CardIdValue[];
+    cardsById: Readonly<Record<CardIdValue, Card | undefined>>;
+}
+
+interface ViewSlotOccupant<PieceIdValue extends string = string, PlayerIdValue extends string = string, SlotIdValue extends string = string, Data extends Record<string, unknown> = Record<string, unknown>> {
+    pieceId: PieceIdValue;
+    playerId: PlayerIdValue | null;
+    slotId: SlotIdValue;
+    data?: Data;
+}
+
+declare function useCards<CardIdValue extends string, CardValue extends ViewCard<CardIdValue>>(collection: CardCollection<CardIdValue, CardValue>): CardValue[];
+
+declare function useGameView(): GameView;
+
+declare function useLobby(): LobbyState;
+
+type CardIdsByHandId = Record<string, PerPlayer<CardId[]>>;
+type StateName = string;
+type TilePropertiesByBoardId = Record<BoardId, Record<string, unknown>>;
+type EdgePropertiesByBoardId = Record<BoardId, Record<string, unknown>>;
+type VertexPropertiesByBoardId = Record<BoardId, Record<string, unknown>>;
+interface Player {
+    
+    playerId: PlayerId$1;
+    
+    name: string;
+    
+    isHost?: boolean;
+    
+    color?: string;
+}
+interface HexTileState<B extends string = BoardId, SpaceIdValue extends SpaceId = SpaceId, Properties = B extends keyof TilePropertiesByBoardId ? TilePropertiesByBoardId[B] : undefined, View = unknown> {
+    
+    id: SpaceIdValue;
+    
+    q: number;
+    
+    r: number;
+    
+    typeId?: SpaceTypeId;
+    
+    label?: string;
+    
+    owner?: PlayerId$1;
+    
+    properties?: Properties;
+    
+    view?: View;
+}
+
+interface HexEdgeState<B extends string = BoardId, SpaceIdValue extends SpaceId = SpaceId, EdgeIdValue extends string = string, Properties = B extends keyof EdgePropertiesByBoardId ? EdgePropertiesByBoardId[B] : undefined> {
+    
+    id: EdgeIdValue;
+    
+    hex1: SpaceIdValue;
+    
+    hex2: SpaceIdValue;
+    
+    typeId?: EdgeTypeId;
+    
+    label?: string;
+    
+    owner?: PlayerId$1;
+    
+    properties?: Properties;
+}
+
+interface HexVertexState<B extends string = BoardId, SpaceIdValue extends SpaceId = SpaceId, VertexIdValue extends string = string, Properties = B extends keyof VertexPropertiesByBoardId ? VertexPropertiesByBoardId[B] : undefined> {
+    
+    id: VertexIdValue;
+    
+    hexes: readonly SpaceIdValue[];
+    
+    typeId?: VertexTypeId;
+    
+    label?: string;
+    
+    owner?: PlayerId$1;
+    
+    properties?: Properties;
+}
+
+interface HexBoardState<B extends string = BoardId, SpaceIdValue extends SpaceId = SpaceId, EdgeIdValue extends string = string, VertexIdValue extends string = string, TileProperties = B extends keyof TilePropertiesByBoardId ? TilePropertiesByBoardId[B] : undefined, EdgeProperties = B extends keyof EdgePropertiesByBoardId ? EdgePropertiesByBoardId[B] : undefined, VertexProperties = B extends keyof VertexPropertiesByBoardId ? VertexPropertiesByBoardId[B] : undefined> {
+    
+    id: B;
+    
+    tiles: ReadonlyArray<HexTileState<B, SpaceIdValue, TileProperties>>;
+    
+    edges: ReadonlyArray<HexEdgeState<B, SpaceIdValue, EdgeIdValue, EdgeProperties>>;
+    
+    vertices: ReadonlyArray<HexVertexState<B, SpaceIdValue, VertexIdValue, VertexProperties>>;
+}
+
+interface NetworkNodeState {
+    
+    id: SpaceId;
+    
+    x: number;
+    
+    y: number;
+    
+    typeId?: SpaceTypeId;
+    
+    label?: string;
+    
+    owner?: PlayerId$1;
+    
+    properties?: string;
+}
+
+interface NetworkEdgeState {
+    
+    id: string;
+    
+    from: SpaceId;
+    
+    to: SpaceId;
+    
+    typeId?: string;
+    
+    label?: string;
+    
+    owner?: PlayerId$1;
+    
+    properties?: string;
+}
+
+interface NetworkPieceState {
+    
+    id: PieceId;
+    
+    nodeId: SpaceId;
+    
+    typeId?: PieceTypeId;
+    
+    owner?: PlayerId$1;
+    
+    properties?: string;
+}
+
+interface NetworkBoardState {
+    
+    id: BoardId;
+    
+    nodes: NetworkNodeState[];
+    
+    edges: NetworkEdgeState[];
+    
+    pieces: NetworkPieceState[];
+}
+
+interface SquareCellState<SpaceIdValue extends SpaceId = SpaceId, Properties = Record<string, unknown>> {
+    
+    id: SpaceIdValue;
+    
+    row: number;
+    
+    col: number;
+    
+    typeId?: SpaceTypeId;
+    
+    label?: string;
+    
+    owner?: PlayerId$1;
+    
+    properties?: Properties;
+}
+
+interface SquareEdgeState<SpaceIdValue extends SpaceId = SpaceId, EdgeIdValue extends string = string, Properties = Record<string, unknown>> {
+    
+    id: EdgeIdValue;
+    
+    spaceIds: readonly SpaceIdValue[];
+    
+    typeId?: EdgeTypeId;
+    
+    label?: string;
+    
+    owner?: PlayerId$1;
+    
+    properties?: Properties;
+}
+
+interface SquareVertexState<SpaceIdValue extends SpaceId = SpaceId, VertexIdValue extends string = string, Properties = Record<string, unknown>> {
+    
+    id: VertexIdValue;
+    
+    spaceIds: readonly SpaceIdValue[];
+    
+    typeId?: VertexTypeId;
+    
+    label?: string;
+    
+    owner?: PlayerId$1;
+    
+    properties?: Properties;
+}
+
+interface SquarePieceState<PieceIdValue extends PieceId = PieceId, Properties = Record<string, unknown>> {
+    
+    id: PieceIdValue;
+    
+    row: number;
+    
+    col: number;
+    
+    typeId: PieceTypeId;
+    
+    owner?: PlayerId$1;
+    
+    properties?: Properties;
+}
+
+interface SquareBoardState<B extends string = BoardId, SpaceIdValue extends SpaceId = SpaceId, EdgeIdValue extends string = string, VertexIdValue extends string = string, PieceIdValue extends PieceId = PieceId, CellProperties = Record<string, unknown>, EdgeProperties = Record<string, unknown>, VertexProperties = Record<string, unknown>, PieceProperties = Record<string, unknown>> {
+    
+    id: B;
+    
+    rows: number;
+    
+    cols: number;
+    
+    cells: ReadonlyArray<SquareCellState<SpaceIdValue, CellProperties>>;
+    
+    edges: ReadonlyArray<SquareEdgeState<SpaceIdValue, EdgeIdValue, EdgeProperties>>;
+    
+    vertices: ReadonlyArray<SquareVertexState<SpaceIdValue, VertexIdValue, VertexProperties>>;
+    
+    pieces: ReadonlyArray<SquarePieceState<PieceIdValue, PieceProperties>>;
+}
+
+interface TrackSpaceState {
+    
+    id: SpaceId;
+    
+    index: number;
+    
+    x: number;
+    
+    y: number;
+    
+    name?: string;
+    
+    typeId?: SpaceTypeId;
+    
+    owner?: PlayerId$1;
+    
+    nextSpaces?: SpaceId[];
+    
+    properties?: string;
+}
+
+interface TrackPieceState {
+    
+    id: PieceId;
+    
+    spaceId: SpaceId;
+    
+    owner: PlayerId$1;
+    
+    typeId?: PieceTypeId;
+    
+    properties?: string;
+}
+
+interface TrackBoardState {
+    
+    id: BoardId;
+    
+    spaces: TrackSpaceState[];
+    
+    pieces: TrackPieceState[];
+}
+
+interface DieState {
+    
+    id: DieId;
+    
+    sides: number;
+    
+    currentValue?: number;
+    
+    color?: string;
+}
+
+interface BoardKindStates<State> {
+    
+    shared: Record<BoardBaseId, State>;
+    
+    perPlayer: Record<BoardBaseId, PerPlayer<State>>;
+}
+
+interface BoardStates {
+    
+    hex: BoardKindStates<HexBoardState>;
+    
+    network: BoardKindStates<NetworkBoardState>;
+    
+    square: BoardKindStates<SquareBoardState>;
+    
+    track: BoardKindStates<TrackBoardState>;
+}
+
+type DiceStates = Record<DieId, DieState>;
+interface GameState {
+    
+    currentPlayerIds: PlayerId$1[];
+    decks: CardIdsByDeckId;
+    
+    hands: CardIdsByHandId;
+    
+    cards: Record<CardId, ViewCard<CardId, string, CardProperties>>;
+    
+    playerResources: PerPlayer<Record<string, number>>;
+    currentState: StateName;
+    isMyTurn: boolean;
+    boards: BoardStates;
+    dice: DiceStates;
+}
+
+declare function useMe(): Player;
+
+declare function usePlayerInfo(): Map<PlayerId$1, Player>;
+
+interface SeatInbox {
+    
+    bySurface: Record<string, readonly InteractionDescriptor[]>;
+    
+    prompts: readonly InteractionDescriptor[];
+    
+    all: readonly InteractionDescriptor[];
+}
+
+declare function useSeatInbox(): SeatInbox;
+
+type InteractionParamsShape = Record<string, unknown>;
+type InteractionHandleStatus = "open" | "submitting" | "submitted";
+type DraftValidation<Params extends InteractionParamsShape = InteractionParamsShape> = {
+    ok: true;
+    params: Params;
+    fieldErrors: Partial<Record<keyof Params & string, readonly string[]>>;
+    formErrors: readonly string[];
+    missing: ReadonlyArray<keyof Params & string>;
+} | {
+    ok: false;
+    fieldErrors: Partial<Record<keyof Params & string, readonly string[]>>;
+    formErrors: readonly string[];
+    missing: ReadonlyArray<keyof Params & string>;
+};
+
+interface InteractionHandle<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never> {
+    descriptor: InteractionDescriptor;
+    
+    commit: InteractionDescriptor["commit"];
+    
+    submit: (params?: Params) => Promise<void>;
+    
+    validate: (params?: Params) => Promise<void>;
+    
+    validateDraft: () => DraftValidation<Params>;
+    
+    validateDraftServer: () => Promise<void>;
+    
+    submitDraft: () => Promise<void>;
+    
+    available: boolean;
+    
+    unavailableReason?: string;
+    
+    status: InteractionHandleStatus;
+    
+    draft: Readonly<Partial<Params>>;
+    
+    values: Readonly<Partial<Params> & Pick<Params, DefaultedKeys>>;
+    
+    setInput: <K extends keyof Params & string>(key: K, value: Params[K]) => void;
+    
+    clearInput: (key?: keyof Params & string) => void;
+    
+    isReady: boolean;
+    
+    isArmed: boolean;
+    
+    arm: () => void;
+    
+    disarm: () => void;
+}
+
+declare function useInteractionHandle<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never>(descriptor: InteractionDescriptor): InteractionHandle<Params, DefaultedKeys>;
+
+declare function useInteractionByKey<Key extends string = string, Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never>(interactionKey: Key | null | undefined): InteractionHandle<Params, DefaultedKeys> | null;
+
+interface ValidationResult {
+    
+    valid: boolean;
+    
+    errorCode?: string;
+    
+    message?: string;
+}
+
+interface SubmissionError extends Error {
+    
+    errorCode?: string;
+}
+
+interface PluginSessionState {
+    
+    status: "loading" | "ready";
+    
+    sessionId: string | null;
+    
+    controllablePlayerIds: PlayerId$1[];
+    
+    controllingPlayerId: PlayerId$1 | null;
+    
+    userId: string | null;
+}
+
+interface RuntimeAPI {
+    
+    validateInteraction: (playerId: PlayerId$1, interactionId: string, params: unknown) => Promise<ValidationResult>;
+    
+    submitInteraction: (playerId: PlayerId$1, interactionId: string, params: unknown) => Promise<void>;
+    
+    getSessionState: () => PluginSessionState;
+    
+    disconnect: () => void;
+    
+    switchPlayer?: (playerId: PlayerId$1) => void;
+}
+
+declare function usePluginSession(): PluginSessionState;
+
+interface ClientParamSchema {
+    safeParse: (value: unknown) => {
+        success: true;
+        data: Record<string, unknown>;
+    } | {
+        success: false;
+        error: {
+            issues: ReadonlyArray<{
+                path: readonly PropertyKey[];
+                message: string;
+            }>;
+        };
+    };
+}
+type ClientParamSchemaMap = Readonly<Record<string, Readonly<Record<string, ClientParamSchema>>>>;
+
+type StageName = string;
+type InteractionId = string;
+type GameplaySnapshot = GameplaySnapshot$1<PhaseName, StageName, InteractionId>;
+
+interface PromptDialogHostProps {
+    contentClassName?: string;
+    messageClassName?: string;
+    optionClassName?: string;
+    optionsClassName?: string;
+    overlayClassName?: string;
+    titleClassName?: string;
+    renderBody?: (prompt: InteractionDescriptor) => ReactNode;
+    renderOptionLabel?: (option: InteractionContextOption, prompt: InteractionDescriptor) => ReactNode;
+    onSubmitError?: (error: unknown, prompt: InteractionDescriptor, option: InteractionContextOption) => void;
+}
+declare function PromptDialogHost(props: PromptDialogHostProps): react_jsx_runtime.JSX.Element | null;
+
+interface InteractiveTargetLayer {
+    enabled?: boolean;
+    eligible?: ReadonlySet<string>;
+    selectTargetId?: (targetId: string) => void | Promise<void>;
+}
+interface InteractiveTargetRenderState {
+    isEnabled: boolean;
+    isEligible: boolean;
+    isHovered: boolean;
+}
+
+type BoardTargetKind = "edge" | "vertex" | "space" | "tile";
+
+type BoardEligibleTargets = Readonly<Record<BoardTargetKind, ReadonlySet<string>>>;
+interface BoardTargetLayerOptions {
+    enabled?: boolean;
+    extraInputs?: Record<string, unknown> | ((targetId: string) => Record<string, unknown>);
+    onBeforeSelect?: () => void;
+    onError?: (error: unknown) => void;
+}
+type BoardTargetLayerFactory = (options?: BoardTargetLayerOptions) => InteractiveTargetLayer;
+interface BoardInteractionsOptions {
+    
+    targetKinds?: readonly BoardTargetKind[];
+}
+declare class BoardInteractionConflictError extends Error {
+    readonly name = "BoardInteractionConflictError";
+    readonly targetKind: BoardTargetKind;
+    readonly targetId: string;
+    readonly interactionKeys: readonly string[];
+    constructor({ targetKind, targetId, interactionKeys, }: {
+        targetKind: BoardTargetKind;
+        targetId: string;
+        interactionKeys: readonly string[];
+    });
+}
+
+interface BoardInteractionsContext<I extends string = string> {
+    
+    interactions: ReadonlyArray<InteractionDescriptor<I>>;
+    
+    eligible: BoardEligibleTargets;
+    
+    isEligible(targetId: string, targetKind?: BoardTargetKind): boolean;
+    
+    select: {
+        edge(targetId: string, extraInputs?: Record<string, unknown>): Promise<string | null>;
+        vertex(targetId: string, extraInputs?: Record<string, unknown>): Promise<string | null>;
+        space(targetId: string, extraInputs?: Record<string, unknown>): Promise<string | null>;
+        tile(targetId: string, extraInputs?: Record<string, unknown>): Promise<string | null>;
+    };
+    
+    targetLayers: {
+        edge: BoardTargetLayerFactory;
+        vertex: BoardTargetLayerFactory;
+        space: BoardTargetLayerFactory;
+        tile: BoardTargetLayerFactory;
+    };
+}
+
+declare function useBoardInteractions<I extends string = string>(options?: BoardInteractionsOptions): BoardInteractionsContext<I>;
+
+type PrimitiveDataAttributes = Record<`data-${string}`, string | boolean | number | undefined>;
+type PrimitiveCommonProps = {
+    asChild?: boolean;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+} & AriaAttributes & PrimitiveDataAttributes;
+type EventHandler<Event> = (event: Event) => void;
+declare function composeEventHandlers<Event extends {
+    defaultPrevented: boolean;
+}>(authorHandler: EventHandler<Event> | undefined, primitiveHandler: EventHandler<Event> | undefined): EventHandler<Event> | undefined;
+declare function renderPrimitive<ElementProps extends HTMLAttributes<HTMLElement>>(tagName: keyof JSX.IntrinsicElements, props: ElementProps & PrimitiveCommonProps): ReactElement;
+
+type BoardContextValue = ReturnType<typeof useBoardInteractions>;
+declare function useBoardPrimitiveContext(): BoardContextValue;
+interface BoardRootProps extends PrimitiveCommonProps {
+    children: ReactNode;
+    targetKinds?: readonly BoardTargetKind[];
+}
+declare function BoardRoot({ children, targetKinds, ...props }: BoardRootProps): react_jsx_runtime.JSX.Element;
+type BoardTargetExtraInputs = Record<string, unknown> | ((targetId: string) => Record<string, unknown>);
+type BoardTargetProps<Target extends string = BoardTargetKey> = PrimitiveCommonProps & ButtonHTMLAttributes<HTMLButtonElement> & {
+    kind: BoardTargetKind;
+    value: Target;
+    interaction?: string;
+    input?: string;
+    extraInputs?: BoardTargetExtraInputs;
+    onSelect?: (interactionKey: string | null) => void;
+    onSelectError?: (error: unknown) => void;
+};
+declare function BoardTarget<Target extends string = BoardTargetKey>({ interaction, input, ...props }: BoardTargetProps<Target>): react_jsx_runtime.JSX.Element;
+declare const Board: {
+    Root: typeof BoardRoot;
+    Target: typeof BoardTarget;
+};
+
+interface InteractionContextValue {
+    interaction: string;
+    descriptor: InteractionDescriptor | null;
+    handle: ReturnType<typeof useInteractionHandle> | null;
+}
+declare function useInteractionPrimitiveContext(): InteractionContextValue;
+interface InteractionRootProps<Interaction extends string = InteractionKey> {
+    interaction: Interaction;
+    children: ReactNode;
+    unavailable?: "render" | "hide";
+}
+declare function InteractionRoot<Interaction extends string = InteractionKey>({ interaction, children, unavailable, }: InteractionRootProps<Interaction>): react_jsx_runtime.JSX.Element | null;
+type InteractionPartProps = PrimitiveCommonProps & HTMLAttributes<HTMLElement>;
+declare function InteractionLabel({ children, ...props }: InteractionPartProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function InteractionDescription({ children, ...props }: InteractionPartProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | null;
+declare function InteractionUnavailableMessage({ children, ...props }: InteractionPartProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | null;
+declare function InteractionValidationMessage({ children, ...props }: InteractionPartProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | null;
+type InteractionTriggerProps = PrimitiveCommonProps & ButtonHTMLAttributes<HTMLButtonElement>;
+declare function InteractionTrigger({ disabled, onClick, ...props }: InteractionTriggerProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+type InteractionSubmitProps = PrimitiveCommonProps & ButtonHTMLAttributes<HTMLButtonElement>;
+declare function InteractionSubmit({ disabled, onClick, ...props }: InteractionSubmitProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+type InteractionInputProps = PrimitiveCommonProps & Omit<InputHTMLAttributes<HTMLInputElement>, "name"> & {
+    name: string;
+    parse?: (value: string) => unknown;
+};
+declare function InteractionInput({ name, parse, onChange, disabled, ...props }: InteractionInputProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+type InteractionCardInputProps<Input extends string = InteractionInputKey> = PrimitiveCommonProps & ButtonHTMLAttributes<HTMLButtonElement> & {
+    input: Input;
+    value?: string;
+    card?: string;
+    selected?: boolean;
+    onSelectedChange?: (selected: boolean) => void;
+};
+declare function InteractionCardInput<Input extends string = InteractionInputKey>({ input, value, card, selected, onSelectedChange, onClick, disabled, children, ...props }: InteractionCardInputProps<Input>): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare const Interaction: {
+    Root: typeof InteractionRoot;
+    Trigger: typeof InteractionTrigger;
+    Label: typeof InteractionLabel;
+    Description: typeof InteractionDescription;
+    UnavailableMessage: typeof InteractionUnavailableMessage;
+    ValidationMessage: typeof InteractionValidationMessage;
+    Input: typeof InteractionInput;
+    CardInput: typeof InteractionCardInput;
+    Submit: typeof InteractionSubmit;
+};
+
+type PhaseRouteMap<Phase extends string = PhaseKey> = {
+    readonly [Key in Phase]: () => ReactNode;
+};
+type PhaseFallback = ReactNode | ((phase: string | null) => ReactNode);
+interface PhaseSwitchProps<Phase extends string = PhaseKey> {
+    routes: PhaseRouteMap<Phase>;
+    fallback?: PhaseFallback;
+}
+declare function PhaseSwitch<Phase extends string = PhaseKey>({ routes, fallback, }: PhaseSwitchProps<Phase>): ReactElement | null;
+declare const Phase: {
+    Switch: typeof PhaseSwitch;
+};
+
+interface PlayerRosterBadge {
+    key: string;
+    label?: ReactNode;
+    icon?: ReactNode;
+    tooltip?: string;
+}
+interface PlayerRosterEntry {
+    playerId: PlayerId$1;
+    name: string;
+    color?: string;
+    index: number;
+    isActive: boolean;
+    isCurrentPlayer: boolean;
+    isControllable: boolean;
+    canSwitchToPlayer: boolean;
+    score?: number;
+    scoreLabel?: string;
+    badges: readonly PlayerRosterBadge[];
+    metadata?: Record<string, unknown>;
+}
+interface PlayerRosterRootProps {
+    children: ReactNode;
+    order?: "turn" | "self-first";
+    include?: "all" | "self" | "opponents";
+    score?: (playerId: PlayerId$1) => number | undefined;
+    scoreLabel?: string | ((playerId: PlayerId$1) => string | undefined);
+    badges?: (playerId: PlayerId$1) => ReadonlyArray<PlayerRosterBadge | null | false | undefined>;
+    metadata?: (playerId: PlayerId$1) => Record<string, unknown> | undefined;
+}
+declare function PlayerRosterRoot({ children, order, include, score, scoreLabel, badges, metadata, }: PlayerRosterRootProps): react_jsx_runtime.JSX.Element;
+type PlayerRosterListProps = Omit<PrimitiveCommonProps, "children"> & Omit<HTMLAttributes<HTMLElement>, "children"> & {
+    children?: (player: PlayerRosterEntry) => ReactNode;
+};
+declare function PlayerRosterList({ children, ...props }: PlayerRosterListProps): ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function PlayerRosterEmpty({ children }: {
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element | null;
+type PlayerRosterSwitchButtonProps = Omit<PrimitiveCommonProps, "children"> & ButtonHTMLAttributes<HTMLButtonElement> & {
+    player: PlayerRosterEntry;
+    children?: ReactNode;
+};
+declare function PlayerRosterSwitchButton({ player, disabled, onClick, ...props }: PlayerRosterSwitchButtonProps): ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+type PlayerRosterPartProps = PrimitiveCommonProps & HTMLAttributes<HTMLElement> & {
+    player: PlayerRosterEntry;
+};
+interface PlayerRosterComponents {
+    Root(props: PlayerRosterRootProps): ReactElement | null;
+    List(props: PlayerRosterListProps): ReactElement;
+    Empty(props: {
+        children?: ReactNode;
+    }): ReactElement | null;
+    SwitchButton(props: PlayerRosterSwitchButtonProps): ReactElement;
+    Name(props: PlayerRosterPartProps): ReactElement;
+    Score(props: PlayerRosterPartProps): ReactElement | null;
+    Badges(props: PlayerRosterPartProps): ReactElement | null;
+}
+declare function PlayerRosterName({ player, children, ...props }: PlayerRosterPartProps): ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function PlayerRosterScore({ player, children, ...props }: PlayerRosterPartProps): ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | null;
+declare function PlayerRosterBadges({ player, children, ...props }: PlayerRosterPartProps): ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | null;
+declare const PlayerRoster: PlayerRosterComponents;
+
+type PromptRootProps<Prompt extends string = PromptKey> = InteractionRootProps<Prompt>;
+declare function PromptRoot<Prompt extends string = PromptKey>(props: PromptRootProps<Prompt>): react_jsx_runtime.JSX.Element;
+declare function PromptTitle(props: InteractionPartProps): react_jsx_runtime.JSX.Element;
+declare function PromptMessage(props: InteractionPartProps): react_jsx_runtime.JSX.Element | null;
+type PromptOptionProps<Option extends string = PromptOptionKey> = PrimitiveCommonProps & ButtonHTMLAttributes<HTMLButtonElement> & {
+    value: Option;
+    disableWhenUnavailable?: boolean;
+    onSubmitError?: (error: unknown) => void;
+    onSubmitSuccess?: () => void;
+};
+declare function PromptOption<Option extends string = PromptOptionKey>({ value, disabled, disableWhenUnavailable, onClick, onSubmitError, onSubmitSuccess, children, ...props }: PromptOptionProps<Option>): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function PromptOptions({ children, }: {
+    children?: (option: {
+        id: string;
+        label?: string;
+    }) => ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function PromptInboxRoot({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function PromptInboxEmpty({ children }: {
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element | null;
+declare function PromptInboxItems({ children, }: {
+    children?: (prompt: InteractionDescriptor) => ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare const Prompt: {
+    Root: typeof PromptRoot;
+    Title: typeof PromptTitle;
+    Message: typeof PromptMessage;
+    Option: typeof PromptOption;
+    Options: typeof PromptOptions;
+};
+declare const PromptInbox: {
+    Root: typeof PromptInboxRoot;
+    Empty: typeof PromptInboxEmpty;
+    Items: typeof PromptInboxItems;
+};
+
+interface ZoneContextValue {
+    zone: string;
+    snapshot: ZoneHandlesSnapshot | null;
+}
+interface ZoneCardContextValue {
+    zone: string;
+    cardId: string;
+}
+declare function useZonePrimitiveContext(): ZoneContextValue;
+declare function useZoneCardContext(): ZoneCardContextValue | null;
+interface ZoneRootProps<Zone extends string = ZoneKey> extends PrimitiveCommonProps, HTMLAttributes<HTMLElement> {
+    zone: Zone;
+}
+declare function ZoneRoot<Zone extends string = ZoneKey>({ zone, children, ...props }: ZoneRootProps<Zone>): react_jsx_runtime.JSX.Element;
+type ZoneListProps = PrimitiveCommonProps & HTMLAttributes<HTMLElement>;
+declare function ZoneList({ children, ...props }: ZoneListProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+interface ZoneItemProps extends PrimitiveCommonProps, HTMLAttributes<HTMLElement> {
+    card: string;
+}
+declare function ZoneItem({ card, children, ...props }: ZoneItemProps): react_jsx_runtime.JSX.Element;
+declare const Zone: {
+    Root: typeof ZoneRoot;
+    List: typeof ZoneList;
+    Item: typeof ZoneItem;
+};
+
+interface DreamboardUIRegister {
+}
+type UIContractBucket = Record<string, unknown>;
+interface UIContract {
+    interactions?: UIContractBucket;
+    inputs?: UIContractBucket;
+    prompts?: UIContractBucket;
+    promptOptions?: UIContractBucket;
+    zones?: UIContractBucket;
+    cards?: UIContractBucket;
+    phases?: UIContractBucket;
+    boardTargets?: UIContractBucket;
+}
+type RegisteredUIContract = DreamboardUIRegister extends {
+    ui: infer Registered extends UIContract;
+} ? Registered : UIContract;
+type BucketOf<Contract extends UIContract, Key extends keyof UIContract> = NonNullable<Contract[Key]> extends UIContractBucket ? NonNullable<Contract[Key]> : UIContractBucket;
+type StringKeysOrFallback<Bucket extends UIContractBucket> = string extends Extract<keyof Bucket, string> ? string : Extract<keyof Bucket, string>;
+type RegisteredUI = RegisteredUIContract;
+type InteractionKey<Contract extends UIContract = RegisteredUI> = StringKeysOrFallback<BucketOf<Contract, "interactions">>;
+type InteractionInputKey<Contract extends UIContract = RegisteredUI> = StringKeysOrFallback<BucketOf<Contract, "inputs">>;
+type PromptKey<Contract extends UIContract = RegisteredUI> = StringKeysOrFallback<BucketOf<Contract, "prompts">>;
+type PromptOptionKey<Contract extends UIContract = RegisteredUI> = StringKeysOrFallback<BucketOf<Contract, "promptOptions">>;
+type ZoneKey<Contract extends UIContract = RegisteredUI> = StringKeysOrFallback<BucketOf<Contract, "zones">>;
+type CardKey<Contract extends UIContract = RegisteredUI> = StringKeysOrFallback<BucketOf<Contract, "cards">>;
+type PhaseKey<Contract extends UIContract = RegisteredUI> = StringKeysOrFallback<BucketOf<Contract, "phases">>;
+type BoardTargetKey<Contract extends UIContract = RegisteredUI> = StringKeysOrFallback<BucketOf<Contract, "boardTargets">>;
+type TypedInteraction<Contract extends UIContract> = Omit<typeof Interaction, "Root" | "CardInput"> & {
+    Root<Interaction extends InteractionKey<Contract>>(props: InteractionRootProps<Interaction>): ReactElement | null;
+    CardInput<Input extends InteractionInputKey<Contract>>(props: Omit<InteractionCardInputProps, "input"> & {
+        input: Input;
+    }): ReactElement;
+};
+type TypedPrompt<Contract extends UIContract> = Omit<typeof Prompt, "Root" | "Option"> & {
+    Root<Prompt extends PromptKey<Contract>>(props: PromptRootProps<Prompt>): ReactElement | null;
+    Option<Option extends PromptOptionKey<Contract>>(props: Omit<PromptOptionProps, "value"> & {
+        value: Option;
+    }): ReactElement;
+};
+type TypedPromptInbox = typeof PromptInbox;
+type TypedPlayerRoster = PlayerRosterComponents;
+type TypedPhase<Contract extends UIContract> = Omit<typeof Phase, "Switch"> & {
+    Switch(props: PhaseSwitchProps<PhaseKey<Contract>>): ReactElement | null;
+};
+type TypedZone<Contract extends UIContract> = Omit<typeof Zone, "Root"> & {
+    Root<Zone extends ZoneKey<Contract>>(props: Omit<ZoneRootProps, "zone"> & {
+        zone: Zone;
+    }): ReactElement;
+};
+type TypedBoard<Contract extends UIContract> = Omit<typeof Board, "Target"> & {
+    Target<Target extends BoardTargetKey<Contract>>(props: Omit<BoardTargetProps, "value"> & {
+        value: Target;
+    }): ReactElement;
+};
+interface DreamboardUI<Contract extends UIContract = RegisteredUI> {
+    readonly contract: Contract;
+    readonly Interaction: TypedInteraction<Contract>;
+    readonly Prompt: TypedPrompt<Contract>;
+    readonly PromptInbox: TypedPromptInbox;
+    readonly PlayerRoster: TypedPlayerRoster;
+    readonly PromptDialogHost: (props: PromptDialogHostProps) => ReactElement | null;
+    readonly Phase: TypedPhase<Contract>;
+    readonly Zone: TypedZone<Contract>;
+    readonly Board: TypedBoard<Contract>;
+}
+declare function createDreamboardUI<const Contract extends UIContract>(contract: Contract): DreamboardUI<Contract>;
+
+type RuntimeFields = Record<string, unknown>;
+interface GeneratedTiledEdgeStateLike<SpaceIdValue extends string = string, EdgeIdValue extends string = string, Fields = RuntimeFields> {
+    id: EdgeIdValue;
+    spaceIds: readonly SpaceIdValue[];
+    typeId?: EdgeTypeId | null;
+    label?: string | null;
+    ownerId?: PlayerId$1 | null;
+    fields?: Fields;
+}
+interface GeneratedTiledVertexStateLike<SpaceIdValue extends string = string, VertexIdValue extends string = string, Fields = RuntimeFields> {
+    id: VertexIdValue;
+    spaceIds: readonly SpaceIdValue[];
+    typeId?: VertexTypeId | null;
+    label?: string | null;
+    ownerId?: PlayerId$1 | null;
+    fields?: Fields;
+}
+interface GeneratedHexSpaceStateLike<SpaceIdValue extends string = string, Fields = RuntimeFields> {
+    id: SpaceIdValue;
+    q: number;
+    r: number;
+    typeId?: SpaceTypeId | null;
+    label?: string | null;
+    ownerId?: PlayerId$1 | null;
+    fields?: Fields;
+}
+interface GeneratedSquareSpaceStateLike<SpaceIdValue extends string = string, Fields = RuntimeFields> {
+    id: SpaceIdValue;
+    row: number;
+    col: number;
+    typeId?: SpaceTypeId | null;
+    label?: string | null;
+    ownerId?: PlayerId$1 | null;
+    fields?: Fields;
+}
+interface GeneratedHexBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields> {
+    id: BoardIdValue;
+    layout?: "hex";
+    orientation?: "pointy-top" | "flat-top";
+    spaces: Readonly<Record<SpaceIdValue, GeneratedHexSpaceStateLike<SpaceIdValue, SpaceFields>>>;
+    edges: ReadonlyArray<HexEdgeState<BoardIdValue, SpaceIdValue, EdgeIdValue, EdgeFields> | GeneratedTiledEdgeStateLike<SpaceIdValue, EdgeIdValue, EdgeFields>>;
+    vertices: ReadonlyArray<HexVertexState<BoardIdValue, SpaceIdValue, VertexIdValue, VertexFields> | GeneratedTiledVertexStateLike<SpaceIdValue, VertexIdValue, VertexFields>>;
+}
+interface AuthoredHexBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields, SpaceView = unknown> {
+    id: BoardIdValue;
+    layout?: "hex";
+    orientation?: "pointy-top" | "flat-top";
+    tiles: ReadonlyArray<HexTileState<BoardIdValue, SpaceIdValue, SpaceFields, SpaceView>>;
+    edges: ReadonlyArray<HexEdgeState<BoardIdValue, SpaceIdValue, EdgeIdValue, EdgeFields> | GeneratedTiledEdgeStateLike<SpaceIdValue, EdgeIdValue, EdgeFields>>;
+    vertices: ReadonlyArray<HexVertexState<BoardIdValue, SpaceIdValue, VertexIdValue, VertexFields> | GeneratedTiledVertexStateLike<SpaceIdValue, VertexIdValue, VertexFields>>;
+}
+type HexBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields> = AuthoredHexBoardInput<BoardIdValue, SpaceIdValue, EdgeIdValue, VertexIdValue, SpaceFields, EdgeFields, VertexFields> | GeneratedHexBoardInput<BoardIdValue, SpaceIdValue, EdgeIdValue, VertexIdValue, SpaceFields, EdgeFields, VertexFields>;
+interface GeneratedSquareBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, PieceIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields, PieceFields = RuntimeFields> {
+    id: BoardIdValue;
+    layout?: "square";
+    spaces: Readonly<Record<SpaceIdValue, GeneratedSquareSpaceStateLike<SpaceIdValue, SpaceFields>>>;
+    edges: ReadonlyArray<SquareEdgeState<SpaceIdValue, EdgeIdValue, EdgeFields> | GeneratedTiledEdgeStateLike<SpaceIdValue, EdgeIdValue, EdgeFields>>;
+    vertices: ReadonlyArray<SquareVertexState<SpaceIdValue, VertexIdValue, VertexFields> | GeneratedTiledVertexStateLike<SpaceIdValue, VertexIdValue, VertexFields>>;
+    pieces?: ReadonlyArray<SquarePieceState<PieceIdValue, PieceFields>>;
+}
+interface AuthoredSquareBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, PieceIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields, PieceFields = RuntimeFields> {
+    id: BoardIdValue;
+    layout?: "square";
+    rows: number;
+    cols: number;
+    cells: ReadonlyArray<SquareCellState<SpaceIdValue, SpaceFields>>;
+    edges: ReadonlyArray<SquareEdgeState<SpaceIdValue, EdgeIdValue, EdgeFields> | GeneratedTiledEdgeStateLike<SpaceIdValue, EdgeIdValue, EdgeFields>>;
+    vertices: ReadonlyArray<SquareVertexState<SpaceIdValue, VertexIdValue, VertexFields> | GeneratedTiledVertexStateLike<SpaceIdValue, VertexIdValue, VertexFields>>;
+    pieces: ReadonlyArray<SquarePieceState<PieceIdValue, PieceFields>>;
+}
+type SquareBoardInput<BoardIdValue extends string = BoardId, SpaceIdValue extends string = string, EdgeIdValue extends string = string, VertexIdValue extends string = string, PieceIdValue extends string = string, SpaceFields = RuntimeFields, EdgeFields = RuntimeFields, VertexFields = RuntimeFields, PieceFields = RuntimeFields> = AuthoredSquareBoardInput<BoardIdValue, SpaceIdValue, EdgeIdValue, VertexIdValue, PieceIdValue, SpaceFields, EdgeFields, VertexFields, PieceFields> | GeneratedSquareBoardInput<BoardIdValue, SpaceIdValue, EdgeIdValue, VertexIdValue, PieceIdValue, SpaceFields, EdgeFields, VertexFields, PieceFields>;
+type AnyHexBoardInput = HexBoardInput<string, string, string, string, RuntimeFields, RuntimeFields, RuntimeFields>;
+type AnySquareBoardInput = SquareBoardInput<string, string, string, string, string, RuntimeFields, RuntimeFields, RuntimeFields, RuntimeFields>;
+type BoardIdOf<TBoard> = TBoard extends {
+    id: infer Id extends string;
+} ? Id : string;
+type SpaceRecordValueOf<TBoard> = TBoard extends {
+    spaces: Readonly<Record<string, infer Space>>;
+} ? Space : never;
+type TileValueOf<TBoard> = TBoard extends {
+    tiles: ReadonlyArray<infer Tile>;
+} ? Tile : never;
+type CellValueOf<TBoard> = TBoard extends {
+    cells: ReadonlyArray<infer Cell>;
+} ? Cell : never;
+type EdgeValueOf<TBoard> = TBoard extends {
+    edges: ReadonlyArray<infer Edge>;
+} ? Edge : never;
+type VertexValueOf<TBoard> = TBoard extends {
+    vertices: ReadonlyArray<infer Vertex>;
+} ? Vertex : never;
+type PieceValueOf<TBoard> = TBoard extends {
+    pieces?: ReadonlyArray<infer Piece>;
+} ? Piece : never;
+type BoardSpaceIdOf<TBoard> = SpaceRecordValueOf<TBoard> extends {
+    id: infer Id extends string;
+} ? Id : TileValueOf<TBoard> extends {
+    id: infer Id extends string;
+} ? Id : CellValueOf<TBoard> extends {
+    id: infer Id extends string;
+} ? Id : never;
+type BoardEdgeIdOf<TBoard> = EdgeValueOf<TBoard> extends {
+    id: infer Id extends string;
+} ? Id : never;
+type BoardVertexIdOf<TBoard> = VertexValueOf<TBoard> extends {
+    id: infer Id extends string;
+} ? Id : never;
+type HexTilePropertiesOf<TBoard> = SpaceRecordValueOf<TBoard> extends {
+    fields?: infer Fields;
+} ? Fields : TileValueOf<TBoard> extends {
+    properties?: infer Properties;
+} ? Properties : RuntimeFields;
+type HexTileViewOf<TBoard> = TileValueOf<TBoard> extends {
+    view: infer View;
+} ? View : TileValueOf<TBoard> extends {
+    view?: infer View;
+} ? View | undefined : unknown;
+type HexEdgePropertiesOf<TBoard> = EdgeValueOf<TBoard> extends {
+    fields?: infer Fields;
+} ? Fields : EdgeValueOf<TBoard> extends {
+    properties?: infer Properties;
+} ? Properties : RuntimeFields;
+type HexVertexPropertiesOf<TBoard> = VertexValueOf<TBoard> extends {
+    fields?: infer Fields;
+} ? Fields : VertexValueOf<TBoard> extends {
+    properties?: infer Properties;
+} ? Properties : RuntimeFields;
+type SquareCellPropertiesOf<TBoard> = SpaceRecordValueOf<TBoard> extends {
+    fields?: infer Fields;
+} ? Fields : CellValueOf<TBoard> extends {
+    properties?: infer Properties;
+} ? Properties : RuntimeFields;
+type SquareEdgePropertiesOf<TBoard> = EdgeValueOf<TBoard> extends {
+    fields?: infer Fields;
+} ? Fields : EdgeValueOf<TBoard> extends {
+    properties?: infer Properties;
+} ? Properties : RuntimeFields;
+type SquareVertexPropertiesOf<TBoard> = VertexValueOf<TBoard> extends {
+    fields?: infer Fields;
+} ? Fields : VertexValueOf<TBoard> extends {
+    properties?: infer Properties;
+} ? Properties : RuntimeFields;
+type SquarePiecePropertiesOf<TBoard> = PieceValueOf<TBoard> extends {
+    properties?: infer Properties;
+} ? Properties : RuntimeFields;
+
+type NormalizedHexTileOf<TBoard extends AnyHexBoardInput> = Omit<HexTileState<BoardIdOf<TBoard>, BoardSpaceIdOf<TBoard>, HexTilePropertiesOf<TBoard>, HexTileViewOf<TBoard>>, "view"> & {
+    view: HexTileViewOf<TBoard>;
+};
+type NormalizedHexEdgeOf<TBoard extends AnyHexBoardInput> = HexEdgeState<BoardIdOf<TBoard>, BoardSpaceIdOf<TBoard>, BoardEdgeIdOf<TBoard>, HexEdgePropertiesOf<TBoard>>;
+type NormalizedHexVertexOf<TBoard extends AnyHexBoardInput> = HexVertexState<BoardIdOf<TBoard>, BoardSpaceIdOf<TBoard>, BoardVertexIdOf<TBoard>, HexVertexPropertiesOf<TBoard>>;
+type NormalizedSquareCellOf<TBoard extends AnySquareBoardInput> = SquareCellState<BoardSpaceIdOf<TBoard>, SquareCellPropertiesOf<TBoard>>;
+type NormalizedSquareEdgeOf<TBoard extends AnySquareBoardInput> = SquareEdgeState<BoardSpaceIdOf<TBoard>, BoardEdgeIdOf<TBoard>, SquareEdgePropertiesOf<TBoard>>;
+type NormalizedSquareVertexOf<TBoard extends AnySquareBoardInput> = SquareVertexState<BoardSpaceIdOf<TBoard>, BoardVertexIdOf<TBoard>, SquareVertexPropertiesOf<TBoard>>;
+type NormalizedSquarePieceOf<TBoard extends AnySquareBoardInput> = SquarePieceState<PieceValueOf<TBoard> extends {
+    id: infer PieceIdValue extends string;
+} ? PieceIdValue : string, SquarePiecePropertiesOf<TBoard>>;
+type NormalizedHexBoard<TBoard extends AnyHexBoardInput> = Omit<Pick<HexBoardState<BoardIdOf<TBoard>, BoardSpaceIdOf<TBoard>, BoardEdgeIdOf<TBoard>, BoardVertexIdOf<TBoard>, HexTilePropertiesOf<TBoard>, HexEdgePropertiesOf<TBoard>, HexVertexPropertiesOf<TBoard>>, "id" | "tiles" | "edges" | "vertices">, "tiles"> & {
+    tiles: ReadonlyArray<NormalizedHexTileOf<TBoard>>;
+    orientation?: "pointy-top" | "flat-top";
+};
+type NormalizedSquareBoard<TBoard extends AnySquareBoardInput> = Pick<SquareBoardState<BoardIdOf<TBoard>, BoardSpaceIdOf<TBoard>, BoardEdgeIdOf<TBoard>, BoardVertexIdOf<TBoard>, PieceValueOf<TBoard> extends {
+    id: infer PieceIdValue extends string;
+} ? PieceIdValue : string, SquareCellPropertiesOf<TBoard>, SquareEdgePropertiesOf<TBoard>, SquareVertexPropertiesOf<TBoard>, SquarePiecePropertiesOf<TBoard>>, "id" | "rows" | "cols" | "cells" | "edges" | "vertices" | "pieces">;
+declare function normalizeHexBoardInput<TBoard extends AnyHexBoardInput>(board: TBoard): NormalizedHexBoard<TBoard>;
+declare function normalizeSquareBoardInput<TBoard extends AnySquareBoardInput>(board: TBoard): NormalizedSquareBoard<TBoard>;
+
+type BoardTopologyData = AnyHexBoardInput | AnySquareBoardInput;
+type BoardSpaceOf$1<TBoard extends BoardTopologyData> = TBoard extends AnyHexBoardInput ? NormalizedHexTileOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareCellOf<TBoard> : never;
+type BoardEdgeOf<TBoard extends BoardTopologyData> = TBoard extends AnyHexBoardInput ? NormalizedHexEdgeOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareEdgeOf<TBoard> : never;
+type BoardVertexOf<TBoard extends BoardTopologyData> = TBoard extends AnyHexBoardInput ? NormalizedHexVertexOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareVertexOf<TBoard> : never;
+type NormalizedBoardOf<TBoard extends BoardTopologyData> = TBoard extends AnyHexBoardInput ? NormalizedHexBoard<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareBoard<TBoard> : never;
+type BoardLayoutOf<TBoard extends BoardTopologyData> = TBoard extends AnyHexBoardInput ? "hex" : "square";
+interface UseBoardTopologyReturn<TBoard extends BoardTopologyData> {
+    layout: BoardLayoutOf<TBoard>;
+    board: NormalizedBoardOf<TBoard>;
+    getSpace: (spaceId: BoardSpaceIdOf<TBoard>) => BoardSpaceOf$1<TBoard> | undefined;
+    getEdge: (edgeId: BoardEdgeIdOf<TBoard>) => BoardEdgeOf<TBoard> | undefined;
+    getVertex: (vertexId: BoardVertexIdOf<TBoard>) => BoardVertexOf<TBoard> | undefined;
+    getAdjacentSpaces: (spaceId: BoardSpaceIdOf<TBoard>) => Array<BoardSpaceOf$1<TBoard>>;
+    getDistance: (fromSpaceId: BoardSpaceIdOf<TBoard>, toSpaceId: BoardSpaceIdOf<TBoard>) => number;
+    getSpaceEdges: (spaceId: BoardSpaceIdOf<TBoard>) => Array<BoardEdgeOf<TBoard>>;
+    getSpaceVertices: (spaceId: BoardSpaceIdOf<TBoard>) => Array<BoardVertexOf<TBoard>>;
+    getIncidentEdges: (vertexId: BoardVertexIdOf<TBoard>) => Array<BoardEdgeOf<TBoard>>;
+    getIncidentVertices: (edgeId: BoardEdgeIdOf<TBoard>) => Array<BoardVertexOf<TBoard>>;
+}
+declare function useBoardTopology<const TBoard extends BoardTopologyData>(board: TBoard): UseBoardTopologyReturn<TBoard>;
+
+declare function useHexBoard<const TBoard extends AnyHexBoardInput>(board: TBoard): {
+    board: NormalizedHexBoard<TBoard>;
+    getTile: (tileId: BoardSpaceIdOf<TBoard>) => NormalizedHexTileOf<TBoard> | undefined;
+    getTileAt: (q: number, r: number) => NormalizedHexTileOf<TBoard> | undefined;
+    getNeighbors: (tileId: BoardSpaceIdOf<TBoard>) => Array<NormalizedHexTileOf<TBoard>>;
+    getTilesInRange: (centerTileId: BoardSpaceIdOf<TBoard>, range: number) => Array<NormalizedHexTileOf<TBoard>>;
+    layout: TBoard extends AnyHexBoardInput ? "hex" : "square";
+    getSpace: (spaceId: BoardSpaceIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexTileOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareCellOf<TBoard> : never) | undefined;
+    getEdge: (edgeId: BoardEdgeIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexEdgeOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareEdgeOf<TBoard> : never) | undefined;
+    getVertex: (vertexId: BoardVertexIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexVertexOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareVertexOf<TBoard> : never) | undefined;
+    getAdjacentSpaces: (spaceId: BoardSpaceIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexTileOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareCellOf<TBoard> : never)[];
+    getDistance: (fromSpaceId: BoardSpaceIdOf<TBoard>, toSpaceId: BoardSpaceIdOf<TBoard>) => number;
+    getSpaceEdges: (spaceId: BoardSpaceIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexEdgeOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareEdgeOf<TBoard> : never)[];
+    getSpaceVertices: (spaceId: BoardSpaceIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexVertexOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareVertexOf<TBoard> : never)[];
+    getIncidentEdges: (vertexId: BoardVertexIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexEdgeOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareEdgeOf<TBoard> : never)[];
+    getIncidentVertices: (edgeId: BoardEdgeIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexVertexOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareVertexOf<TBoard> : never)[];
+};
+
+type NeighborMode = "orthogonal" | "diagonal" | "all";
+type DistanceMetric = "manhattan" | "chebyshev";
+declare function useSquareBoard<const TBoard extends AnySquareBoardInput>(board: TBoard): {
+    board: NormalizedSquareBoard<TBoard>;
+    getCell: (cellId: BoardSpaceIdOf<TBoard>) => NormalizedSquareCellOf<TBoard> | undefined;
+    getCellAt: (row: number, col: number) => NormalizedSquareCellOf<TBoard> | undefined;
+    getNeighbors: (cellId: BoardSpaceIdOf<TBoard>, mode?: NeighborMode) => NormalizedSquareCellOf<TBoard>[];
+    getDistance: (fromCellId: BoardSpaceIdOf<TBoard>, toCellId: BoardSpaceIdOf<TBoard>, metric?: DistanceMetric) => number;
+    layout: TBoard extends AnyHexBoardInput ? "hex" : "square";
+    getSpace: (spaceId: BoardSpaceIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexTileOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareCellOf<TBoard> : never) | undefined;
+    getEdge: (edgeId: BoardEdgeIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexEdgeOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareEdgeOf<TBoard> : never) | undefined;
+    getVertex: (vertexId: BoardVertexIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexVertexOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareVertexOf<TBoard> : never) | undefined;
+    getAdjacentSpaces: (spaceId: BoardSpaceIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexTileOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareCellOf<TBoard> : never)[];
+    getSpaceEdges: (spaceId: BoardSpaceIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexEdgeOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareEdgeOf<TBoard> : never)[];
+    getSpaceVertices: (spaceId: BoardSpaceIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexVertexOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareVertexOf<TBoard> : never)[];
+    getIncidentEdges: (vertexId: BoardVertexIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexEdgeOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareEdgeOf<TBoard> : never)[];
+    getIncidentVertices: (edgeId: BoardEdgeIdOf<TBoard>) => (TBoard extends AnyHexBoardInput ? NormalizedHexVertexOf<TBoard> : TBoard extends AnySquareBoardInput ? NormalizedSquareVertexOf<TBoard> : never)[];
+};
+
+type CardSize = "sm" | "md" | "lg";
+type HandLayout = "spread" | "stack" | "overlap";
+interface CardPositionProps {
+    
+    x: number;
+    
+    y: number;
+    
+    zIndex: number;
+    
+    transformOrigin: string;
+}
+interface UseHandLayoutOptions {
+    
+    cardCount: number;
+    
+    cardSize?: CardSize;
+    
+    layout?: HandLayout;
+    
+    containerPadding?: number;
+}
+interface UseHandLayoutReturn {
+    
+    containerRef: RefObject<HTMLDivElement | null>;
+    
+    cardsContainerRef: RefObject<HTMLDivElement | null>;
+    
+    containerWidth: number;
+    
+    cardOffset: number;
+    
+    totalWidth: number;
+    
+    useDrawerMode: boolean;
+    
+    cardDimensions: {
+        width: number;
+        height: number;
+    };
+    
+    constants: {
+        hoverLift: number;
+        selectedLift: number;
+    };
+    
+    hoveredIndex: number | null;
+    
+    handleMouseMove: (e: React.MouseEvent<HTMLDivElement>) => void;
+    
+    handleMouseLeave: () => void;
+    
+    getCardPosition: (index: number, isHovered: boolean, isSelected: boolean) => CardPositionProps;
+}
+
+declare function useHandLayout({ cardCount, cardSize, layout, containerPadding, }: UseHandLayoutOptions): UseHandLayoutReturn;
+
+declare function useIsMobile(breakpoint?: number): boolean;
+
+interface PanZoomTransform {
+    
+    zoom: number;
+    
+    pan: {
+        x: number;
+        y: number;
+    };
+}
+interface UsePanZoomOptions {
+    
+    enabled?: boolean;
+    
+    initialZoom?: number;
+    
+    minZoom?: number;
+    
+    maxZoom?: number;
+    
+    initialPan?: {
+        x: number;
+        y: number;
+    };
+    
+    mode?: "viewbox" | "css";
+    
+    wheelSensitivity?: number;
+    
+    onTransformChange?: (transform: PanZoomTransform) => void;
+}
+
+type GestureBindFunction = () => Omit<React.HTMLAttributes<Element>, "ref">;
+interface UsePanZoomReturn {
+    
+    transform: PanZoomTransform;
+    
+    bind: GestureBindFunction;
+    
+    resetTransform: () => void;
+    
+    setZoom: (zoom: number) => void;
+    
+    setPan: (pan: {
+        x: number;
+        y: number;
+    }) => void;
+    
+    style: React.CSSProperties;
+    
+    isDragging: boolean;
+    
+    isPinching: boolean;
+}
+
+declare function usePanZoom(options?: UsePanZoomOptions): UsePanZoomReturn;
+
+declare function calculateViewBox(bounds: {
+    minX: number;
+    minY: number;
+    width: number;
+    height: number;
+}, transform: PanZoomTransform): string;
+
+interface PluginRuntimeAPI extends RuntimeAPI {
+    
+    getSnapshot: () => PluginStateSnapshot | null;
+    
+    subscribeToState: (listener: (state: PluginStateSnapshot) => void) => () => void;
+    
+    _subscribeToSessionState: (listener: (state: PluginSessionState) => void) => () => void;
+    
+    restoreHistory?: (entryId: string) => void;
+}
+
+interface UsePluginRuntimeOptions {
+    
+    timeout?: number;
+}
+interface UsePluginRuntimeResult {
+    
+    runtime: PluginRuntimeAPI;
+    
+    isReady: boolean;
+    
+    error: string | null;
+}
+
+declare function usePluginRuntime(options?: UsePluginRuntimeOptions): UsePluginRuntimeResult;
+
+interface TrackSpace<SpaceIdValue extends string = string, Data = unknown> {
+    id: SpaceIdValue;
+    index: number;
+    name?: string;
+    type?: string;
+    
+    nextSpaces?: readonly SpaceIdValue[];
+    
+    jumpTo?: SpaceIdValue;
+    position: {
+        x: number;
+        y: number;
+    };
+    data?: Data;
+}
+interface TrackPiece<PieceIdValue extends string = string, SpaceIdValue extends string = string, OwnerIdValue extends string = string, Data = unknown> {
+    id: PieceIdValue;
+    spaceId: SpaceIdValue;
+    owner: OwnerIdValue;
+    type?: string;
+    data?: Data;
+}
+interface TrackBoardProps {
+    spaces: TrackSpace[];
+    pieces: TrackPiece[];
+    type?: "linear" | "circular" | "branching";
+    renderSpace: (space: TrackSpace, pieces: TrackPiece[]) => ReactNode;
+    renderConnection?: (from: {
+        x: number;
+        y: number;
+    }, to: {
+        x: number;
+        y: number;
+    }, fromSpace: TrackSpace, toSpace: TrackSpace) => ReactNode;
+    renderJump?: (from: {
+        x: number;
+        y: number;
+    }, to: {
+        x: number;
+        y: number;
+    }, fromSpace: TrackSpace, toSpace: TrackSpace, isUp: boolean) => ReactNode;
+    width?: number | string;
+    height?: number | string;
+    enablePanZoom?: boolean;
+    initialZoom?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    className?: string;
+}
+interface DefaultTrackSpaceProps {
+    space: TrackSpace;
+    size?: number;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    isHighlighted?: boolean;
+    isSelected?: boolean;
+    showJumpIndicator?: boolean;
+    onClick?: () => void;
+    onHover?: (hovering: boolean) => void;
+    className?: string;
+    children?: ReactNode;
+}
+declare function DefaultTrackSpace({ space, size, fill, stroke, strokeWidth, isHighlighted, isSelected, showJumpIndicator, onClick, onHover, className, children, }: DefaultTrackSpaceProps): react_jsx_runtime.JSX.Element;
+interface DefaultTrackPieceProps {
+    piece: TrackPiece;
+    index?: number;
+    total?: number;
+    radius?: number;
+    color?: string;
+    onClick?: () => void;
+    className?: string;
+}
+declare function DefaultTrackPiece({ piece, index, total, radius, color, onClick, className, }: DefaultTrackPieceProps): react_jsx_runtime.JSX.Element;
+interface DefaultTrackConnectionProps {
+    from: {
+        x: number;
+        y: number;
+    };
+    to: {
+        x: number;
+        y: number;
+    };
+    stroke?: string;
+    strokeWidth?: number;
+    className?: string;
+}
+declare function DefaultTrackConnection({ from, to, stroke, strokeWidth, className, }: DefaultTrackConnectionProps): react_jsx_runtime.JSX.Element;
+interface DefaultTrackJumpProps {
+    from: {
+        x: number;
+        y: number;
+    };
+    to: {
+        x: number;
+        y: number;
+    };
+    
+    isUp: boolean;
+    spaceSize?: number;
+    upColor?: string;
+    downColor?: string;
+    strokeWidth?: number;
+    className?: string;
+}
+declare function DefaultTrackJump({ from, to, isUp, spaceSize, upColor, downColor, strokeWidth, className, }: DefaultTrackJumpProps): react_jsx_runtime.JSX.Element;
+declare function TrackBoard({ spaces, pieces, type, renderSpace, renderConnection, renderJump, width, height, enablePanZoom, initialZoom, minZoom, maxZoom, className, }: TrackBoardProps): react_jsx_runtime.JSX.Element;
+
+interface GenericBoardSpaceLike<SpaceIdValue extends string = string, Fields = Record<string, unknown>> {
+    id: SpaceIdValue;
+    name?: string | null;
+    typeId?: string | null;
+    fields: Fields;
+}
+interface GenericBoardRelationLike<SpaceIdValue extends string = string> {
+    fromSpaceId: SpaceIdValue;
+    toSpaceId: SpaceIdValue;
+    directed: boolean;
+}
+interface GenericBoardLike<BoardIdValue extends string = string, SpaceIdValue extends string = string, SpaceFields = Record<string, unknown>> {
+    id: BoardIdValue;
+    spaces: Readonly<Record<SpaceIdValue, GenericBoardSpaceLike<SpaceIdValue, SpaceFields>>>;
+    relations?: ReadonlyArray<GenericBoardRelationLike<SpaceIdValue>>;
+}
+interface TrackBoardPieceLike<PieceIdValue extends string = string, SpaceIdValue extends string = string, OwnerIdValue extends string = string, Fields = unknown> {
+    id: PieceIdValue;
+    spaceId: SpaceIdValue;
+    owner: OwnerIdValue;
+    typeId?: string | null;
+    fields?: Fields;
+}
+type BoardSpaceOf<TBoard extends GenericBoardLike> = TBoard["spaces"][keyof TBoard["spaces"]];
+type SpaceIdOf<TBoard extends GenericBoardLike> = BoardSpaceOf<TBoard> extends {
+    id: infer Id extends string;
+} ? Id : never;
+type SpaceFieldsOf<TBoard extends GenericBoardLike> = BoardSpaceOf<TBoard> extends {
+    fields: infer Fields;
+} ? Fields : never;
+type PieceIdOf<TPiece extends TrackBoardPieceLike> = TPiece extends {
+    id: infer Id extends string;
+} ? Id : never;
+type PieceOwnerOf<TPiece extends TrackBoardPieceLike> = TPiece extends {
+    owner: infer Owner extends string;
+} ? Owner : never;
+type PieceFieldsOf<TPiece extends TrackBoardPieceLike> = TPiece extends {
+    fields?: infer Fields;
+} ? Fields : never;
+type TrackLayout = {
+    type: "linear";
+    axis?: "x" | "y";
+    spacing?: number;
+    origin?: {
+        x: number;
+        y: number;
+    };
+} | {
+    type: "circular";
+    center: {
+        x: number;
+        y: number;
+    };
+    radius: number;
+    startAngleDeg?: number;
+    clockwise?: boolean;
+};
+type PositionOptions<TBoard extends GenericBoardLike> = {
+    getPosition: (space: BoardSpaceOf<TBoard>, index: number, spaces: ReadonlyArray<BoardSpaceOf<TBoard>>) => {
+        x: number;
+        y: number;
+    };
+    layout?: never;
+} | {
+    getPosition?: never;
+    layout: TrackLayout;
+};
+type ToTrackBoardDataOptions<TBoard extends GenericBoardLike, TPiece extends TrackBoardPieceLike<string, SpaceIdOf<TBoard>, string, unknown>> = PositionOptions<TBoard> & {
+    pieces?: readonly TPiece[];
+    getNextSpaces?: (space: BoardSpaceOf<TBoard>, board: TBoard) => ReadonlyArray<SpaceIdOf<TBoard>> | undefined;
+    getJumpTo?: (space: BoardSpaceOf<TBoard>, board: TBoard) => SpaceIdOf<TBoard> | undefined;
+};
+declare function toTrackBoardData<TBoard extends GenericBoardLike, TPiece extends TrackBoardPieceLike<string, SpaceIdOf<TBoard>, string, unknown>>(board: TBoard, options: ToTrackBoardDataOptions<TBoard, TPiece>): {
+    spaces: Array<TrackSpace<SpaceIdOf<TBoard>, SpaceFieldsOf<TBoard>>>;
+    pieces: Array<TrackPiece<PieceIdOf<TPiece>, SpaceIdOf<TBoard>, PieceOwnerOf<TPiece>, PieceFieldsOf<TPiece>>>;
+};
+
+type PlayerId = string;
+
+interface PluginStateProviderProps {
+    children: React__default.ReactNode;
+    
+    loadingComponent?: React__default.ReactNode;
+}
+
+declare function PluginStateProvider({ children, loadingComponent, }: PluginStateProviderProps): react_jsx_runtime.JSX.Element;
+
+declare function usePluginState<T>(selector: (state: PluginStateSnapshot) => T): T;
+
+declare function usePluginActions(): {
+    
+    markNotificationRead: (notificationId: string) => void;
+    
+    switchPlayer: (playerId: string) => void;
+    
+    submitInteraction: (playerId: PlayerId, interactionId: string, params: unknown) => Promise<void>;
+};
+
+declare const RuntimeContext: React__default.Context<RuntimeAPI | null>;
+
+declare function useRuntimeContext(): RuntimeAPI;
+
+declare function RuntimeProvider({ runtime, children, }: {
+    runtime: RuntimeAPI;
+    children: React__default.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+interface ThemeMeta {
+    
+    readonly id: string;
+    
+    readonly name: string;
+    
+    readonly mode: "light" | "dark";
+}
+
+interface ColorRamp {
+    readonly 50: string;
+    readonly 100: string;
+    readonly 200: string;
+    readonly 400: string;
+    readonly 600: string;
+    readonly 800: string;
+    readonly 950: string;
+}
+
+interface PlayerColor {
+    readonly solid: string;
+    readonly soft: string;
+    readonly on: string;
+}
+
+interface FoundationColor {
+    readonly neutral: ColorRamp;
+    readonly brand: ColorRamp;
+    readonly accent: ColorRamp;
+    readonly success: ColorRamp;
+    readonly warning: ColorRamp;
+    readonly danger: ColorRamp;
+    readonly info: ColorRamp;
+}
+
+interface SemanticColor {
+    readonly surface: {
+        
+        readonly app: string;
+        
+        readonly board: string;
+        
+        readonly hud: string;
+        
+        readonly card: string;
+        
+        readonly sheet: string;
+        
+        readonly overlay: string;
+        
+        readonly inset: string;
+    };
+    readonly text: {
+        
+        readonly primary: string;
+        
+        readonly muted: string;
+        
+        readonly onIntent: string;
+        
+        readonly accent: string;
+        
+        readonly disabled: string;
+    };
+    readonly border: {
+        
+        readonly subtle: string;
+        
+        readonly default: string;
+        
+        readonly strong: string;
+        
+        readonly focus: string;
+    };
+    
+    readonly intent: {
+        readonly primary: IntentColor;
+        readonly secondary: IntentColor;
+        readonly success: IntentColor;
+        readonly danger: IntentColor;
+        readonly warning: IntentColor;
+        readonly info: IntentColor;
+    };
+}
+
+interface IntentColor {
+    
+    readonly solid: string;
+    
+    readonly on: string;
+    
+    readonly soft: string;
+    
+    readonly onSoft: string;
+    
+    readonly border: string;
+}
+
+interface Radius {
+    readonly none: string;
+    readonly sm: string;
+    readonly md: string;
+    readonly lg: string;
+    
+    readonly hud: string;
+    
+    readonly pill: string;
+}
+
+interface Space {
+    readonly 0: string;
+    readonly 0.5: string;
+    readonly 1: string;
+    readonly 1.5: string;
+    readonly 2: string;
+    readonly 3: string;
+    readonly 4: string;
+    readonly 6: string;
+    readonly 8: string;
+    readonly 12: string;
+}
+
+interface Typography {
+    readonly fontFamily: {
+        
+        readonly display: string;
+        
+        readonly body: string;
+        
+        readonly tabular: string;
+        
+        readonly mono: string;
+    };
+    readonly fontSize: {
+        readonly xs: string;
+        readonly sm: string;
+        readonly md: string;
+        readonly lg: string;
+        readonly xl: string;
+        readonly "2xl": string;
+        readonly "3xl": string;
+    };
+    readonly fontWeight: {
+        readonly regular: string;
+        readonly medium: string;
+        readonly bold: string;
+    };
+    readonly lineHeight: {
+        readonly tight: string;
+        readonly normal: string;
+        readonly relaxed: string;
+    };
+    readonly letterSpacing: {
+        readonly tight: string;
+        readonly normal: string;
+        readonly wide: string;
+        
+        readonly caps: string;
+    };
+}
+
+interface Elevation {
+    
+    readonly rest: string;
+    
+    readonly hover: string;
+    
+    readonly lifted: string;
+    
+    readonly overlay: string;
+    
+    readonly inset: string;
+}
+
+interface Motion {
+    readonly duration: {
+        
+        readonly fast: string;
+        
+        readonly normal: string;
+        
+        readonly slow: string;
+        
+        readonly ambient: string;
+    };
+    readonly easing: {
+        
+        readonly out: string;
+        
+        readonly in: string;
+        
+        readonly inOut: string;
+        
+        readonly spring: string;
+    };
+    
+    readonly reducedMotion: "true" | "false";
+}
+
+interface ComponentTokens {
+    readonly board: {
+        
+        readonly frameBorder: string;
+        
+        readonly frameBackground: string;
+        
+        readonly hoverRing: string;
+        
+        readonly eligibleHint: string;
+    };
+    readonly card: {
+        
+        readonly border: string;
+        
+        readonly backBorder: string;
+        
+        readonly backBackground: string;
+        
+        readonly selectedRing: string;
+    };
+    readonly playerCard: {
+        
+        readonly activeBackground: string;
+        
+        readonly activeBorder: string;
+        
+        readonly activeGlow: string;
+        
+        readonly youBadgeBackground: string;
+        
+        readonly youBadgeForeground: string;
+    };
+    readonly toast: {
+        readonly successBackground: string;
+        readonly errorBackground: string;
+        readonly infoBackground: string;
+        readonly foreground: string;
+    };
+}
+
+interface Theme {
+    readonly meta: ThemeMeta;
+    readonly color: FoundationColor;
+    readonly semantic: SemanticColor;
+    readonly radius: Radius;
+    readonly space: Space;
+    readonly typography: Typography;
+    readonly elevation: Elevation;
+    readonly motion: Motion;
+    readonly player: readonly [
+        PlayerColor,
+        PlayerColor,
+        PlayerColor,
+        PlayerColor,
+        PlayerColor,
+        PlayerColor
+    ];
+    readonly component: ComponentTokens;
+}
+
+type ThemeOverride = DeepPartial<Theme>;
+type DeepPartial<T> = T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends object ? {
+    readonly [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+
+declare function mergeTheme(base: Theme, override?: ThemeOverride): Theme;
+
+declare const tabletopTheme: Theme;
+
+declare const arcadeTheme: Theme;
+
+declare const studioTheme: Theme;
+
+type ThemePresetId = "tabletop" | "arcade" | "studio";
+
+declare function resolveTheme(input: ThemePresetId | Theme | undefined): Theme;
+
+declare function getThemePreset(id: ThemePresetId): Theme | undefined;
+
+interface ThemeContextValue {
+    
+    readonly theme: Theme;
+    
+    readonly cssVars: CSSProperties;
+}
+interface ThemeProviderProps {
+    
+    theme?: ThemePresetId | Theme;
+    
+    override?: ThemeOverride;
+    
+    reducedMotion?: "auto" | "force" | "ignore";
+    
+    as?: "block" | "none";
+    
+    style?: CSSProperties;
+    
+    className?: string;
+    children: ReactNode;
+}
+
+declare function ThemeProvider({ theme: themeInput, override, reducedMotion, as, style, className, children, }: ThemeProviderProps): react_jsx_runtime.JSX.Element;
+
+declare function useTheme(): Theme;
+
+declare function useThemeCssVars(): CSSProperties;
+
+declare function themeToCssVars(theme: Theme): CSSProperties;
+
+declare function cssVar(...path: Array<string | number>): string;
+
+declare function cssVarOr(fallback: string, ...path: Array<string | number>): string;
+
+type ButtonVariant$1 = "primary" | "secondary" | "danger" | "submitted" | "success" | "warning" | "info" | "ghost";
+type ButtonSize$1 = "sm" | "md" | "lg";
+
+declare function buttonStyle(theme: Theme, options?: {
+    variant?: ButtonVariant$1;
+    size?: ButtonSize$1;
+    disabled?: boolean;
+    pressed?: boolean;
+}): CSSProperties;
+
+declare function chipStyle(theme: Theme, options?: {
+    variant?: Exclude<ButtonVariant$1, "ghost">;
+    size?: "sm" | "md";
+}): CSSProperties;
+
+declare function surfaceStyle(theme: Theme, options?: {
+    tone?: keyof Theme["semantic"]["surface"];
+    interactive?: boolean;
+    
+    radius?: keyof Theme["radius"];
+}): CSSProperties;
+
+declare function intentForVariant(theme: Theme, variant: ButtonVariant$1): IntentColor;
+
+declare function playerColor(theme: Theme, slot: number): PlayerColor;
+
+declare function motionDuration(theme: Theme, key: keyof Theme["motion"]["duration"]): string;
+
+interface BoardTheme {
+    
+    readonly frameBorder: string;
+    
+    readonly frameBackground: string;
+    
+    readonly hoverRing: string;
+    
+    readonly eligibleHint: string;
+    
+    readonly tileBorder: string;
+    
+    readonly tileBorderSubtle: string;
+    
+    readonly tileText: string;
+    
+    readonly ringWidth: number;
+}
+
+declare function useBoardTheme(): BoardTheme;
+
+declare function deriveBoardTheme(theme: Theme): BoardTheme;
+
+interface InteractionFieldRenderProps<Params extends InteractionParamsShape = InteractionParamsShape, Key extends keyof Params & string = keyof Params & string> {
+    descriptor: InteractionDescriptor;
+    input: InteractionInputDescriptor & {
+        key: Key;
+    };
+    handle: InteractionHandle<Params>;
+    value: Params[Key] | undefined;
+    setValue: (value: Params[Key]) => void;
+    clearValue: () => void;
+    errors: readonly string[];
+    missing: boolean;
+    disabled: boolean;
+}
+type InteractionFieldRenderMap<Params extends InteractionParamsShape = InteractionParamsShape> = Partial<{
+    [K in keyof Params & string]: (props: InteractionFieldRenderProps<Params, K>) => ReactNode;
+}>;
+interface InteractionFieldProps<Params extends InteractionParamsShape = InteractionParamsShape, Key extends keyof Params & string = keyof Params & string> {
+    descriptor: InteractionDescriptor;
+    inputKey: Key;
+    handle: InteractionHandle<Params>;
+    errors?: readonly string[];
+    missing?: boolean;
+    disabled?: boolean;
+    render?: InteractionFieldRenderMap<Params>[Key];
+}
+interface InteractionFormProps<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never> {
+    descriptor: InteractionDescriptor;
+    handle: InteractionHandle<Params, DefaultedKeys>;
+    fields?: ReadonlyArray<keyof Params & string>;
+    hiddenFields?: ReadonlyArray<keyof Params & string>;
+    renderFields?: InteractionFieldRenderMap<Params>;
+    title?: ReactNode;
+    description?: ReactNode;
+    submitLabel?: ReactNode;
+    cancelLabel?: ReactNode;
+    onCancel?: () => void;
+    onSubmitSuccess?: () => void;
+    disabled?: boolean;
+    accordion?: boolean;
+    defaultOpen?: boolean;
+    style?: CSSProperties;
+}
+declare function InteractionForm<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never>({ descriptor, handle, fields, hiddenFields, renderFields, title, description, submitLabel, cancelLabel, onCancel, onSubmitSuccess, disabled, accordion, defaultOpen, style, }: InteractionFormProps<Params, DefaultedKeys>): react_jsx_runtime.JSX.Element;
+declare function InteractionField<Params extends InteractionParamsShape = InteractionParamsShape, Key extends keyof Params & string = keyof Params & string>({ descriptor, inputKey, handle, errors, missing, disabled, render, }: InteractionFieldProps<Params, Key>): react_jsx_runtime.JSX.Element | null;
+declare function hasDefaultInteractionFormFields(descriptor: Pick<InteractionDescriptor, "inputs">): boolean;
+declare function defaultFormInputs(descriptor: Pick<InteractionDescriptor, "inputs">): InteractionInputDescriptor[];
+
+interface CardProps<CardData extends ViewCard = ViewCard> extends Omit<HTMLMotionProps<"button">, "children"> {
+    card: CardData;
+    selected?: boolean;
+    disabled?: boolean;
+    size?: "sm" | "md" | "lg";
+    faceDown?: boolean;
+    renderContent?: (card: CardData) => React.ReactNode;
+    onCardClick?: (cardId: string) => void;
+    "aria-label"?: string;
+}
+
+declare function Card<CardData extends ViewCard = ViewCard>({ card, selected, disabled, size, faceDown, renderContent, onCardClick, className, "aria-label": ariaLabel, ...motionProps }: CardProps<CardData>): react_jsx_runtime.JSX.Element;
+
+interface HandCardRenderProps<CardData extends ViewCard = ViewCard> {
+    card: CardData;
+    index: number;
+    isHovered: boolean;
+    isSelected: boolean;
+    x: number;
+    y: number;
+    zIndex: number;
+    cardDimensions: {
+        width: number;
+        height: number;
+    };
+}
+interface HandDrawerRenderProps<CardData extends ViewCard = ViewCard> {
+    cards: readonly CardData[];
+    selectedIds: readonly string[];
+    cardCount: number;
+    selectedCount: number;
+    disabled: boolean;
+    cardDimensions: {
+        width: number;
+        height: number;
+    };
+}
+interface HandEmptyRenderProps {
+    layout: HandLayout;
+}
+interface HandContainerRenderProps {
+    totalWidth: number;
+    totalHeight: number;
+    cardDimensions: {
+        width: number;
+        height: number;
+    };
+    children: ReactNode;
+    onMouseMove: (e: React.MouseEvent<HTMLDivElement>) => void;
+    onMouseLeave: () => void;
+}
+interface HandProps<CardData extends ViewCard = ViewCard> {
+    cards: readonly CardData[];
+    selectedIds?: readonly string[];
+    disabled?: boolean;
+    cardSize?: CardSize;
+    layout?: HandLayout;
+    "aria-label"?: string;
+    
+    onCardClick?: (cardId: string) => void;
+    
+    renderCardContent?: (card: CardData) => ReactNode;
+    
+    renderCard?: (props: HandCardRenderProps<CardData>) => ReactNode;
+    
+    renderDrawer?: (props: HandDrawerRenderProps<CardData>) => ReactNode;
+    
+    renderEmpty?: (props: HandEmptyRenderProps) => ReactNode;
+    renderContainer?: (props: HandContainerRenderProps) => ReactNode;
+    className?: string;
+}
+
+declare function Hand<CardData extends ViewCard = ViewCard>({ cards, selectedIds, disabled, cardSize, layout, "aria-label": ariaLabel, onCardClick, renderCardContent, renderCard, renderDrawer, renderEmpty, renderContainer, className, }: HandProps<CardData>): react_jsx_runtime.JSX.Element;
+
+type HandDockMode = "inline" | "drawer" | "hidden";
+type HandDockPlacement = "bottom-left" | "bottom-center" | "bottom-right";
+interface HandDockToggleContext {
+    label: string;
+    count: number;
+    open: boolean;
+}
+interface HandDockPresentation {
+    
+    mode?: HandDockMode;
+    
+    defaultOpen?: boolean;
+    
+    placement?: HandDockPlacement;
+    
+    toggleLabel?: ReactNode | ((context: HandDockToggleContext) => ReactNode);
+    
+    maxWidth?: CSSProperties["maxWidth"];
+    
+    maxHeight?: CSSProperties["maxHeight"];
+    
+    style?: CSSProperties;
+}
+interface HandDockProps {
+    label: string;
+    count: number;
+    presentation?: HandDockPresentation;
+    children: ReactNode;
+}
+declare function HandDock({ label, count, presentation, children, }: HandDockProps): react_jsx_runtime.JSX.Element | null;
+
+interface PlayAreaProps<CardData extends ViewCard = ViewCard> {
+    cards: readonly CardData[];
+    filter?: (card: CardData) => boolean;
+    cardSize?: CardProps["size"];
+    renderCard?: CardProps<CardData>["renderContent"];
+    layout?: "grid" | "row";
+    interactive?: boolean;
+    onCardClick?: (cardId: string) => void;
+    "aria-label"?: string;
+    className?: string;
+}
+
+declare function PlayArea<CardData extends ViewCard = ViewCard>({ cards, filter, cardSize, renderCard, layout, interactive, onCardClick, "aria-label": ariaLabel, className, }: PlayAreaProps<CardData>): react_jsx_runtime.JSX.Element;
+
+interface GameSkeletonProps {
+    variant?: "default" | "cards" | "players" | "minimal";
+    message?: string;
+    className?: string;
+}
+declare function GameSkeleton({ variant, message, className, }: GameSkeletonProps): react_jsx_runtime.JSX.Element;
+
+type ToastType = "success" | "error" | "info" | "warning";
+interface Toast {
+    id: string;
+    type: ToastType;
+    message: string;
+    duration?: number;
+}
+interface ToastContextValue {
+    toasts: Toast[];
+    show: (message: string, type?: ToastType, duration?: number) => void;
+    dismiss: (id: string) => void;
+    success: (message: string, duration?: number) => void;
+    error: (message: string, duration?: number) => void;
+    info: (message: string, duration?: number) => void;
+    warning: (message: string, duration?: number) => void;
+}
+interface ToastProviderProps {
+    children: ReactNode;
+}
+declare function ToastProvider({ children }: ToastProviderProps): react_jsx_runtime.JSX.Element;
+declare function useToast(): ToastContextValue;
+
+interface ErrorBoundaryProps {
+    children: ReactNode;
+    fallback?: (error: Error, reset: () => void) => ReactNode;
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+}
+interface ErrorBoundaryState {
+    hasError: boolean;
+    error: Error | null;
+}
+declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    handleReset: () => void;
+    render(): ReactNode;
+}
+
+interface PluginRuntimeProps {
+    
+    children: React__default.ReactNode;
+    
+    timeout?: number;
+    
+    loadingComponent?: React__default.ReactNode;
+    
+    errorComponent?: (error: string) => React__default.ReactNode;
+}
+
+declare function PluginRuntime({ children, timeout, loadingComponent, errorComponent, }: PluginRuntimeProps): react_jsx_runtime.JSX.Element;
+
+declare const NODES: readonly ["a", "button", "div", "form", "h2", "h3", "img", "input", "label", "li", "nav", "ol", "p", "select", "span", "svg", "ul"];
+type Primitives = {
+    [E in (typeof NODES)[number]]: PrimitiveForwardRefComponent<E>;
+};
+type PrimitivePropsWithRef<E extends React$1.ElementType> = React$1.ComponentPropsWithRef<E> & {
+    asChild?: boolean;
+};
+interface PrimitiveForwardRefComponent<E extends React$1.ElementType> extends React$1.ForwardRefExoticComponent<PrimitivePropsWithRef<E>> {
+}
+declare const Primitive: Primitives;
+
+type PrimitiveDivProps$3 = React$1.ComponentPropsWithoutRef<typeof Primitive.div>;
+interface DismissableLayerProps$1 extends PrimitiveDivProps$3 {
+    
+    disableOutsidePointerEvents?: boolean;
+    
+    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+    
+    onPointerDownOutside?: (event: PointerDownOutsideEvent) => void;
+    
+    onFocusOutside?: (event: FocusOutsideEvent) => void;
+    
+    onInteractOutside?: (event: PointerDownOutsideEvent | FocusOutsideEvent) => void;
+    
+    onDismiss?: () => void;
+}
+declare const DismissableLayer: React$1.ForwardRefExoticComponent<DismissableLayerProps$1 & React$1.RefAttributes<HTMLDivElement>>;
+type PointerDownOutsideEvent = CustomEvent<{
+    originalEvent: PointerEvent;
+}>;
+type FocusOutsideEvent = CustomEvent<{
+    originalEvent: FocusEvent;
+}>;
+
+type PrimitiveDivProps$2 = React$1.ComponentPropsWithoutRef<typeof Primitive.div>;
+interface FocusScopeProps$1 extends PrimitiveDivProps$2 {
+    
+    loop?: boolean;
+    
+    trapped?: boolean;
+    
+    onMountAutoFocus?: (event: Event) => void;
+    
+    onUnmountAutoFocus?: (event: Event) => void;
+}
+declare const FocusScope: React$1.ForwardRefExoticComponent<FocusScopeProps$1 & React$1.RefAttributes<HTMLDivElement>>;
+
+type PrimitiveDivProps$1 = React$1.ComponentPropsWithoutRef<typeof Primitive.div>;
+interface PortalProps$2 extends PrimitiveDivProps$1 {
+    
+    container?: Element | DocumentFragment | null;
+}
+declare const Portal$2: React$1.ForwardRefExoticComponent<PortalProps$2 & React$1.RefAttributes<HTMLDivElement>>;
+
+interface DialogProps$1 {
+    children?: React$1.ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?(open: boolean): void;
+    modal?: boolean;
+}
+type PrimitiveButtonProps = React$1.ComponentPropsWithoutRef<typeof Primitive.button>;
+interface DialogTriggerProps extends PrimitiveButtonProps {
+}
+type PortalProps$1 = React$1.ComponentPropsWithoutRef<typeof Portal$2>;
+interface DialogPortalProps {
+    children?: React$1.ReactNode;
+    
+    container?: PortalProps$1['container'];
+    
+    forceMount?: true;
+}
+interface DialogOverlayProps extends DialogOverlayImplProps {
+    
+    forceMount?: true;
+}
+type PrimitiveDivProps = React$1.ComponentPropsWithoutRef<typeof Primitive.div>;
+interface DialogOverlayImplProps extends PrimitiveDivProps {
+}
+interface DialogContentProps extends DialogContentTypeProps {
+    
+    forceMount?: true;
+}
+interface DialogContentTypeProps extends Omit<DialogContentImplProps, 'trapFocus' | 'disableOutsidePointerEvents'> {
+}
+type DismissableLayerProps = React$1.ComponentPropsWithoutRef<typeof DismissableLayer>;
+type FocusScopeProps = React$1.ComponentPropsWithoutRef<typeof FocusScope>;
+interface DialogContentImplProps extends Omit<DismissableLayerProps, 'onDismiss'> {
+    
+    trapFocus?: FocusScopeProps['trapped'];
+    
+    onOpenAutoFocus?: FocusScopeProps['onMountAutoFocus'];
+    
+    onCloseAutoFocus?: FocusScopeProps['onUnmountAutoFocus'];
+}
+type PrimitiveHeading2Props = React$1.ComponentPropsWithoutRef<typeof Primitive.h2>;
+interface DialogTitleProps extends PrimitiveHeading2Props {
+}
+type PrimitiveParagraphProps = React$1.ComponentPropsWithoutRef<typeof Primitive.p>;
+interface DialogDescriptionProps extends PrimitiveParagraphProps {
+}
+interface DialogCloseProps extends PrimitiveButtonProps {
+}
+declare const Root$1: React$1.FC<DialogProps$1>;
+declare const Trigger: React$1.ForwardRefExoticComponent<DialogTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const Portal$1: React$1.FC<DialogPortalProps>;
+declare const Overlay: React$1.ForwardRefExoticComponent<DialogOverlayProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const Content: React$1.ForwardRefExoticComponent<DialogContentProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const Title: React$1.ForwardRefExoticComponent<DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>>;
+declare const Description: React$1.ForwardRefExoticComponent<DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>>;
+declare const Close: React$1.ForwardRefExoticComponent<DialogCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+interface WithFadeFromProps {
+    
+    snapPoints: (number | string)[];
+    
+    fadeFromIndex: number;
+}
+interface WithoutFadeFromProps {
+    
+    snapPoints?: (number | string)[];
+    fadeFromIndex?: never;
+}
+type DialogProps = {
+    activeSnapPoint?: number | string | null;
+    setActiveSnapPoint?: (snapPoint: number | string | null) => void;
+    children?: React__default.ReactNode;
+    open?: boolean;
+    
+    closeThreshold?: number;
+    
+    noBodyStyles?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    shouldScaleBackground?: boolean;
+    
+    setBackgroundColorOnScale?: boolean;
+    
+    scrollLockTimeout?: number;
+    
+    fixed?: boolean;
+    
+    handleOnly?: boolean;
+    
+    dismissible?: boolean;
+    onDrag?: (event: React__default.PointerEvent<HTMLDivElement>, percentageDragged: number) => void;
+    onRelease?: (event: React__default.PointerEvent<HTMLDivElement>, open: boolean) => void;
+    
+    modal?: boolean;
+    nested?: boolean;
+    onClose?: () => void;
+    
+    direction?: 'top' | 'bottom' | 'left' | 'right';
+    
+    defaultOpen?: boolean;
+    
+    disablePreventScroll?: boolean;
+    
+    repositionInputs?: boolean;
+    
+    snapToSequentialPoint?: boolean;
+    container?: HTMLElement | null;
+    
+    onAnimationEnd?: (open: boolean) => void;
+    preventScrollRestoration?: boolean;
+    autoFocus?: boolean;
+} & (WithFadeFromProps | WithoutFadeFromProps);
+declare function Root({ open: openProp, onOpenChange, children, onDrag: onDragProp, onRelease: onReleaseProp, snapPoints, shouldScaleBackground, setBackgroundColorOnScale, closeThreshold, scrollLockTimeout, dismissible, handleOnly, fadeFromIndex, activeSnapPoint: activeSnapPointProp, setActiveSnapPoint: setActiveSnapPointProp, fixed, modal, onClose, nested, noBodyStyles, direction, defaultOpen, disablePreventScroll, snapToSequentialPoint, preventScrollRestoration, repositionInputs, onAnimationEnd, container, autoFocus, }: DialogProps): React__default.JSX.Element;
+declare function NestedRoot({ onDrag, onOpenChange, open: nestedIsOpen, ...rest }: DialogProps): React__default.JSX.Element;
+type PortalProps = React__default.ComponentPropsWithoutRef<typeof Portal$1>;
+declare function Portal(props: PortalProps): React__default.JSX.Element;
+declare const Drawer$1: {
+    Root: typeof Root;
+    NestedRoot: typeof NestedRoot;
+    Content: React__default.ForwardRefExoticComponent<Omit<DialogContentProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+    Overlay: React__default.ForwardRefExoticComponent<Omit<DialogOverlayProps & React__default.RefAttributes<HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+    Trigger: React__default.ForwardRefExoticComponent<DialogTriggerProps & React__default.RefAttributes<HTMLButtonElement>>;
+    Portal: typeof Portal;
+    Handle: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        preventCycle?: boolean | undefined;
+    } & React__default.RefAttributes<HTMLDivElement>>;
+    Close: React__default.ForwardRefExoticComponent<DialogCloseProps & React__default.RefAttributes<HTMLButtonElement>>;
+    Title: React__default.ForwardRefExoticComponent<DialogTitleProps & React__default.RefAttributes<HTMLHeadingElement>>;
+    Description: React__default.ForwardRefExoticComponent<DialogDescriptionProps & React__default.RefAttributes<HTMLParagraphElement>>;
+};
+
+declare function Drawer({ ...props }: React$1.ComponentProps<typeof Drawer$1.Root>): react_jsx_runtime.JSX.Element;
+declare function DrawerTrigger({ ...props }: React$1.ComponentProps<typeof Drawer$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function DrawerPortal({ ...props }: React$1.ComponentProps<typeof Drawer$1.Portal>): react_jsx_runtime.JSX.Element;
+declare function DrawerClose({ ...props }: React$1.ComponentProps<typeof Drawer$1.Close>): react_jsx_runtime.JSX.Element;
+declare function DrawerOverlay({ className, style, ...props }: React$1.ComponentProps<typeof Drawer$1.Overlay>): react_jsx_runtime.JSX.Element;
+interface DrawerContentProps extends React$1.ComponentPropsWithoutRef<typeof Drawer$1.Content> {
+    showHandle?: boolean;
+    children?: React$1.ReactNode;
+}
+declare function DrawerContent({ className, children, showHandle, ...props }: DrawerContentProps): react_jsx_runtime.JSX.Element;
+declare function DrawerHeader({ className, ...props }: React$1.ComponentPropsWithoutRef<"div">): react_jsx_runtime.JSX.Element;
+declare function DrawerFooter({ className, ...props }: React$1.ComponentPropsWithoutRef<"div">): react_jsx_runtime.JSX.Element;
+declare function DrawerTitle({ className, ...props }: React$1.ComponentProps<typeof Drawer$1.Title>): react_jsx_runtime.JSX.Element;
+declare function DrawerDescription({ className, ...props }: React$1.ComponentProps<typeof Drawer$1.Description>): react_jsx_runtime.JSX.Element;
+
+declare function Dialog(props: React$1.ComponentProps<typeof Root$1>): react_jsx_runtime.JSX.Element;
+declare function DialogTrigger(props: React$1.ComponentProps<typeof Trigger>): react_jsx_runtime.JSX.Element;
+declare function DialogPortal(props: React$1.ComponentProps<typeof Portal$1>): react_jsx_runtime.JSX.Element;
+declare function DialogClose(props: React$1.ComponentProps<typeof Close>): react_jsx_runtime.JSX.Element;
+declare function DialogOverlay({ className, ...props }: React$1.ComponentProps<typeof Overlay>): react_jsx_runtime.JSX.Element;
+declare function DialogContent({ className, children, showCloseButton, overlayClassName, ...props }: React$1.ComponentProps<typeof Content> & {
+    showCloseButton?: boolean;
+    overlayClassName?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function DialogHeader({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function DialogFooter({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function DialogTitle({ className, ...props }: React$1.ComponentProps<typeof Title>): react_jsx_runtime.JSX.Element;
+declare function DialogDescription({ className, ...props }: React$1.ComponentProps<typeof Description>): react_jsx_runtime.JSX.Element;
+
+interface ResourceDisplayConfig {
+    type: ResourceId;
+    label: string;
+    icon: ReactNode | ComponentType<{
+        className?: string;
+        strokeWidth?: number;
+        "aria-hidden"?: string;
+    }>;
+    iconColor?: string;
+    bgColor?: string;
+    textColor?: string;
+}
+interface ResourceCounterProps {
+    resources: ResourceDisplayConfig[];
+    counts: Record<ResourceId, number>;
+    layout?: "row" | "grid" | "compact";
+    
+    columns?: number;
+    showZero?: boolean;
+    size?: "sm" | "md" | "lg";
+    onResourceClick?: (resourceType: ResourceId) => void;
+    className?: string;
+}
+declare function ResourceCounter({ resources, counts, layout, columns, showZero, size, onResourceClick, className, }: ResourceCounterProps): react_jsx_runtime.JSX.Element;
+
+interface ResourceDefinition {
+    type: string;
+    label: string;
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    color?: string;
+}
+interface CostDisplayProps {
+    
+    cost: Record<string, number>;
+    
+    currentResources?: Record<string, number>;
+    resourceDefs: ResourceDefinition[];
+    size?: "sm" | "md";
+    layout?: "inline" | "stacked";
+    className?: string;
+}
+declare function CostDisplay({ cost, currentResources, resourceDefs, size, layout, className, }: CostDisplayProps): react_jsx_runtime.JSX.Element | null;
+
+interface ActionButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onClick"> {
+    handle: InteractionHandle;
+    children?: ReactNode;
+}
+declare function ActionButton({ handle, children, disabled, title, ...rest }: ActionButtonProps): react_jsx_runtime.JSX.Element;
+
+interface PrimaryButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    
+    variant?: ButtonVariant$1;
+    
+    size?: ButtonSize$1;
+}
+declare function PrimaryButton({ children, disabled, style, variant, size, ...rest }: PrimaryButtonProps): react_jsx_runtime.JSX.Element;
+
+type ButtonVariant = "default" | "destructive" | "outline" | "secondary" | "ghost" | "link";
+type ButtonSize = "default" | "sm" | "lg" | "icon";
+interface ButtonProps extends React$1.ComponentProps<"button"> {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    asChild?: boolean;
+}
+declare function Button({ className, variant, size, asChild, ...props }: ButtonProps): react_jsx_runtime.JSX.Element;
+
+type ShadcnButtonProps = ComponentProps<typeof Button>;
+interface ThemedButtonProps extends Omit<ShadcnButtonProps, "variant" | "size"> {
+    variant?: ButtonVariant$1;
+    size?: ButtonSize$1;
+    pressed?: boolean;
+}
+declare function ThemedButton({ variant, size, pressed, disabled, className, style, ...props }: ThemedButtonProps): react_jsx_runtime.JSX.Element;
+
+interface SubmittedActionConfig {
+    label?: ReactNode;
+    icon?: ReactNode;
+    variant?: ButtonVariant$1;
+}
+
+type PrimaryActionAttention = "auto" | "always" | "off";
+interface PrimaryActionButtonProps<Params extends InteractionParamsShape = InteractionParamsShape> {
+    
+    handle: InteractionHandle<Params>;
+    
+    variant?: ButtonVariant$1;
+    
+    size?: ButtonSize$1;
+    
+    label?: ReactNode;
+    
+    ready?: boolean;
+    
+    whenSubmitted?: SubmittedActionConfig;
+    
+    icon?: ReactNode;
+    
+    params?: Record<string, unknown>;
+    
+    attention?: PrimaryActionAttention;
+    
+    style?: CSSProperties;
+    
+    className?: string;
+}
+
+declare function PrimaryActionButton<Params extends InteractionParamsShape = InteractionParamsShape>({ handle, variant, size, label, ready, whenSubmitted, icon, params, attention, style, className, }: PrimaryActionButtonProps<Params>): react_jsx_runtime.JSX.Element;
+
+interface ActionPanelProps {
+    title?: string;
+    
+    state?: string;
+    
+    stateLabels?: Record<string, string>;
+    collapsible?: boolean;
+    defaultExpanded?: boolean;
+    children: ReactNode;
+    className?: string;
+}
+declare function ActionPanel({ title, state, stateLabels, collapsible, defaultExpanded, children, className, }: ActionPanelProps): react_jsx_runtime.JSX.Element;
+interface ActionGroupProps {
+    title: string;
+    description?: string;
+    visible?: boolean;
+    
+    variant?: "default" | "warning" | "danger" | "success";
+    children: ReactNode;
+    className?: string;
+}
+declare function ActionGroup({ title, description, visible, variant, children, className, }: ActionGroupProps): react_jsx_runtime.JSX.Element | null;
+
+interface MoreActionsProps {
+    
+    children: ReactNode;
+    
+    label?: string;
+    
+    count?: number;
+    
+    defaultOpen?: boolean;
+    
+    style?: CSSProperties;
+}
+declare function MoreActions({ children, label, count, defaultOpen, style, }: MoreActionsProps): react_jsx_runtime.JSX.Element;
+
+interface DiceRollerRenderProps {
+    values: Array<number | undefined> | undefined;
+    
+    sum: number | undefined;
+    diceCount: number;
+    allRolled: boolean;
+}
+interface DiceRollerRollAction<Params extends InteractionParamsShape = InteractionParamsShape> {
+    
+    handle: InteractionHandle<Params> | null;
+    title?: ReactNode;
+    description?: ReactNode;
+    rollLabel?: ReactNode;
+    resultLabel?: ReactNode;
+    minSpinMs?: number;
+    revealHoldMs?: number;
+}
+interface DiceRollerProps<Params extends InteractionParamsShape = InteractionParamsShape> {
+    values?: Array<number | undefined>;
+    
+    diceCount?: number;
+    render?: (props: DiceRollerRenderProps) => ReactNode;
+    
+    rollAction?: DiceRollerRollAction<Params>;
+    className?: string;
+}
+declare function DiceRoller<Params extends InteractionParamsShape = InteractionParamsShape>({ values, diceCount, render, rollAction, className, }: DiceRollerProps<Params>): react_jsx_runtime.JSX.Element;
+
+interface PhaseIndicatorProps {
+    currentPhase: string;
+    phaseLabels?: Record<string, string>;
+    isMyTurn?: boolean;
+    activePlayerNames?: string[];
+    variant?: "badge" | "bar" | "minimal";
+    className?: string;
+}
+declare function PhaseIndicator({ currentPhase, phaseLabels, isMyTurn, activePlayerNames, variant, className, }: PhaseIndicatorProps): react_jsx_runtime.JSX.Element;
+
+interface PlayerScore {
+    playerId: string;
+    name: string;
+    score: number;
+    isWinner?: boolean;
+    details?: Record<string, number>;
+}
+interface GameEndDisplayProps {
+    isGameOver: boolean;
+    
+    scores: PlayerScore[];
+    winnerMessage?: string;
+    showDetails?: boolean;
+    onReturnToLobby?: () => void;
+    className?: string;
+}
+declare function GameEndDisplay({ isGameOver, scores, winnerMessage, showDetails, onReturnToLobby, className, }: GameEndDisplayProps): react_jsx_runtime.JSX.Element | null;
+
+interface NetworkNode {
+    id: string;
+    label?: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    type?: string;
+    data?: Record<string, unknown>;
+}
+interface NetworkEdge {
+    id: string;
+    from: string;
+    to: string;
+    label?: string | number;
+    owner?: string;
+    type?: string;
+    data?: Record<string, unknown>;
+}
+interface NetworkPiece {
+    id: string;
+    nodeId: string;
+    owner?: string;
+    type?: string;
+    data?: Record<string, unknown>;
+}
+interface NetworkGraphProps {
+    nodes: NetworkNode[];
+    edges: NetworkEdge[];
+    pieces: NetworkPiece[];
+    
+    renderNode: (node: NetworkNode, pieces: NetworkPiece[]) => ReactNode;
+    renderEdge: (edge: NetworkEdge, fromNode: NetworkNode, toNode: NetworkNode) => ReactNode;
+    renderPiece: (piece: NetworkPiece, position: {
+        x: number;
+        y: number;
+    }) => ReactNode;
+    width?: number | string;
+    height?: number | string;
+    nodeRadius?: number;
+    enablePanZoom?: boolean;
+    initialZoom?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    padding?: number;
+    className?: string;
+}
+interface DefaultNetworkNodeProps {
+    radius?: number;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    isSelected?: boolean;
+    isHighlighted?: boolean;
+    label?: string;
+    maxLabelLength?: number;
+    onClick?: () => void;
+    onPointerEnter?: () => void;
+    onPointerLeave?: () => void;
+    className?: string;
+}
+
+declare function DefaultNetworkNode({ radius, fill, stroke, strokeWidth, isSelected, isHighlighted, label, maxLabelLength, onClick, onPointerEnter, onPointerLeave, className, }: DefaultNetworkNodeProps): react_jsx_runtime.JSX.Element;
+interface DefaultNetworkEdgeProps {
+    from: {
+        x: number;
+        y: number;
+    };
+    to: {
+        x: number;
+        y: number;
+    };
+    color?: string;
+    strokeWidth?: number;
+    isSelected?: boolean;
+    isHighlighted?: boolean;
+    
+    label?: string | number;
+    onClick?: () => void;
+    onPointerEnter?: () => void;
+    onPointerLeave?: () => void;
+    className?: string;
+}
+
+declare function DefaultNetworkEdge({ from, to, color, strokeWidth, isSelected, isHighlighted, label, onClick, onPointerEnter, onPointerLeave, className, }: DefaultNetworkEdgeProps): react_jsx_runtime.JSX.Element;
+interface DefaultNetworkPieceProps {
+    color?: string;
+    radius?: number;
+    shape?: "circle" | "square";
+    onClick?: () => void;
+    className?: string;
+}
+declare function DefaultNetworkPiece({ color, radius, shape, onClick, className, }: DefaultNetworkPieceProps): react_jsx_runtime.JSX.Element;
+declare function NetworkGraph({ nodes, edges, pieces, renderNode, renderEdge, renderPiece, width, height, nodeRadius, enablePanZoom, initialZoom, minZoom, maxZoom, padding, className, }: NetworkGraphProps): react_jsx_runtime.JSX.Element;
+
+interface ZoneShape {
+    type: "polygon" | "path" | "circle";
+    points?: Array<{
+        x: number;
+        y: number;
+    }>;
+    
+    path?: string;
+    center?: {
+        x: number;
+        y: number;
+    };
+    radius?: number;
+}
+interface ZoneDefinition {
+    id: string;
+    name: string;
+    adjacentTo: string[];
+    shape?: ZoneShape;
+    value?: number;
+    type?: string;
+    data?: Record<string, unknown>;
+}
+interface ZonePiece {
+    id: string;
+    zoneId: string;
+    type: string;
+    owner?: string;
+    
+    count?: number;
+    data?: Record<string, unknown>;
+}
+interface ZoneMapProps {
+    zones: ZoneDefinition[];
+    pieces: ZonePiece[];
+    renderZone: (zone: ZoneDefinition, pieces: ZonePiece[]) => ReactNode;
+    backgroundImage?: string;
+    width?: number | string;
+    height?: number | string;
+    enablePanZoom?: boolean;
+    initialZoom?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    className?: string;
+}
+type ZoneHighlightType = "valid" | "selected" | "attack" | "defend" | "neutral";
+interface DefaultZoneProps {
+    zone: ZoneDefinition;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    isHighlighted?: boolean;
+    highlightType?: ZoneHighlightType;
+    isSelected?: boolean;
+    showLabel?: boolean;
+    showValue?: boolean;
+    onClick?: () => void;
+    onHover?: (hovering: boolean) => void;
+    className?: string;
+    children?: ReactNode;
+}
+declare function DefaultZone({ zone, fill, stroke, strokeWidth, isHighlighted, highlightType, isSelected, showLabel, showValue, onClick, onHover, className, children, }: DefaultZoneProps): react_jsx_runtime.JSX.Element;
+interface DefaultZonePiecesProps {
+    pieces: ZonePiece[];
+    zone: ZoneDefinition;
+    playerColors?: Record<string, string>;
+    radius?: number;
+    spacing?: number;
+    yOffset?: number;
+    className?: string;
+}
+declare function DefaultZonePieces({ pieces, zone, playerColors, radius, spacing, yOffset, className, }: DefaultZonePiecesProps): react_jsx_runtime.JSX.Element | null;
+interface DefaultZonePieceProps {
+    piece: ZonePiece;
+    x?: number;
+    y?: number;
+    radius?: number;
+    color?: string;
+    onClick?: () => void;
+    className?: string;
+}
+declare function DefaultZonePiece({ piece, x, y, radius, color, onClick, className, }: DefaultZonePieceProps): react_jsx_runtime.JSX.Element;
+declare function ZoneMap({ zones, pieces, renderZone, backgroundImage, width, height, enablePanZoom, initialZoom, minZoom, maxZoom, className, }: ZoneMapProps): react_jsx_runtime.JSX.Element;
+
+interface SlotDefinition {
+    id: string;
+    name: string;
+    description?: string;
+    capacity: number;
+    
+    exclusive?: boolean;
+    
+    owner?: string;
+    group?: string;
+    cost?: Record<string, number>;
+    reward?: Record<string, number>;
+    type?: string;
+    position?: {
+        x: number;
+        y: number;
+    };
+    data?: Record<string, unknown>;
+}
+type SlotOccupant = ViewSlotOccupant;
+interface SlotSystemProps {
+    slots: readonly SlotDefinition[];
+    occupants: readonly SlotOccupant[];
+    renderSlot: (slot: SlotDefinition, occupants: readonly SlotOccupant[]) => ReactNode;
+    layout?: "grid" | "list" | "grouped";
+    width?: number | string;
+    height?: number | string;
+    
+    minSlotWidth?: number;
+    className?: string;
+}
+interface DefaultSlotItemProps {
+    name: string;
+    description?: string;
+    capacity: number;
+    occupantCount: number;
+    isExclusive?: boolean;
+    isAvailable?: boolean;
+    isHighlighted?: boolean;
+    isSelected?: boolean;
+    costLabel?: string;
+    rewardLabel?: string;
+    renderOccupants?: () => ReactNode;
+    onClick?: () => void;
+    onPointerEnter?: () => void;
+    onPointerLeave?: () => void;
+    className?: string;
+}
+
+declare function DefaultSlotItem({ name, description, capacity, occupantCount, isExclusive, isAvailable, isHighlighted, isSelected, costLabel, rewardLabel, renderOccupants, onClick, onPointerEnter, onPointerLeave, className, }: DefaultSlotItemProps): react_jsx_runtime.JSX.Element;
+interface DefaultSlotOccupantProps {
+    color?: string;
+    size?: number;
+    shape?: "circle" | "square";
+    label?: string;
+    onClick?: () => void;
+    className?: string;
+}
+declare function DefaultSlotOccupant({ color, size, shape, label, onClick, className, }: DefaultSlotOccupantProps): react_jsx_runtime.JSX.Element;
+interface DefaultEmptySlotProps {
+    size?: number;
+    className?: string;
+}
+declare function DefaultEmptySlot({ size, className, }: DefaultEmptySlotProps): react_jsx_runtime.JSX.Element;
+declare function SlotSystem({ slots, occupants, renderSlot, layout, width, height, minSlotWidth, className, }: SlotSystemProps): react_jsx_runtime.JSX.Element;
+
+interface SquareEdgePosition {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    midX: number;
+    midY: number;
+    angle: number;
+}
+interface SquareVertexPosition {
+    x: number;
+    y: number;
+}
+interface InteractiveSquareEdge<TBoard extends AnySquareBoardInput = AnySquareBoardInput> extends NormalizedSquareEdgeOf<TBoard> {
+    position: SquareEdgePosition;
+}
+interface InteractiveSquareVertex<TBoard extends AnySquareBoardInput = AnySquareBoardInput> extends NormalizedSquareVertexOf<TBoard> {
+    position: SquareVertexPosition;
+}
+type InteractiveSquareSpace<TBoard extends AnySquareBoardInput = AnySquareBoardInput> = NormalizedSquareCellOf<TBoard>;
+interface SquareGeneratedGridInputProps {
+    id?: string;
+    layout?: "square";
+    spaces: Extract<AnySquareBoardInput, {
+        spaces: unknown;
+    }>["spaces"];
+    pieces?: AnySquareBoardInput["pieces"];
+    edges?: AnySquareBoardInput["edges"];
+    vertices?: AnySquareBoardInput["vertices"];
+}
+interface SquareAuthoredGridInputProps {
+    id?: string;
+    layout?: "square";
+    rows?: number;
+    cols?: number;
+    cells: Extract<AnySquareBoardInput, {
+        cells: unknown;
+    }>["cells"];
+    pieces?: readonly SquarePieceState[];
+    edges?: AnySquareBoardInput["edges"];
+    vertices?: AnySquareBoardInput["vertices"];
+}
+type SquareGridInputProps = SquareGeneratedGridInputProps | SquareAuthoredGridInputProps;
+type ResolvedSquareArrayProp<Value> = Exclude<Value, undefined> extends readonly unknown[] ? Exclude<Value, undefined> : readonly [];
+type SquareBoardLikeOfProps<TProps extends SquareGridInputProps> = TProps extends {
+    id?: infer Id;
+    layout?: infer Layout;
+    spaces: infer Spaces;
+    pieces?: infer Pieces;
+    edges?: infer Edges;
+    vertices?: infer Vertices;
+} ? {
+    id: Extract<Id, string> extends never ? string : Extract<Id, string>;
+    layout?: Extract<Layout, "square">;
+    spaces: Spaces;
+    pieces: ResolvedSquareArrayProp<Pieces>;
+    edges: ResolvedSquareArrayProp<Edges>;
+    vertices: ResolvedSquareArrayProp<Vertices>;
+} & GeneratedSquareBoardInput : TProps extends {
+    id?: infer Id;
+    layout?: infer Layout;
+    rows?: infer Rows;
+    cols?: infer Cols;
+    cells: infer Cells;
+    pieces?: infer Pieces;
+    edges?: infer Edges;
+    vertices?: infer Vertices;
+} ? {
+    id: Extract<Id, string> extends never ? string : Extract<Id, string>;
+    layout?: Extract<Layout, "square">;
+    rows: Extract<Rows, number> extends never ? number : Extract<Rows, number>;
+    cols: Extract<Cols, number> extends never ? number : Extract<Cols, number>;
+    cells: Cells;
+    pieces: ResolvedSquareArrayProp<Pieces>;
+    edges: ResolvedSquareArrayProp<Edges>;
+    vertices: ResolvedSquareArrayProp<Vertices>;
+} & AuthoredSquareBoardInput : never;
+type SquareGridProps<TProps extends SquareGridInputProps = SquareGridInputProps> = TProps & {
+    cellSize?: number;
+    
+    renderCell: (row: number, col: number) => ReactNode;
+    
+    renderPiece: (piece: NormalizedSquarePieceOf<NoInfer<SquareBoardLikeOfProps<TProps>>>) => ReactNode;
+    renderEdge?: (edge: NormalizedSquareEdgeOf<NoInfer<SquareBoardLikeOfProps<TProps>>>, position: SquareEdgePosition) => ReactNode;
+    renderVertex?: (vertex: NormalizedSquareVertexOf<NoInfer<SquareBoardLikeOfProps<TProps>>>, position: SquareVertexPosition) => ReactNode;
+    showCoordinates?: boolean;
+    coordinateStyle?: "algebraic" | "numeric" | "none";
+    width?: number | string;
+    height?: number | string;
+    enablePanZoom?: boolean;
+    initialZoom?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    className?: string;
+    interactiveSpaces?: InteractiveTargetLayer;
+    interactiveEdges?: InteractiveTargetLayer;
+    interactiveVertices?: InteractiveTargetLayer;
+    renderInteractiveSpace?: (space: InteractiveSquareSpace<NoInfer<SquareBoardLikeOfProps<TProps>>>, state: InteractiveTargetRenderState) => ReactNode;
+    renderInteractiveEdge?: (edge: InteractiveSquareEdge<NoInfer<SquareBoardLikeOfProps<TProps>>>, position: SquareEdgePosition, state: InteractiveTargetRenderState) => ReactNode;
+    renderInteractiveVertex?: (vertex: InteractiveSquareVertex<NoInfer<SquareBoardLikeOfProps<TProps>>>, position: SquareVertexPosition, state: InteractiveTargetRenderState) => ReactNode;
+};
+interface SquareGridBoardProps<TBoard extends AnySquareBoardInput = AnySquareBoardInput> {
+    board: TBoard;
+    cellSize?: number;
+    renderCell: (row: number, col: number) => ReactNode;
+    renderPiece: (piece: NormalizedSquarePieceOf<NoInfer<TBoard>>) => ReactNode;
+    renderEdge?: (edge: NormalizedSquareEdgeOf<NoInfer<TBoard>>, position: SquareEdgePosition) => ReactNode;
+    renderVertex?: (vertex: NormalizedSquareVertexOf<NoInfer<TBoard>>, position: SquareVertexPosition) => ReactNode;
+    showCoordinates?: boolean;
+    coordinateStyle?: "algebraic" | "numeric" | "none";
+    width?: number | string;
+    height?: number | string;
+    enablePanZoom?: boolean;
+    initialZoom?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    className?: string;
+    interactiveSpaces?: InteractiveTargetLayer;
+    interactiveEdges?: InteractiveTargetLayer;
+    interactiveVertices?: InteractiveTargetLayer;
+    renderInteractiveSpace?: (space: InteractiveSquareSpace<NoInfer<TBoard>>, state: InteractiveTargetRenderState) => ReactNode;
+    renderInteractiveEdge?: (edge: InteractiveSquareEdge<NoInfer<TBoard>>, position: SquareEdgePosition, state: InteractiveTargetRenderState) => ReactNode;
+    renderInteractiveVertex?: (vertex: InteractiveSquareVertex<NoInfer<TBoard>>, position: SquareVertexPosition, state: InteractiveTargetRenderState) => ReactNode;
+}
+interface DefaultGridCellProps {
+    size: number;
+    isLight?: boolean;
+    lightColor?: string;
+    darkColor?: string;
+    isHighlighted?: boolean;
+    highlightColor?: string;
+    isSelected?: boolean;
+    selectedColor?: string;
+    isValidMove?: boolean;
+    isCapture?: boolean;
+    onClick?: () => void;
+    onPointerEnter?: () => void;
+    onPointerLeave?: () => void;
+    className?: string;
+}
+
+declare function DefaultGridCell({ size, isLight, lightColor, darkColor, isHighlighted, highlightColor, isSelected, selectedColor, isValidMove, isCapture, onClick, onPointerEnter, onPointerLeave, className, }: DefaultGridCellProps): react_jsx_runtime.JSX.Element;
+interface DefaultGridPieceProps {
+    size: number;
+    color?: string;
+    strokeColor?: string;
+    label?: string;
+    isDragging?: boolean;
+    onClick?: () => void;
+    onPointerDown?: (e: React.PointerEvent) => void;
+    className?: string;
+}
+
+declare function DefaultGridPiece({ size, color, strokeColor, label, isDragging, onClick, onPointerDown, className, }: DefaultGridPieceProps): react_jsx_runtime.JSX.Element;
+interface DefaultChessPieceProps {
+    size: number;
+    type: string;
+    owner: "white" | "black";
+    onClick?: () => void;
+    onPointerDown?: (e: React.PointerEvent) => void;
+    className?: string;
+}
+
+declare function DefaultChessPiece({ size, type, owner, onClick, onPointerDown, className, }: DefaultChessPieceProps): react_jsx_runtime.JSX.Element;
+
+declare function toAlgebraic(row: number, col: number, totalRows: number): string;
+
+declare function toNumeric(row: number, col: number): string;
+interface SquareGridComponent {
+    <const TBoard extends AnySquareBoardInput>(props: SquareGridBoardProps<TBoard>): ReactNode;
+    <const TProps extends SquareGeneratedGridInputProps>(props: SquareGridProps<TProps>): ReactNode;
+    <const TProps extends SquareAuthoredGridInputProps>(props: SquareGridProps<TProps>): ReactNode;
+}
+declare const SquareGrid: SquareGridComponent;
+
+type HexOrientation = "pointy-top" | "flat-top";
+
+interface HexTileGeometry {
+    size: number;
+    orientation: HexOrientation;
+    center: {
+        x: 0;
+        y: 0;
+    };
+    position: {
+        x: number;
+        y: number;
+    };
+    corners: (options?: {
+        inset?: number;
+    }) => Array<{
+        x: number;
+        y: number;
+    }>;
+    points: (options?: {
+        inset?: number;
+    }) => string;
+    bounds: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+        width: number;
+        height: number;
+    };
+}
+interface EdgePosition {
+    
+    x1: number;
+    y1: number;
+    
+    x2: number;
+    y2: number;
+    
+    midX: number;
+    midY: number;
+    
+    centerAngle: number;
+    
+    edgeAngle: number;
+}
+interface InteractiveHexVertex<TBoard extends AnyHexBoardInput = AnyHexBoardInput> extends NormalizedHexVertexOf<TBoard> {
+    position: {
+        x: number;
+        y: number;
+    };
+    spaceIds: ReadonlyArray<BoardSpaceIdOf<TBoard>>;
+}
+interface InteractiveHexEdge<TBoard extends AnyHexBoardInput = AnyHexBoardInput> extends NormalizedHexEdgeOf<TBoard> {
+    position: EdgePosition;
+    spaceIds: ReadonlyArray<BoardSpaceIdOf<TBoard>>;
+}
+type InteractiveHexSpace<TBoard extends AnyHexBoardInput = AnyHexBoardInput> = NormalizedHexTileOf<TBoard>;
+interface HexGeneratedGridInputProps {
+    id?: string;
+    layout?: "hex";
+    orientation?: HexOrientation;
+    spaces: Extract<AnyHexBoardInput, {
+        spaces: unknown;
+    }>["spaces"];
+    edges?: AnyHexBoardInput["edges"];
+    vertices?: AnyHexBoardInput["vertices"];
+}
+interface HexAuthoredGridInputProps {
+    id?: string;
+    layout?: "hex";
+    orientation?: HexOrientation;
+    tiles: Extract<AnyHexBoardInput, {
+        tiles: unknown;
+    }>["tiles"];
+    edges?: AnyHexBoardInput["edges"];
+    vertices?: AnyHexBoardInput["vertices"];
+}
+type HexGridInputProps = HexGeneratedGridInputProps | HexAuthoredGridInputProps;
+type ResolvedArrayProp<Value> = Exclude<Value, undefined> extends readonly unknown[] ? Exclude<Value, undefined> : readonly [];
+type HexBoardLikeOfProps<TProps extends HexGridInputProps> = TProps extends {
+    id?: infer Id;
+    layout?: infer Layout;
+    orientation?: infer Orientation;
+    spaces: infer Spaces;
+    edges?: infer Edges;
+    vertices?: infer Vertices;
+} ? {
+    id: Extract<Id, string> extends never ? string : Extract<Id, string>;
+    layout?: Extract<Layout, "hex">;
+    orientation?: Extract<Orientation, HexOrientation>;
+    spaces: Spaces;
+    edges: ResolvedArrayProp<Edges>;
+    vertices: ResolvedArrayProp<Vertices>;
+} & GeneratedHexBoardInput : TProps extends {
+    id?: infer Id;
+    layout?: infer Layout;
+    orientation?: infer Orientation;
+    tiles: infer Tiles;
+    edges?: infer Edges;
+    vertices?: infer Vertices;
+} ? {
+    id: Extract<Id, string> extends never ? string : Extract<Id, string>;
+    layout?: Extract<Layout, "hex">;
+    orientation?: Extract<Orientation, HexOrientation>;
+    tiles: Tiles;
+    edges: ResolvedArrayProp<Edges>;
+    vertices: ResolvedArrayProp<Vertices>;
+} & AuthoredHexBoardInput : never;
+type HexGridProps<TProps extends HexGridInputProps = HexGridInputProps> = TProps & {
+    orientation?: HexOrientation;
+    
+    hexSize?: number;
+    
+    renderTile: (tile: NormalizedHexTileOf<NoInfer<HexBoardLikeOfProps<TProps>>>, geometry: HexTileGeometry) => ReactNode;
+    
+    renderEdge: (edge: NormalizedHexEdgeOf<NoInfer<HexBoardLikeOfProps<TProps>>>, position: EdgePosition) => ReactNode;
+    renderVertex: (vertex: NormalizedHexVertexOf<NoInfer<HexBoardLikeOfProps<TProps>>>, position: {
+        x: number;
+        y: number;
+    }) => ReactNode;
+    width?: number | string;
+    height?: number | string;
+    enablePanZoom?: boolean;
+    initialZoom?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    className?: string;
+    
+    interactiveSpaces?: InteractiveTargetLayer;
+    
+    interactiveVertices?: InteractiveTargetLayer;
+    
+    interactiveEdges?: InteractiveTargetLayer;
+    
+    renderInteractiveSpace?: (space: InteractiveHexSpace<NoInfer<HexBoardLikeOfProps<TProps>>>, state: InteractiveTargetRenderState) => ReactNode;
+    
+    renderInteractiveVertex?: (vertex: InteractiveHexVertex<NoInfer<HexBoardLikeOfProps<TProps>>>, position: {
+        x: number;
+        y: number;
+    }, state: InteractiveTargetRenderState) => ReactNode;
+    
+    renderInteractiveEdge?: (edge: InteractiveHexEdge<NoInfer<HexBoardLikeOfProps<TProps>>>, position: EdgePosition, state: InteractiveTargetRenderState) => ReactNode;
+    interactiveVertexSize?: number;
+    interactiveEdgeSize?: number;
+};
+interface HexGridBoardProps<TBoard extends AnyHexBoardInput = AnyHexBoardInput> {
+    board: TBoard;
+    orientation?: HexOrientation;
+    hexSize?: number;
+    
+    renderTile: (tile: NormalizedHexTileOf<NoInfer<TBoard>>, geometry: HexTileGeometry) => ReactNode;
+    
+    renderEdge: (edge: NormalizedHexEdgeOf<NoInfer<TBoard>>, position: EdgePosition) => ReactNode;
+    renderVertex: (vertex: NormalizedHexVertexOf<NoInfer<TBoard>>, position: {
+        x: number;
+        y: number;
+    }) => ReactNode;
+    width?: number | string;
+    height?: number | string;
+    enablePanZoom?: boolean;
+    initialZoom?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    className?: string;
+    interactiveSpaces?: InteractiveTargetLayer;
+    interactiveVertices?: InteractiveTargetLayer;
+    interactiveEdges?: InteractiveTargetLayer;
+    
+    renderInteractiveSpace?: (space: InteractiveHexSpace<NoInfer<TBoard>>, state: InteractiveTargetRenderState) => ReactNode;
+    
+    renderInteractiveVertex?: (vertex: InteractiveHexVertex<NoInfer<TBoard>>, position: {
+        x: number;
+        y: number;
+    }, state: InteractiveTargetRenderState) => ReactNode;
+    
+    renderInteractiveEdge?: (edge: InteractiveHexEdge<NoInfer<TBoard>>, position: EdgePosition, state: InteractiveTargetRenderState) => ReactNode;
+    interactiveVertexSize?: number;
+    interactiveEdgeSize?: number;
+}
+interface DefaultHexTileProps {
+    
+    size: number;
+    fill: string;
+    stroke?: string;
+    strokeWidth?: number;
+    isSelected?: boolean;
+    isHighlighted?: boolean;
+    label?: string;
+    showCoordinates?: boolean;
+    coordinates?: {
+        q: number;
+        r: number;
+    };
+    orientation?: HexOrientation;
+    onClick?: () => void;
+    onPointerEnter?: () => void;
+    onPointerLeave?: () => void;
+    className?: string;
+}
+
+declare function DefaultHexTile({ size, fill, stroke, strokeWidth, isSelected, isHighlighted, label, showCoordinates, coordinates, orientation, onClick, onPointerEnter, onPointerLeave, className, }: DefaultHexTileProps): react_jsx_runtime.JSX.Element;
+interface DefaultHexEdgeProps {
+    position: EdgePosition;
+    color: string;
+    hasOwner?: boolean;
+    strokeWidth?: number;
+    touchTargetSize?: number;
+    onClick?: () => void;
+    className?: string;
+}
+
+declare function DefaultHexEdge({ position, color, hasOwner, strokeWidth, touchTargetSize, onClick, className, }: DefaultHexEdgeProps): react_jsx_runtime.JSX.Element;
+interface DefaultHexVertexProps {
+    position: {
+        x: number;
+        y: number;
+    };
+    color: string;
+    stroke?: string;
+    strokeWidth?: number;
+    hasOwner?: boolean;
+    isSelected?: boolean;
+    isHighlighted?: boolean;
+    size?: number;
+    touchTargetSize?: number;
+    shape?: "circle" | "square";
+    onClick?: () => void;
+    onPointerEnter?: () => void;
+    onPointerLeave?: () => void;
+    className?: string;
+}
+
+declare function DefaultHexVertex({ position, color, stroke, strokeWidth, hasOwner, isSelected, isHighlighted, size, touchTargetSize, shape, onClick, onPointerEnter, onPointerLeave, className, }: DefaultHexVertexProps): react_jsx_runtime.JSX.Element;
+declare const hexUtils: {
+    
+    axialToPixel(q: number, r: number, size: number, orientation: HexOrientation): {
+        x: number;
+        y: number;
+    };
+    getNeighbors(q: number, r: number): Array<{
+        q: number;
+        r: number;
+    }>;
+    getDistance(q1: number, r1: number, q2: number, r2: number): number;
+    getHexCorners(centerX: number, centerY: number, size: number, orientation: HexOrientation): Array<{
+        x: number;
+        y: number;
+    }>;
+    getHexPoints(centerX: number, centerY: number, size: number, orientation: HexOrientation): string;
+    getEdgePosition(hex1Pos: {
+        x: number;
+        y: number;
+    }, hex2Pos: {
+        x: number;
+        y: number;
+    }, size: number): EdgePosition;
+    getVertexPosition(hex1Pos: {
+        x: number;
+        y: number;
+    }, hex2Pos: {
+        x: number;
+        y: number;
+    }, hex3Pos: {
+        x: number;
+        y: number;
+    }): {
+        x: number;
+        y: number;
+    };
+};
+interface HexGridComponent {
+    <const TBoard extends AnyHexBoardInput>(props: HexGridBoardProps<TBoard>): ReactNode;
+    <const TProps extends HexGeneratedGridInputProps>(props: HexGridProps<TProps>): ReactNode;
+    <const TProps extends HexAuthoredGridInputProps>(props: HexGridProps<TProps>): ReactNode;
+}
+declare const HexGrid: HexGridComponent;
+
+type HexBoardViewTile<TBoard extends AnyHexBoardInput, TSpaceView extends {
+    id: BoardSpaceIdOf<TBoard>;
+}> = Omit<NormalizedHexTileOf<TBoard>, "view"> & {
+    view: TSpaceView;
+};
+
+interface HexBoardView<TBoard extends AnyHexBoardInput, TSpaceView extends {
+    id: BoardSpaceIdOf<TBoard>;
+}> {
+    id: BoardIdOf<TBoard>;
+    layout?: "hex";
+    orientation?: "pointy-top" | "flat-top";
+    tiles: ReadonlyArray<HexBoardViewTile<TBoard, TSpaceView>>;
+    edges: TBoard["edges"];
+    vertices: TBoard["vertices"];
+}
+interface CreateHexBoardViewOptions<TSpaceView> {
+    spaces: readonly TSpaceView[];
+}
+
+declare function createHexBoardView<const TBoard extends AnyHexBoardInput, const TSpaceView extends {
+    id: BoardSpaceIdOf<TBoard>;
+}>(board: TBoard, options: CreateHexBoardViewOptions<TSpaceView>): HexBoardView<TBoard, TSpaceView>;
+
+export { ActionButton, ActionGroup, ActionPanel, Board, BoardInteractionConflictError, BoardRoot, BoardTarget, Card, CostDisplay, DefaultChessPiece, DefaultEmptySlot, DefaultGridCell, DefaultGridPiece, DefaultHexEdge, DefaultHexTile, DefaultHexVertex, DefaultNetworkEdge, DefaultNetworkNode, DefaultNetworkPiece, DefaultSlotItem, DefaultSlotOccupant, DefaultTrackConnection, DefaultTrackJump, DefaultTrackPiece, DefaultTrackSpace, DefaultZone, DefaultZonePiece, DefaultZonePieces, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DiceRoller, Drawer, DrawerClose, DrawerContent, DrawerDescription, DrawerFooter, DrawerHeader, DrawerOverlay, DrawerPortal, DrawerTitle, DrawerTrigger, ErrorBoundary, GameEndDisplay, GameSkeleton, Hand, HandDock, HexGrid, Interaction, InteractionCardInput, InteractionDescription, InteractionField, InteractionForm, InteractionInput, InteractionLabel, InteractionRoot, InteractionSubmit, InteractionTrigger, InteractionUnavailableMessage, InteractionValidationMessage, MoreActions, NetworkGraph, Phase, PhaseIndicator, PhaseSwitch, PlayArea, PlayerRoster, PlayerRosterBadges, PlayerRosterEmpty, PlayerRosterList, PlayerRosterName, PlayerRosterRoot, PlayerRosterScore, PlayerRosterSwitchButton, PluginRuntime, PluginStateProvider, PrimaryActionButton, PrimaryButton, Prompt, PromptDialogHost, PromptInbox, PromptInboxEmpty, PromptInboxItems, PromptInboxRoot, PromptMessage, PromptOption, PromptOptions, PromptRoot, PromptTitle, ResourceCounter, RuntimeContext, RuntimeProvider, SlotSystem, SquareGrid, ThemeProvider, ThemedButton, ToastProvider, TrackBoard, Zone, ZoneItem, ZoneList, ZoneMap, ZoneRoot, arcadeTheme, buttonStyle, calculateViewBox, chipStyle, composeEventHandlers, createDreamboardUI, createHexBoardView, cssVar, cssVarOr, defaultFormInputs, deriveBoardTheme, getThemePreset, hasDefaultInteractionFormFields, hexUtils, intentForVariant, mergeTheme, motionDuration, normalizeHexBoardInput, normalizeSquareBoardInput, playerColor, renderPrimitive, resolveTheme, studioTheme, surfaceStyle, tabletopTheme, themeToCssVars, toAlgebraic, toNumeric, toTrackBoardData, useActivePlayers, useBoardInteractions, useBoardPrimitiveContext, useBoardTheme, useBoardTopology, useCards, useGameSelector, useGameView, useHandLayout, useHexBoard, useInteractionByKey, useInteractionHandle, useInteractionPrimitiveContext, useIsMobile, useIsMyTurn, useLobby, useMe, usePanZoom, usePlayerInfo, usePlayerTurnOrder, usePluginActions, usePluginRuntime, usePluginSession, usePluginState, useRuntimeContext, useSeatInbox, useSimultaneousPhase, useSquareBoard, useTheme, useThemeCssVars, useToast, useZoneCardContext, useZonePrimitiveContext };
+export type { ActionButtonProps, ActionGroupProps, ActionPanelProps, AnyHexBoardInput, AnySquareBoardInput, AuthoredHexBoardInput, AuthoredSquareBoardInput, BoardEdgeIdOf, BoardInteractionsContext, BoardInteractionsOptions, BoardKindStates, BoardRootProps, BoardSpaceIdOf, BoardStates, BoardTargetExtraInputs, BoardTargetKey, BoardTargetLayerFactory, BoardTargetLayerOptions, BoardTargetProps, BoardTheme, BoardVertexIdOf, ButtonSize$1 as ButtonSize, ButtonVariant$1 as ButtonVariant, CardCollection, CardKey, CardPositionProps, CardProps, CardSize, ClientParamSchema, ClientParamSchemaMap, ColorRamp, ComponentTokens, CostDisplayProps, DefaultChessPieceProps, DefaultEmptySlotProps, DefaultGridCellProps, DefaultGridPieceProps, DefaultHexEdgeProps, DefaultHexTileProps, DefaultHexVertexProps, DefaultNetworkEdgeProps, DefaultNetworkNodeProps, DefaultNetworkPieceProps, DefaultSlotItemProps, DefaultSlotOccupantProps, DefaultTrackConnectionProps, DefaultTrackJumpProps, DefaultTrackPieceProps, DefaultTrackSpaceProps, DefaultZonePieceProps, DefaultZonePiecesProps, DefaultZoneProps, DiceRollerProps, DiceStates, DieState, DraftValidation, DreamboardUI, DreamboardUIRegister, EdgePosition, Elevation, ErrorBoundaryProps, FoundationColor, GameEndDisplayProps, GameSkeletonProps, GameState, GameplayPromptOption, GameplaySnapshot, GeneratedHexBoardInput, GeneratedHexSpaceStateLike, GeneratedSquareBoardInput, GeneratedSquareSpaceStateLike, GeneratedTiledEdgeStateLike, GeneratedTiledVertexStateLike, HandDockMode, HandDockPlacement, HandDockPresentation, HandDockProps, HandDockToggleContext, HandLayout, HandProps, HexBoardInput, HexBoardState, HexBoardView, HexBoardViewTile, HexEdgeState, HexGridBoardProps, HexGridProps, HexOrientation, HexTileGeometry, HexTileState, HexVertexState, IntentColor, InteractionCardInputProps, InteractionContext, InteractionContextOption, InteractionDescriptor, InteractionFieldProps, InteractionFieldRenderMap, InteractionFieldRenderProps, InteractionFormProps, InteractionHandle, InteractionHandleStatus, InteractionInputKey, InteractionInputProps, InteractionKey, InteractionParamsShape, InteractionPartProps, InteractionRootProps, InteractionSubmitProps, InteractionTriggerProps, InteractiveHexEdge, InteractiveHexVertex, InteractiveSquareEdge, InteractiveSquareVertex, InteractiveTargetLayer, InteractiveTargetRenderState, LobbyState, MoreActionsProps, Motion, NetworkBoardState, NetworkEdge, NetworkEdgeState, NetworkGraphProps, NetworkNode, NetworkNodeState, NetworkPiece, NetworkPieceState, NormalizedHexBoard, NormalizedHexEdgeOf, NormalizedHexTileOf, NormalizedHexVertexOf, NormalizedSquareBoard, NormalizedSquareCellOf, NormalizedSquareEdgeOf, NormalizedSquarePieceOf, NormalizedSquareVertexOf, PanZoomTransform, PhaseFallback, PhaseIndicatorProps, PhaseKey, PhaseRouteMap, PhaseSwitchProps, PlayAreaProps, Player, PlayerColor, PlayerRosterBadge, PlayerRosterComponents, PlayerRosterEntry, PlayerRosterListProps, PlayerRosterPartProps, PlayerRosterRootProps, PlayerRosterSwitchButtonProps, PlayerScore, PluginRuntimeProps, PluginSessionState, PluginStateSnapshot, PrimaryActionAttention, PrimaryActionButtonProps, PrimaryButtonProps, PrimitiveCommonProps, PrimitiveDataAttributes, PromptDialogHostProps, PromptKey, PromptOptionKey, PromptOptionProps, PromptRootProps, Radius, RegisteredUI, ResourceCounterProps, ResourceDefinition, ResourceDisplayConfig, RuntimeAPI, SeatInbox, SemanticColor, SlotDefinition, SlotOccupant, SlotSystemProps, Space, SquareBoardInput, SquareBoardState, SquareCellState, SquareEdgePosition, SquareEdgeState, SquareGridBoardProps, SquareGridProps, SquarePieceState, SquareVertexPosition, SquareVertexState, SubmissionError, Theme, ThemeContextValue, ThemeMeta, ThemeOverride, ThemePresetId, ThemeProviderProps, ThemedButtonProps, Toast, ToastType, TrackBoardProps, TrackBoardState, TrackPiece, TrackPieceState, TrackSpace, TrackSpaceState, TypedBoard, TypedInteraction, TypedPhase, TypedPlayerRoster, TypedPrompt, TypedPromptInbox, TypedZone, Typography, UIContract, UIContractBucket, UseHandLayoutOptions, UseHandLayoutReturn, UsePanZoomOptions, UsePanZoomReturn, UsePluginRuntimeOptions, UsePluginRuntimeResult, ValidationResult, ViewCard, ViewSlotOccupant, ZoneDefinition, ZoneHighlightType, ZoneItemProps, ZoneKey, ZoneListProps, ZoneMapProps, ZonePiece, ZoneRootProps, ZoneShape };