@dreamboard-games/sdk 0.2.0

package/dist/ui-contract-iQfTtUSL.d.ts

@@ -0,0 +1,1161 @@
+import * as react from 'react';
+import { CSSProperties, ReactNode, AriaAttributes, HTMLAttributes, JSX, ReactElement, ButtonHTMLAttributes, InputHTMLAttributes } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { _ as Theme, a0 as ThemeOverride, A as AnyHexBoardInput, d as BoardSpaceIdOf, u as HexGridBoardProps, r as HexBoardView } from './hex-board-view-D_07hO6O.js';
+import { a as ThemePresetId } from './ThemeProvider-fy0_QzgO.js';
+import { a as InteractionDescriptor, Z as ZoneHandlesSnapshot, I as InputDomain, b as InteractionInputDescriptor } from './runtime-api-DWxvTr-O.js';
+import { V as ViewCard } from './cards-Sl3b40Mv.js';
+import { a as PluginSessionState, P as PlayerId } from './runtime-api-3dshj6kK.js';
+import { Player } from './ui/types/player-state.js';
+import { H as HexColor } from './hex-color-MhOyuY-o.js';
+
+interface UIRootProps {
+    /**
+     * Preset id, a full Theme, or omitted to defer to the host-mounted theme.
+     * When omitted, no provider is mounted and existing parent themes apply.
+     */
+    theme?: ThemePresetId | Theme;
+    /** Deep-partial overrides forwarded to the SDK ThemeProvider. */
+    themeOverride?: ThemeOverride;
+    /** Forwarded to the SDK ThemeProvider. */
+    reducedMotion?: "auto" | "force" | "ignore";
+    /** Forwarded to the SDK ThemeProvider wrapper. */
+    className?: string;
+    /** Forwarded to the SDK ThemeProvider wrapper style. */
+    style?: CSSProperties;
+    children: ReactNode;
+}
+/**
+ * Root provider for generated UI contracts.
+ *
+ * Composes the SDK `ThemeProvider` so authors can write
+ * `<UI.Root theme="tabletop">` and have presentation tokens applied without
+ * importing `@dreamboard-games/sdk/ui` themselves. The runtime workspace contract
+ * stacks plugin-state, toast and mobile-hand providers around this.
+ */
+declare function UIRoot({ theme, themeOverride, reducedMotion, className, style, children, }: UIRootProps): react_jsx_runtime.JSX.Element;
+declare const UI: {
+    Root: typeof UIRoot;
+};
+
+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;
+
+interface ZoneContextValue {
+    zone: string;
+    snapshot: ZoneHandlesSnapshot | null;
+}
+interface ZoneCardContextValue {
+    zone: string;
+    cardId: string;
+}
+/**
+ * An item rendered by a zone primitive. Discriminated by `hidden`:
+ *
+ * - `hidden: false` — fully hydrated from the zone projection. Carries the
+ *   authored card type, properties, and reducer-projected interaction state.
+ * - `hidden: true` — the zone snapshot exposes the card id but withholds its
+ *   contents (e.g. opponent zones, or a zone that is projected count-only).
+ *   The render contract is honest about not knowing the type; authors must
+ *   narrow on `hidden` before reading `cardType` / `properties`.
+ *
+ * Replaces the previous silent fallback that widened `cardType` to the
+ * untyped string `"unknown"` — see SDK Design Principles §2 (strong contracts
+ * over comments).
+ */
+type ZoneCardRenderItem<CardIdValue extends string = string, CardTypeValue extends string = string, Properties extends Record<string, unknown> = Record<string, unknown>> = HydratedZoneCardRenderItem<CardIdValue, CardTypeValue, Properties> | HiddenZoneCardRenderItem<CardIdValue>;
+interface HydratedZoneCardRenderItem<CardIdValue extends string = string, CardTypeValue extends string = string, Properties extends Record<string, unknown> = Record<string, unknown>> extends ViewCard<CardIdValue, CardTypeValue, Properties> {
+    zone: string;
+    index: number;
+    hidden: false;
+    playable: boolean;
+    interactions: readonly InteractionDescriptor[];
+}
+interface HiddenZoneCardRenderItem<CardIdValue extends string = string> {
+    id: CardIdValue;
+    zone: string;
+    index: number;
+    hidden: true;
+}
+interface ZonePileContextValue {
+    zone: string;
+    label: string;
+    count: number;
+    cards: readonly string[];
+    items: readonly ZoneCardRenderItem[];
+    hasVisibleCards: boolean;
+    isHidden: boolean;
+    description: string | null;
+}
+declare function useZonePrimitiveContext(): ZoneContextValue;
+declare function useOptionalZonePrimitiveContext(): ZoneContextValue | null;
+declare function useZoneCardContext(): ZoneCardContextValue | null;
+declare function useZonePileContext(): ZonePileContextValue;
+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;
+interface ZoneListProps extends Omit<PrimitiveCommonProps, "children">, Omit<HTMLAttributes<HTMLElement>, "children"> {
+    children?: ReactNode | ((card: ZoneCardRenderItem) => ReactNode);
+    empty?: ReactNode;
+    sort?: (a: ZoneCardRenderItem, b: ZoneCardRenderItem) => number;
+}
+declare function ZoneList({ children, empty, sort, ...props }: ZoneListProps): react.ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+interface UseZoneCardsOptions {
+    sort?: (a: ZoneCardRenderItem, b: ZoneCardRenderItem) => number;
+}
+interface UseZoneCardsResult {
+    zone: string;
+    items: readonly ZoneCardRenderItem[];
+    count: number;
+    isEmpty: boolean;
+}
+declare function useZoneCards({ sort, }?: UseZoneCardsOptions): UseZoneCardsResult;
+interface ZoneItemProps extends PrimitiveCommonProps, HTMLAttributes<HTMLElement> {
+    card: string | ZoneCardRenderItem;
+}
+declare function ZoneItem({ card, children, ...props }: ZoneItemProps): react_jsx_runtime.JSX.Element;
+interface ZoneCardAtProps<Zone extends string = ZoneKey> extends Omit<ZoneItemProps, "card" | "children"> {
+    zone?: Zone;
+    index: number;
+    children?: ReactNode | ((card: ZoneCardRenderItem) => ReactNode);
+    empty?: ReactNode;
+}
+declare function ZoneCardAt<Zone extends string = ZoneKey>({ zone, ...props }: ZoneCardAtProps<Zone>): react_jsx_runtime.JSX.Element;
+type ZoneTopCardProps<Zone extends string = ZoneKey> = Omit<ZoneCardAtProps<Zone>, "index">;
+declare function ZoneTopCard<Zone extends string = ZoneKey>(props: ZoneTopCardProps<Zone>): react_jsx_runtime.JSX.Element;
+type ZoneCardActionExtraInputs = Record<string, unknown> | ((cardId: string) => Record<string, unknown>);
+interface ZoneCardActionProps<Card extends string = string> extends PrimitiveCommonProps, Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onSelect"> {
+    card?: Card;
+    interaction?: string;
+    input?: string;
+    extraInputs?: ZoneCardActionExtraInputs;
+    onSelect?: (result: ZoneCardActionResult) => void;
+    onSelectError?: (error: unknown) => void;
+}
+type ZoneCardActionResult = {
+    status: "none";
+} | {
+    status: "pending";
+    interactionKey: string;
+    descriptor: InteractionDescriptor;
+    missingInputs: readonly string[];
+} | {
+    status: "submitted";
+    interactionKey: string;
+    descriptor: InteractionDescriptor;
+};
+declare function ZoneCardAction<Card extends string = string>({ card, interaction, input, extraInputs, onSelect, onSelectError, disabled, onClick, children, ...props }: ZoneCardActionProps<Card>): react.ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+interface ZonePileRootProps<Zone extends string = ZoneKey> extends Omit<ZoneRootProps<Zone>, "children"> {
+    label: string;
+    children?: ReactNode;
+    hiddenDescription?: string | null;
+    emptyDescription?: string | null;
+    visibleDescription?: ((count: number) => string) | null;
+}
+declare function ZonePileRoot<Zone extends string = ZoneKey>({ zone, label, hiddenDescription, emptyDescription, visibleDescription, children, ...props }: ZonePileRootProps<Zone>): react_jsx_runtime.JSX.Element;
+interface ZonePileTriggerProps extends PrimitiveCommonProps, ButtonHTMLAttributes<HTMLButtonElement> {
+}
+declare function ZonePileTrigger({ children, ...props }: ZonePileTriggerProps): react.ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+type ZonePileLabelProps = PrimitiveCommonProps & HTMLAttributes<HTMLElement>;
+declare function ZonePileLabel({ children, ...props }: ZonePileLabelProps): react.ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+type ZonePileCountProps = PrimitiveCommonProps & HTMLAttributes<HTMLElement>;
+declare function ZonePileCount({ children, ...props }: ZonePileCountProps): react.ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+type ZonePileDescriptionProps = PrimitiveCommonProps & HTMLAttributes<HTMLElement>;
+declare function ZonePileDescription({ children, ...props }: ZonePileDescriptionProps): react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | null;
+interface ZonePileCardsProps extends Omit<ZoneListProps, "children"> {
+    renderCard: (card: ZoneCardRenderItem) => ReactNode;
+}
+declare function ZonePileCards({ renderCard, ...props }: ZonePileCardsProps): react_jsx_runtime.JSX.Element | null;
+declare function createZoneCardRenderItem(zone: string, snapshot: ZoneHandlesSnapshot | null, cardId: string, index: number): ZoneCardRenderItem;
+declare const Zone: {
+    Root: typeof ZoneRoot;
+    List: typeof ZoneList;
+    Item: typeof ZoneItem;
+    CardAt: typeof ZoneCardAt;
+    TopCard: typeof ZoneTopCard;
+    CardAction: typeof ZoneCardAction;
+    PileRoot: typeof ZonePileRoot;
+    PileTrigger: typeof ZonePileTrigger;
+    PileLabel: typeof ZonePileLabel;
+    PileCount: typeof ZonePileCount;
+    PileDescription: typeof ZonePileDescription;
+    PileCards: typeof ZonePileCards;
+    useZoneCards: typeof useZoneCards;
+};
+
+type BoardTargetKind = "edge" | "vertex" | "space" | "tile";
+
+interface InteractiveTargetState {
+    kind?: BoardTargetKind;
+    id: string;
+    eligible: boolean;
+    selectable: boolean;
+    hovered: boolean;
+    interactionKey?: string;
+    interactionId?: string;
+    inputKey?: string;
+    pending: boolean;
+    conflict: boolean;
+    conflictInteractionKeys?: readonly string[];
+    unavailableReason?: string;
+    select?: () => unknown | Promise<unknown>;
+}
+interface InteractiveTargetLayer {
+    enabled?: boolean;
+    eligible?: ReadonlySet<string>;
+    selectTargetId?: (targetId: string) => unknown | Promise<unknown>;
+    targetState?: (targetId: string) => Partial<InteractiveTargetState>;
+}
+
+type BoardEligibleTargets = Readonly<Record<BoardTargetKind, ReadonlySet<string>>>;
+interface BoardTargetLayerOptions {
+    enabled?: boolean;
+    interactionKeys?: readonly string[];
+    extraInputs?: Record<string, unknown> | ((targetId: string) => Record<string, unknown>);
+    onBeforeSelect?: () => void;
+    onError?: (error: unknown) => void;
+}
+type BoardTargetLayerFactory = (options?: BoardTargetLayerOptions) => InteractiveTargetLayer;
+type BoardSelectionResult<I extends string = string> = {
+    status: "none";
+} | {
+    status: "pending";
+    interactionKey: I;
+    descriptor: InteractionDescriptor<I>;
+    missingInputs: readonly string[];
+} | {
+    status: "submitted";
+    interactionKey: I;
+    descriptor: InteractionDescriptor<I>;
+};
+interface BoardPendingInteraction<I extends string = string> {
+    interactionKey: I;
+    descriptor: InteractionDescriptor<I>;
+    missingInputs: readonly string[];
+    clear(): void;
+}
+/**
+ * Opinionated board-level dispatch context. Collapses the repeated
+ * "collect every board handle, merge target domains across them,
+ * route each click into the right interaction" pattern that advanced
+ * board games (Catan-class) otherwise have to re-implement by hand.
+ */
+interface BoardInteractionsContext<I extends string = string> {
+    /**
+     * All board-surface interactions projected onto the controlling seat
+     * — both available and unavailable. Rendered greyed-out states can
+     * key off this even when the interaction isn't dispatchable yet.
+     */
+    interactions: ReadonlyArray<InteractionDescriptor<I>>;
+    /**
+     * Per-target-kind eligibility sets merged across every currently-
+     * available board interaction. `eligible.vertex` answers "which
+     * vertex ids can be clicked right now?" without the caller manually
+     * unioning descriptor eligibility across handles or knowing the
+     * authored input key.
+     */
+    eligible: BoardEligibleTargets;
+    /**
+     * True when `targetId` is eligible for at least one available
+     * interaction. Pass `kind` to scope the check to a specific
+     * board target kind.
+     */
+    isEligible(targetId: string, kind?: BoardTargetKind): boolean;
+    /**
+     * Target-kind dispatch. Routes by board geometry (`edge`, `vertex`,
+     * `space`, `tile`) rather than authored input-key strings.
+     */
+    pendingInteraction: BoardPendingInteraction<I> | null;
+    select: {
+        edge(targetId: string, extraInputs?: Record<string, unknown>): Promise<BoardSelectionResult<I>>;
+        vertex(targetId: string, extraInputs?: Record<string, unknown>): Promise<BoardSelectionResult<I>>;
+        space(targetId: string, extraInputs?: Record<string, unknown>): Promise<BoardSelectionResult<I>>;
+        tile(targetId: string, extraInputs?: Record<string, unknown>): Promise<BoardSelectionResult<I>>;
+    };
+    /**
+     * Reducer-aware target layers for board primitives. Pass these directly
+     * to grids so eligibility, dispatch, and submit error handling stay in
+     * one place instead of being re-wired per component.
+     */
+    targetLayers: {
+        edge: BoardTargetLayerFactory;
+        vertex: BoardTargetLayerFactory;
+        space: BoardTargetLayerFactory;
+        tile: BoardTargetLayerFactory;
+    };
+    targetState(targetKind: BoardTargetKind, targetId: string, options?: Pick<BoardTargetLayerOptions, "enabled" | "interactionKeys">): InteractiveTargetState;
+    selectTarget(descriptor: InteractionDescriptor<I>, targetKind: BoardTargetKind, targetId: string, inputKey: string, extraInputs?: Record<string, unknown>): Promise<BoardSelectionResult<I>>;
+}
+
+type BoardContextValue = BoardInteractionsContext;
+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;
+interface BoardStateProps {
+    children: (board: BoardInteractionsContext) => ReactNode;
+}
+declare function BoardState({ children }: BoardStateProps): react_jsx_runtime.JSX.Element;
+interface BoardHexViewProps<TBoard extends AnyHexBoardInput, TSpaceView extends {
+    id: BoardSpaceIdOf<TBoard>;
+}> {
+    board: TBoard;
+    spaces: readonly TSpaceView[];
+    children: (view: HexBoardView<TBoard, TSpaceView>) => ReactNode;
+}
+declare function BoardHexView<const TBoard extends AnyHexBoardInput, const TSpaceView extends {
+    id: BoardSpaceIdOf<TBoard>;
+}>({ board, spaces, children }: BoardHexViewProps<TBoard, TSpaceView>): react_jsx_runtime.JSX.Element;
+interface BoardHexGridInteractions {
+    edge?: BoardTargetLayerOptions;
+    vertex?: BoardTargetLayerOptions;
+    space?: BoardTargetLayerOptions;
+}
+type BoardHexGridInteractionFilter = "auto" | false | {
+    edge?: readonly string[];
+    vertex?: readonly string[];
+    space?: readonly string[];
+};
+type BoardHexGridView<TBoard extends AnyHexBoardInput, TSpaceView extends {
+    id: BoardSpaceIdOf<TBoard>;
+}> = HexBoardView<TBoard, TSpaceView> & AnyHexBoardInput;
+type BoardHexGridProps<TBoard extends AnyHexBoardInput, TSpaceView extends {
+    id: BoardSpaceIdOf<TBoard>;
+}> = Omit<HexGridBoardProps<BoardHexGridView<TBoard, TSpaceView>>, "board" | "interactiveEdges" | "interactiveVertices" | "interactiveSpaces"> & Omit<BoardHexViewProps<TBoard, TSpaceView>, "children"> & {
+    interactions?: BoardHexGridInteractionFilter;
+};
+declare function BoardHexGrid<const TBoard extends AnyHexBoardInput, const TSpaceView extends {
+    id: BoardSpaceIdOf<TBoard>;
+}>({ board, spaces, interactions, ...props }: BoardHexGridProps<TBoard, TSpaceView>): 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?: (result: BoardSelectionResult) => void;
+    onSelectError?: (error: unknown) => void;
+};
+declare function BoardTarget<Target extends string = BoardTargetKey>({ interaction, input, ...props }: BoardTargetProps<Target>): react_jsx_runtime.JSX.Element;
+type BoardSpaceTargetProps<Target extends string = BoardTargetKey> = Omit<BoardTargetProps<Target>, "kind">;
+declare function BoardSpaceTarget<Target extends string = BoardTargetKey>(props: BoardSpaceTargetProps<Target>): react_jsx_runtime.JSX.Element;
+type BoardEdgeTargetProps<Target extends string = BoardTargetKey> = Omit<BoardTargetProps<Target>, "kind">;
+declare function BoardEdgeTarget<Target extends string = BoardTargetKey>(props: BoardEdgeTargetProps<Target>): react_jsx_runtime.JSX.Element;
+type BoardVertexTargetProps<Target extends string = BoardTargetKey> = Omit<BoardTargetProps<Target>, "kind">;
+declare function BoardVertexTarget<Target extends string = BoardTargetKey>(props: BoardVertexTargetProps<Target>): react_jsx_runtime.JSX.Element;
+declare const Board: {
+    Root: typeof BoardRoot;
+    State: typeof BoardState;
+    HexGrid: typeof BoardHexGrid;
+    HexView: typeof BoardHexView;
+    Target: typeof BoardTarget;
+    SpaceTarget: typeof BoardSpaceTarget;
+    EdgeTarget: typeof BoardEdgeTarget;
+    VertexTarget: typeof BoardVertexTarget;
+};
+
+/**
+ * Hook to access plugin session metadata.
+ * Returns session initialization status and IDs.
+ *
+ * @returns Plugin session state with status, sessionId, controllablePlayerIds, and controllingPlayerId
+ *
+ * @example
+ * ```tsx
+ * function MyPluginComponent() {
+ *   const { status, sessionId, controllablePlayerIds, controllingPlayerId } = usePluginSession();
+ *
+ *   if (status === "loading") {
+ *     return <div>Initializing...</div>;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <p>Session: {sessionId}</p>
+ *       <p>Can control: {controllablePlayerIds.join(", ")}</p>
+ *       <p>Currently controlling: {controllingPlayerId}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function usePluginSession(): PluginSessionState;
+
+type GamePlayer<PlayerIdValue extends string = PlayerId> = Omit<Player, "playerId"> & {
+    playerId: PlayerIdValue;
+};
+type GamePlayerEntry<PlayerIdValue extends string = PlayerId> = GamePlayer<PlayerIdValue> & {
+    index: number;
+    isActive: boolean;
+    isCurrentPlayer: boolean;
+    isControllable: boolean;
+};
+interface GamePlayersState<PlayerIdValue extends string = PlayerId> {
+    byId: ReadonlyMap<PlayerIdValue, GamePlayer<PlayerIdValue>>;
+    order: readonly PlayerIdValue[];
+    entries: ReadonlyArray<GamePlayerEntry<PlayerIdValue>>;
+    active: readonly PlayerIdValue[];
+    current: GamePlayer<PlayerIdValue> | null;
+}
+interface GameMeState<PlayerIdValue extends string = PlayerId> {
+    playerId: PlayerIdValue | null;
+    player: GamePlayer<PlayerIdValue> | null;
+    controllablePlayerIds: readonly PlayerIdValue[];
+    canAct: boolean;
+}
+interface GameTurnState<PlayerIdValue extends string = PlayerId, PhaseValue extends string = string> {
+    phase: PhaseValue | null;
+    stage: string | null;
+    activePlayerIds: readonly PlayerIdValue[];
+    currentPlayerId: PlayerIdValue | null;
+    order: readonly PlayerIdValue[];
+    isMine: boolean;
+}
+interface GameRenderState<ViewValue = unknown, PlayerIdValue extends string = PlayerId, PhaseValue extends string = string> {
+    view: ViewValue;
+    phase: PhaseValue | null;
+    stage: string | null;
+    session: ReturnType<typeof usePluginSession>;
+    me: GameMeState<PlayerIdValue>;
+    turn: GameTurnState<PlayerIdValue, PhaseValue>;
+    players: GamePlayersState<PlayerIdValue>;
+}
+interface GamePendingInputState {
+    key: string;
+    kind: string;
+    domain: InputDomain;
+    title: string;
+}
+interface GameActiveActionState<Interaction extends string = string, Params extends Record<string, unknown> = Record<string, unknown>> {
+    interaction: Interaction;
+    interactionId: string;
+    descriptor: InteractionDescriptor<Interaction>;
+    title: string;
+    draft: Readonly<Partial<Params>>;
+    values: Partial<Params>;
+    missingInputs: readonly string[];
+    readyFrontier: readonly string[];
+    pendingInput: GamePendingInputState | null;
+}
+interface GameChromeState<ViewValue = unknown, PlayerIdValue extends string = PlayerId, PhaseValue extends string = string, Interaction extends string = string> extends GameRenderState<ViewValue, PlayerIdValue, PhaseValue> {
+    activePlayers: readonly PlayerIdValue[];
+    activeAction: GameActiveActionState<Interaction> | null;
+    cancel: (() => void) | null;
+}
+interface GameRootProps<ViewValue = unknown, PlayerIdValue extends string = PlayerId, PhaseValue extends string = string> {
+    onActionError?: (error: unknown) => void;
+    children: (state: GameRenderState<ViewValue, PlayerIdValue, PhaseValue>) => ReactNode;
+}
+interface GameChromeProps<ViewValue = unknown, PlayerIdValue extends string = PlayerId, PhaseValue extends string = string, Interaction extends string = string> {
+    children: (state: GameChromeState<ViewValue, PlayerIdValue, PhaseValue, Interaction>) => ReactNode;
+}
+type GameActionErrorHandler = (error: unknown) => void;
+declare function useGameActionError(): GameActionErrorHandler | null;
+declare function GameRoot<ViewValue = unknown, PlayerIdValue extends string = PlayerId, PhaseValue extends string = string>({ children, onActionError, }: GameRootProps<ViewValue, PlayerIdValue, PhaseValue>): react_jsx_runtime.JSX.Element;
+declare function GameChrome<ViewValue = unknown, PlayerIdValue extends string = PlayerId, PhaseValue extends string = string, Interaction extends string = string>({ children, }: GameChromeProps<ViewValue, PlayerIdValue, PhaseValue, Interaction>): react_jsx_runtime.JSX.Element;
+declare const Game: {
+    Root: typeof GameRoot;
+    Chrome: typeof GameChrome;
+};
+
+/**
+ * Anything that can be used as a submit params object. Subset of TS
+ * objects so generic defaults and `keyof Params & string` hold.
+ */
+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>;
+};
+/**
+ * Bound handle around an {@link InteractionDescriptor}. Surfaces call into
+ * this hook to submit/validate an interaction, track draft input state for
+ * multi-step prompts, and arm/disarm themselves on a surface.
+ *
+ * Availability flags are mirrored from the authoritative descriptor; UI
+ * MUST NOT recompute eligibility locally.
+ *
+ * When the surrounding workspace knows the concrete params shape (e.g.
+ * obtained from the generated `InteractionParamsOf<Id>` alias), parameterise
+ * this handle on `Params` so `submit`, `draft`, and `setInput` are all
+ * statically typed. The default `Record<string, unknown>` preserves the
+ * loosely-typed fallback for generic infrastructure.
+ */
+interface InteractionHandle<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never> {
+    descriptor: InteractionDescriptor;
+    /** Draft commit policy projected by the reducer. */
+    commit: InteractionDescriptor["commit"];
+    /**
+     * Submit the interaction. When `params` is omitted the current draft (as
+     * mutated by {@link InteractionHandle.setInput}) is used instead, which is
+     * the common case for multi-input prompts.
+     */
+    submit: (params?: Params) => Promise<void>;
+    /** Run server validation using `params` (or the current draft by default). */
+    validate: (params?: Params) => Promise<void>;
+    /** Run local generated client-schema validation against the current draft. */
+    validateDraft: () => DraftValidation<Params>;
+    /** Run server validation against the current draft. */
+    validateDraftServer: () => Promise<void>;
+    /**
+     * Validate the current draft locally, submit parsed params, then clear the
+     * draft only when submission succeeds.
+     */
+    submitDraft: () => Promise<void>;
+    /** Derived from `descriptor.availability`. */
+    available: boolean;
+    /** Derived from `descriptor.availability`. */
+    unavailableReason?: string;
+    /** Local/authoritative progress for this interaction. */
+    status: InteractionHandleStatus;
+    /** Live draft values for this interaction. Empty object when unset. */
+    draft: Readonly<Partial<Params>>;
+    /**
+     * Draft values with authored input defaults applied. Fields with declared
+     * defaults are typed as present; other draft fields remain partial.
+     */
+    values: Readonly<Partial<Params> & Pick<Params, DefaultedKeys>>;
+    /** Set a single input on the draft. */
+    setInput: <K extends keyof Params & string>(key: K, value: Params[K]) => void;
+    /** Clear a single input (or the whole draft when `key` is omitted). */
+    clearInput: (key?: keyof Params & string) => void;
+    /**
+     * True when every key declared on `descriptor.inputs` has a value in
+     * the draft. Falls back to `true` when the descriptor declares no inputs.
+     */
+    isReady: boolean;
+    /**
+     * True when this interaction is the currently armed one on its surface.
+     * Armed interactions are the ones that board primitives use
+     * to highlight eligible targets and route clicks.
+     */
+    isArmed: boolean;
+    /** Arm this interaction on its surface (disarms any previously armed). */
+    arm: () => void;
+    /** Disarm this interaction (if it was armed). */
+    disarm: () => void;
+}
+/**
+ * Bind an {@link InteractionDescriptor} to submit/validate helpers plus
+ * draft + arming state. Use this from any surface; draft state is shared
+ * across components through {@link InteractionUiProvider}, which
+ * `PluginRuntime` auto-mounts.
+ *
+ * Example:
+ * ```tsx
+ * const handle = useInteractionHandle(placeThing);
+ * handle.setInput("cardId", card.id);
+ * handle.setInput("ringId", ring.id);
+ * if (handle.isReady) await handle.submit();
+ * ```
+ */
+declare function useInteractionHandle<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never>(descriptor: InteractionDescriptor): InteractionHandle<Params, DefaultedKeys>;
+
+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 InteractionSlotComponentProps {
+    children?: ReactNode;
+}
+type InteractionButtonSlotProps = InteractionSlotComponentProps & Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children" | "disabled" | "type" | "value">;
+interface InteractionTargetSlotProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children" | "disabled" | "aria-disabled" | "aria-pressed" | "onClick" | "type" | "value"> {
+    value: string;
+    children?: ReactNode;
+}
+interface InteractionOptionsSlotProps {
+    children: (option: {
+        value: string | null;
+        label: string;
+    }) => ReactNode;
+}
+interface InteractionCardsSlotProps {
+    children: (card: {
+        id: string;
+    }) => ReactNode;
+}
+interface InteractionValueSlotProps {
+    children: (value: unknown) => ReactNode;
+}
+interface InteractionInputSlot {
+    Field: (props: InteractionSlotComponentProps) => ReactNode;
+    Default: (props: InteractionSlotComponentProps) => ReactNode;
+    Target: (props: InteractionTargetSlotProps) => ReactNode;
+    Card: (props: InteractionTargetSlotProps) => ReactNode;
+    Cards: (props: InteractionCardsSlotProps) => ReactNode;
+    Options: (props: InteractionOptionsSlotProps) => ReactNode;
+    Value: (props: InteractionValueSlotProps) => ReactNode;
+    Label: (props: InteractionSlotComponentProps) => ReactNode;
+    Message: (props: InteractionSlotComponentProps) => ReactNode;
+}
+type InteractionInputRenderMap = Record<string, (slot: InteractionInputSlot) => ReactNode>;
+interface InteractionSubmitSlot {
+    Button: (props: InteractionButtonSlotProps) => 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>;
+    inputs?: InteractionInputRenderMap;
+    submit?: (slot: InteractionSubmitSlot, descriptor: InteractionDescriptor) => ReactNode;
+    title?: ReactNode;
+    description?: ReactNode;
+    submitLabel?: ReactNode;
+    cancelLabel?: ReactNode;
+    onCancel?: () => void;
+    onSubmitSuccess?: () => void;
+    disabled?: boolean;
+    accordion?: boolean;
+    defaultOpen?: boolean;
+    style?: CSSProperties;
+}
+
+type BoundInteractionFormProps<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never> = Omit<InteractionFormProps<Params, DefaultedKeys>, "descriptor" | "handle">;
+
+interface InteractionSubmitCallbacks {
+    onSubmitSuccess?: () => void;
+    onSubmitError?: (error: unknown) => void;
+}
+
+type DialogLifecycleState = "open" | "minimized" | "dismissed";
+
+interface InteractionContextValue {
+    interaction: string;
+    descriptor: InteractionDescriptor | null;
+    handle: ReturnType<typeof useInteractionHandle> | null;
+}
+declare function useInteractionPrimitiveContext(): InteractionContextValue;
+/**
+ * Live draft value for the active interaction's card-target input, resolved
+ * from the surrounding `<Interaction.Root>`. Returns the selected card-id array
+ * for `selection: "many"` inputs and the single id for `selection: "one"`.
+ * Returns `undefined` when there is no interaction context or no card-target
+ * input (so it is safe to render outside a root). Reactive: `handle.values`
+ * updates as the draft changes. Backs the card surface `slot.card.Value`.
+ */
+declare function useResolvedCardTargetValue(): unknown;
+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 InteractionDialogState = DialogLifecycleState;
+interface InteractionDialogRenderState<Interaction extends string = InteractionKey> {
+    interaction: Interaction;
+    state: InteractionDialogState;
+    open: boolean;
+    minimized: boolean;
+    dismissed: boolean;
+    setOpen: (open: boolean) => void;
+    restore: () => void;
+    minimize: () => void;
+    dismiss: () => void;
+}
+interface InteractionDialogProps<Interaction extends string = InteractionKey> {
+    defaultOpen?: boolean;
+    onStateChange?: (state: InteractionDialogState) => void;
+    children: (state: InteractionDialogRenderState<Interaction>) => ReactNode;
+}
+declare function InteractionDialog<Interaction extends string = InteractionKey>({ defaultOpen, onStateChange, children, }: InteractionDialogProps<Interaction>): react_jsx_runtime.JSX.Element;
+interface InteractionSwitchRenderState<Interaction extends string = InteractionKey> {
+    interaction: Interaction;
+    descriptor: InteractionDescriptor<Interaction>;
+}
+type InteractionSwitchRouteMap<Interaction extends string = InteractionKey> = {
+    [Key in Interaction]?: (state: InteractionSwitchRenderState<Key>) => ReactNode;
+};
+interface InteractionRoute {
+    readonly collect: Record<string, unknown>;
+}
+type InteractionRoutesMap<Interaction extends string = InteractionKey> = {
+    [Key in Interaction]: InteractionRoute;
+};
+interface InteractionSwitchProps<Interaction extends string = InteractionKey> {
+    interaction?: Interaction;
+    routes: InteractionSwitchRouteMap<Interaction>;
+    fallback?: ReactNode;
+}
+declare function InteractionSwitch<Interaction extends string = InteractionKey>({ interaction, routes, fallback, }: InteractionSwitchProps<Interaction>): react_jsx_runtime.JSX.Element;
+interface InteractionRoutesProps<Interaction extends string = InteractionKey> {
+    routes: InteractionRoutesMap<Interaction>;
+    fallback?: ReactNode;
+    includeUnavailable?: boolean | null;
+}
+declare function InteractionRoutes<Interaction extends string = InteractionKey>({ routes, fallback, includeUnavailable, }: InteractionRoutesProps<Interaction>): react_jsx_runtime.JSX.Element | null;
+type InteractionPartProps = PrimitiveCommonProps & HTMLAttributes<HTMLElement>;
+declare function InteractionLabel({ children, ...props }: InteractionPartProps): react.ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+declare function InteractionDescription({ children, ...props }: InteractionPartProps): react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | null;
+declare function InteractionUnavailableMessage({ children, ...props }: InteractionPartProps): react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | null;
+declare function InteractionValidationMessage({ children, ...props }: InteractionPartProps): react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | null;
+type InteractionTriggerProps = PrimitiveCommonProps & ButtonHTMLAttributes<HTMLButtonElement>;
+declare function InteractionTrigger({ disabled, onClick, ...props }: InteractionTriggerProps): react.ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+interface InteractionStateSnapshot<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never> {
+    interaction: string;
+    descriptor: InteractionDescriptor;
+    handle: InteractionHandle<Params, DefaultedKeys>;
+    draft: InteractionHandle<Params, DefaultedKeys>["draft"];
+    values: InteractionHandle<Params, DefaultedKeys>["values"];
+    status: InteractionHandle<Params, DefaultedKeys>["status"];
+    available: boolean;
+    isReady: boolean;
+    isArmed: boolean;
+    inputKeys: readonly string[];
+    missingInputs: readonly string[];
+    readyFrontier: readonly string[];
+    blockedInputs: readonly string[];
+    hasInputs: boolean;
+}
+interface InteractionStateProps<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never> {
+    unavailable: ReactNode;
+    children: (state: InteractionStateSnapshot<Params, DefaultedKeys>) => ReactNode;
+}
+declare function InteractionState<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never>({ children, unavailable }: InteractionStateProps<Params, DefaultedKeys>): react_jsx_runtime.JSX.Element;
+type InteractionFormPrimitiveProps<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never> = BoundInteractionFormProps<Params, DefaultedKeys>;
+declare function InteractionFormPrimitive<Params extends InteractionParamsShape = InteractionParamsShape, DefaultedKeys extends keyof Params & string = never>(props: InteractionFormPrimitiveProps<Params, DefaultedKeys>): react_jsx_runtime.JSX.Element | null;
+type InteractionFieldPrimitiveProps<Params extends InteractionParamsShape = InteractionParamsShape, Input extends keyof Params & string = keyof Params & string> = Omit<InteractionFieldProps<Params, Input>, "descriptor" | "handle" | "inputKey"> & {
+    input: Input;
+};
+declare function InteractionFieldPrimitive<Params extends InteractionParamsShape = InteractionParamsShape, Input extends keyof Params & string = keyof Params & string>({ input, ...props }: InteractionFieldPrimitiveProps<Params, Input>): react_jsx_runtime.JSX.Element | null;
+type InteractionSubmitProps = PrimitiveCommonProps & ButtonHTMLAttributes<HTMLButtonElement> & {
+    params?: InteractionParamsShape | (() => InteractionParamsShape | null | undefined);
+    onSubmitSuccess?: InteractionSubmitCallbacks["onSubmitSuccess"];
+    onSubmitError?: InteractionSubmitCallbacks["onSubmitError"];
+};
+declare function InteractionSubmit({ disabled, onClick, params, onSubmitSuccess, onSubmitError, ...props }: InteractionSubmitProps): react.ReactElement<unknown, string | react.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.ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+type InteractionCardInputProps<Input extends string = InteractionInputKey> = PrimitiveCommonProps & Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children"> & {
+    input: Input;
+    unsafeCardId?: string;
+    selected?: boolean;
+    onSelectedChange?: (selected: boolean) => void;
+    children?: ReactNode | ((state: InteractionCardInputRenderState) => ReactNode);
+};
+interface InteractionCardInputRenderState {
+    cardId: string | undefined;
+    zone: string | undefined;
+    selected: boolean;
+    disabled: boolean;
+    eligible: boolean;
+    targetValid: boolean;
+    selectable: boolean;
+    cardAvailable: boolean;
+    invalid: boolean;
+}
+declare function InteractionCardInput<Input extends string = InteractionInputKey>({ input, unsafeCardId, selected, onSelectedChange, onClick, disabled, children, ...props }: InteractionCardInputProps<Input>): react.ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+declare const Interaction: {
+    Root: typeof InteractionRoot;
+    State: typeof InteractionState;
+    Switch: typeof InteractionSwitch;
+    Routes: typeof InteractionRoutes;
+    Dialog: typeof InteractionDialog;
+    Trigger: typeof InteractionTrigger;
+    Label: typeof InteractionLabel;
+    Description: typeof InteractionDescription;
+    UnavailableMessage: typeof InteractionUnavailableMessage;
+    ValidationMessage: typeof InteractionValidationMessage;
+    Input: typeof InteractionInput;
+    Field: typeof InteractionFieldPrimitive;
+    CardInput: typeof InteractionCardInput;
+    Form: typeof InteractionFormPrimitive;
+    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;
+    name: string;
+    color?: HexColor;
+    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) => number | undefined;
+    scoreLabel?: string | ((playerId: PlayerId) => string | undefined);
+    badges?: (playerId: PlayerId) => ReadonlyArray<PlayerRosterBadge | null | false | undefined>;
+    metadata?: (playerId: PlayerId) => 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.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.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.JSXElementConstructor<any>>;
+declare function PlayerRosterScore({ player, children, ...props }: PlayerRosterPartProps): ReactElement<unknown, string | react.JSXElementConstructor<any>> | null;
+declare function PlayerRosterBadges({ player, children, ...props }: PlayerRosterPartProps): ReactElement<unknown, string | react.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?: InteractionSubmitCallbacks["onSubmitError"];
+    onSubmitSuccess?: InteractionSubmitCallbacks["onSubmitSuccess"];
+};
+declare function PromptOption<Option extends string = PromptOptionKey>({ value, disabled, disableWhenUnavailable, onClick, onSubmitError, onSubmitSuccess, children, ...props }: PromptOptionProps<Option>): react.ReactElement<unknown, string | react.JSXElementConstructor<any>>;
+interface PromptOptionRenderItem {
+    id: string;
+    label?: string;
+}
+interface PromptOptionsProps {
+    children: (option: PromptOptionRenderItem) => ReactNode;
+}
+declare function PromptOptions({ children }: PromptOptionsProps): react_jsx_runtime.JSX.Element;
+type PromptDialogState = DialogLifecycleState;
+interface PromptDialogRenderState<Prompt extends string = PromptKey> {
+    prompt: Prompt;
+    state: PromptDialogState;
+    open: boolean;
+    minimized: boolean;
+    dismissed: boolean;
+    setOpen: (open: boolean) => void;
+    restore: () => void;
+    minimize: () => void;
+    dismiss: () => void;
+}
+interface PromptDialogProps<Prompt extends string = PromptKey> {
+    prompt: Prompt;
+    defaultOpen?: boolean;
+    onStateChange?: (state: PromptDialogState) => void;
+    children: (state: PromptDialogRenderState<Prompt>) => ReactNode;
+}
+declare function PromptDialog<Prompt extends string = PromptKey>({ prompt, defaultOpen, onStateChange, children, }: PromptDialogProps<Prompt>): 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;
+interface PromptInboxItemsProps {
+    children: (prompt: InteractionDescriptor) => ReactNode;
+}
+declare function PromptInboxItems({ children }: PromptInboxItemsProps): react_jsx_runtime.JSX.Element;
+declare const Prompt: {
+    Root: typeof PromptRoot;
+    Title: typeof PromptTitle;
+    Message: typeof PromptMessage;
+    Option: typeof PromptOption;
+    Options: typeof PromptOptions;
+    Dialog: typeof PromptDialog;
+};
+declare const PromptInbox: {
+    Root: typeof PromptInboxRoot;
+    Empty: typeof PromptInboxEmpty;
+    Items: typeof PromptInboxItems;
+};
+
+type DiceValue = number | null | undefined;
+interface DiceState {
+    values: ReadonlyArray<number | undefined> | undefined;
+    /** Undefined if any die has not been rolled yet. */
+    sum: number | undefined;
+    diceCount: number;
+    allRolled: boolean;
+}
+interface DiceRootProps {
+    values?: readonly DiceValue[] | null;
+    /** Used when values are not provided. */
+    count?: number;
+    children: ReactNode;
+}
+interface DiceValuesProps {
+    children: (state: DiceState) => ReactNode;
+}
+interface DiceComponents {
+    Root(props: DiceRootProps): ReactNode;
+    Values(props: DiceValuesProps): ReactNode;
+}
+declare function normalizeDiceState({ values, count, }: {
+    values?: readonly DiceValue[] | null;
+    count?: number;
+}): DiceState;
+declare function DiceRoot({ values, count, children }: DiceRootProps): react_jsx_runtime.JSX.Element;
+declare function useDicePrimitiveContext(): DiceState;
+declare function DiceValues({ children }: DiceValuesProps): ReactNode;
+declare const Dice: DiceComponents;
+
+/**
+ * Workspace-aware UI typing extension point.
+ *
+ * Generated workspaces will augment this interface with their concrete UI
+ * contract. The unregistered SDK keeps all public keys string-compatible so
+ * package-local tests and generic consumers can still import ui-sdk directly.
+ */
+interface DreamboardUIRegister {
+}
+type UIContractBucket = Record<string, unknown>;
+interface UIContract {
+    interactions?: UIContractBucket;
+    inputs?: UIContractBucket;
+    prompts?: UIContractBucket;
+    promptOptions?: UIContractBucket;
+    players?: 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 StringKeyOf<Bucket extends UIContractBucket> = Extract<keyof Bucket, string>;
+type StringKeysOrFallback<Bucket extends UIContractBucket> = [
+    StringKeyOf<Bucket>
+] extends [never] ? string : string extends StringKeyOf<Bucket> ? string : StringKeyOf<Bucket>;
+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 PlayerKey<Contract extends UIContract = RegisteredUI> = StringKeysOrFallback<BucketOf<Contract, "players">>;
+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 TypedZoneCardRenderItem<Contract extends UIContract> = ZoneCardRenderItem<CardKey<Contract> & string> extends infer Item ? Item extends {
+    id: string;
+    zone: string;
+} ? Omit<Item, "id" | "zone"> & {
+    id: CardKey<Contract>;
+    zone: ZoneKey<Contract>;
+} : never : never;
+type TypedInteraction<Contract extends UIContract> = Omit<typeof Interaction, "Root" | "CardInput" | "Dialog" | "Field" | "Form" | "Switch"> & {
+    Root<Interaction extends InteractionKey<Contract>>(props: InteractionRootProps<Interaction>): ReactElement | null;
+    Switch(props: Omit<InteractionSwitchProps<InteractionKey<Contract>>, "routes"> & {
+        routes: InteractionSwitchRouteMap<InteractionKey<Contract>>;
+    }): ReactElement;
+    Routes(props: Omit<InteractionRoutesProps<InteractionKey<Contract>>, "routes"> & {
+        routes: InteractionRoutesMap<InteractionKey<Contract>>;
+    }): ReactElement;
+    CardInput<Input extends InteractionInputKey<Contract>>(props: Omit<InteractionCardInputProps, "input" | "unsafeCardId"> & {
+        input: Input;
+        unsafeCardId?: CardKey<Contract>;
+    }): ReactElement;
+    Dialog<Interaction extends InteractionKey<Contract>>(props: InteractionDialogProps<Interaction>): ReactElement;
+    Field<Input extends InteractionInputKey<Contract>>(props: Omit<InteractionFieldPrimitiveProps, "input"> & {
+        input: Input;
+    }): ReactElement | null;
+    Form(props: InteractionFormPrimitiveProps): ReactElement | null;
+};
+type TypedPrompt<Contract extends UIContract> = Omit<typeof Prompt, "Root" | "Option" | "Options" | "Dialog"> & {
+    Root<Prompt extends PromptKey<Contract>>(props: PromptRootProps<Prompt>): ReactElement | null;
+    Option<Option extends PromptOptionKey<Contract>>(props: Omit<PromptOptionProps, "value"> & {
+        value: Option;
+    }): ReactElement;
+    Options(props: Omit<PromptOptionsProps, "children"> & {
+        children: (option: Omit<PromptOptionRenderItem, "id"> & {
+            id: PromptOptionKey<Contract>;
+        }) => ReactNode;
+    }): ReactElement;
+    Dialog<Prompt extends PromptKey<Contract>>(props: PromptDialogProps<Prompt>): ReactElement;
+};
+type TypedPromptInbox<Contract extends UIContract> = Omit<typeof PromptInbox, "Items"> & {
+    Items(props: Omit<PromptInboxItemsProps, "children"> & {
+        children: (prompt: Omit<InteractionDescriptor, "interactionKey"> & {
+            interactionKey: PromptKey<Contract>;
+        }) => ReactNode;
+    }): ReactElement;
+};
+type TypedPlayerRosterEntry<Player extends string> = Omit<PlayerRosterEntry, "playerId"> & {
+    playerId: Player;
+};
+type TypedPlayerRosterRootProps<Player extends string> = Omit<PlayerRosterRootProps, "score" | "scoreLabel" | "badges" | "metadata"> & {
+    score?: (playerId: Player) => number | undefined;
+    scoreLabel?: string | ((playerId: Player) => string | undefined);
+    badges?: (playerId: Player) => ReadonlyArray<PlayerRosterBadge | null | false | undefined>;
+    metadata?: (playerId: Player) => Record<string, unknown> | undefined;
+};
+type TypedPlayerRosterListProps<Player extends string> = Omit<PlayerRosterListProps, "children"> & {
+    children?: (player: TypedPlayerRosterEntry<Player>) => ReactNode;
+};
+type TypedPlayerRosterPartProps<Player extends string> = Omit<PlayerRosterPartProps, "player"> & {
+    player: TypedPlayerRosterEntry<Player>;
+};
+type TypedPlayerRosterSwitchButtonProps<Player extends string> = Omit<PlayerRosterSwitchButtonProps, "player"> & {
+    player: TypedPlayerRosterEntry<Player>;
+};
+type TypedPlayerRoster<Contract extends UIContract> = Omit<PlayerRosterComponents, "Root" | "List" | "SwitchButton" | "Name" | "Score" | "Badges"> & {
+    Root(props: TypedPlayerRosterRootProps<PlayerKey<Contract>>): ReactElement | null;
+    List(props: TypedPlayerRosterListProps<PlayerKey<Contract>>): ReactElement;
+    SwitchButton(props: TypedPlayerRosterSwitchButtonProps<PlayerKey<Contract>>): ReactElement;
+    Name(props: TypedPlayerRosterPartProps<PlayerKey<Contract>>): ReactElement;
+    Score(props: TypedPlayerRosterPartProps<PlayerKey<Contract>>): ReactElement | null;
+    Badges(props: TypedPlayerRosterPartProps<PlayerKey<Contract>>): ReactElement | null;
+};
+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" | "Item" | "CardAt" | "TopCard" | "CardAction" | "List" | "PileRoot" | "PileCards"> & {
+    Root<Zone extends ZoneKey<Contract>>(props: Omit<ZoneRootProps, "zone"> & {
+        zone: Zone;
+    }): ReactElement;
+    Item<Card extends CardKey<Contract>>(props: Omit<ZoneItemProps, "card"> & {
+        card: Card;
+    }): ReactElement;
+    CardAction<Card extends CardKey<Contract>>(props: Omit<ZoneCardActionProps, "card"> & {
+        card?: Card;
+    }): ReactElement;
+    CardAt<Zone extends ZoneKey<Contract>>(props: Omit<ZoneCardAtProps<Zone>, "zone" | "children"> & {
+        zone?: Zone;
+        children?: ReactNode | ((card: TypedZoneCardRenderItem<Contract>) => ReactNode);
+    }): ReactElement | null;
+    TopCard<Zone extends ZoneKey<Contract>>(props: Omit<ZoneCardAtProps<Zone>, "zone" | "index" | "children"> & {
+        zone?: Zone;
+        children?: ReactNode | ((card: TypedZoneCardRenderItem<Contract>) => ReactNode);
+    }): ReactElement | null;
+    List(props: Omit<ZoneListProps, "children"> & {
+        children?: ReactNode | ((card: TypedZoneCardRenderItem<Contract>) => ReactNode);
+    }): ReactElement;
+    PileRoot<Zone extends ZoneKey<Contract>>(props: Omit<ZonePileRootProps<Zone>, "zone"> & {
+        zone: Zone;
+    }): ReactElement;
+    PileCards(props: Omit<ZonePileCardsProps, "renderCard"> & {
+        renderCard: (card: TypedZoneCardRenderItem<Contract>) => ReactNode;
+    }): ReactElement | null;
+};
+type TypedBoard<Contract extends UIContract> = Omit<typeof Board, "Target" | "SpaceTarget" | "EdgeTarget" | "VertexTarget" | "HexGrid"> & {
+    Target<Target extends BoardTargetKey<Contract>>(props: Omit<BoardTargetProps, "value"> & {
+        value: Target;
+    }): ReactElement;
+    SpaceTarget<Target extends BoardTargetKey<Contract>>(props: Omit<BoardSpaceTargetProps, "value"> & {
+        value: Target;
+    }): ReactElement;
+    EdgeTarget<Target extends BoardTargetKey<Contract>>(props: Omit<BoardEdgeTargetProps, "value"> & {
+        value: Target;
+    }): ReactElement;
+    VertexTarget<Target extends BoardTargetKey<Contract>>(props: Omit<BoardVertexTargetProps, "value"> & {
+        value: Target;
+    }): ReactElement;
+    HexGrid<TBoard extends AnyHexBoardInput, TSpaceView extends {
+        id: BoardSpaceIdOf<TBoard>;
+    }>(props: Omit<BoardHexGridProps<TBoard, TSpaceView>, "interactions"> & {
+        interactions?: Exclude<BoardHexGridInteractionFilter, object> | {
+            edge?: ReadonlyArray<InteractionKey<Contract>>;
+            vertex?: ReadonlyArray<InteractionKey<Contract>>;
+            space?: ReadonlyArray<InteractionKey<Contract>>;
+        };
+    }): ReactElement;
+};
+type TypedGame<_Contract extends UIContract, View = unknown, Player extends string = PlayerKey<_Contract>, Phase extends string = PhaseKey<_Contract>> = Omit<typeof Game, "Root"> & {
+    Root(props: GameRootProps<View, Player, Phase>): ReactElement;
+    Chrome(props: GameChromeProps<View, Player, Phase, InteractionKey<_Contract>>): ReactElement;
+};
+interface DreamboardUI<Contract extends UIContract = RegisteredUI> {
+    readonly contract: Contract;
+    Root(props: UIRootProps): ReactElement;
+    readonly Game: TypedGame<Contract>;
+    readonly Interaction: TypedInteraction<Contract>;
+    readonly Prompt: TypedPrompt<Contract>;
+    readonly PromptInbox: TypedPromptInbox<Contract>;
+    readonly PlayerRoster: TypedPlayerRoster<Contract>;
+    readonly Dice: DiceComponents;
+    readonly Phase: TypedPhase<Contract>;
+    readonly Zone: TypedZone<Contract>;
+    readonly Board: TypedBoard<Contract>;
+}
+
+export { InteractionFormPrimitive as $, type DreamboardUI as A, Board as B, type GameActiveActionState as C, Dice as D, GameChrome as E, type GameChromeProps as F, Game as G, type GameChromeState as H, type GameMeState as I, type GamePendingInputState as J, type GamePlayer as K, type GamePlayerEntry as L, type GamePlayersState as M, type GameRenderState as N, GameRoot as O, type GameRootProps as P, type GameTurnState as Q, Interaction as R, InteractionCardInput as S, type InteractionCardInputProps as T, type InteractionCardInputRenderState as U, InteractionDescription as V, InteractionDialog as W, type InteractionDialogProps as X, type InteractionDialogRenderState as Y, type InteractionDialogState as Z, type InteractionFieldPrimitiveProps as _, BoardEdgeTarget as a, type PromptRootProps as a$, type InteractionFormPrimitiveProps as a0, InteractionInput as a1, type InteractionInputProps as a2, InteractionLabel as a3, type InteractionPartProps as a4, InteractionRoot as a5, type InteractionRootProps as a6, type InteractionRoute as a7, InteractionRoutes as a8, type InteractionRoutesMap as a9, type PlayerRosterListProps as aA, PlayerRosterName as aB, type PlayerRosterPartProps as aC, PlayerRosterRoot as aD, type PlayerRosterRootProps as aE, PlayerRosterScore as aF, PlayerRosterSwitchButton as aG, type PlayerRosterSwitchButtonProps as aH, type PrimitiveCommonProps as aI, type PrimitiveDataAttributes as aJ, Prompt as aK, PromptDialog as aL, type PromptDialogProps as aM, type PromptDialogRenderState as aN, type PromptDialogState as aO, PromptInbox as aP, PromptInboxEmpty as aQ, PromptInboxItems as aR, type PromptInboxItemsProps as aS, PromptInboxRoot as aT, PromptMessage as aU, PromptOption as aV, type PromptOptionProps as aW, type PromptOptionRenderItem as aX, PromptOptions as aY, type PromptOptionsProps as aZ, PromptRoot as a_, type InteractionRoutesProps as aa, InteractionState as ab, type InteractionStateProps as ac, type InteractionStateSnapshot as ad, InteractionSubmit as ae, type InteractionSubmitProps as af, InteractionSwitch as ag, type InteractionSwitchProps as ah, type InteractionSwitchRenderState as ai, type InteractionSwitchRouteMap as aj, InteractionTrigger as ak, type InteractionTriggerProps as al, InteractionUnavailableMessage as am, InteractionValidationMessage as an, Phase as ao, type PhaseFallback as ap, type PhaseRouteMap as aq, PhaseSwitch as ar, type PhaseSwitchProps as as, PlayerRoster as at, type PlayerRosterBadge as au, PlayerRosterBadges as av, type PlayerRosterComponents as aw, PlayerRosterEmpty as ax, type PlayerRosterEntry as ay, PlayerRosterList as az, type BoardEdgeTargetProps as b, PromptTitle as b0, type TypedGame as b1, UI as b2, type UIContract as b3, UIRoot as b4, type UIRootProps as b5, type UseZoneCardsOptions as b6, type UseZoneCardsResult as b7, Zone as b8, ZoneCardAction as b9, type ZoneTopCardProps as bA, composeEventHandlers as bB, createZoneCardRenderItem as bC, normalizeDiceState as bD, renderPrimitive as bE, useBoardPrimitiveContext as bF, useDicePrimitiveContext as bG, useGameActionError as bH, useInteractionPrimitiveContext as bI, useOptionalZonePrimitiveContext as bJ, useResolvedCardTargetValue as bK, useZoneCardContext as bL, useZoneCards as bM, useZonePileContext as bN, useZonePrimitiveContext as bO, type ZoneCardActionExtraInputs as ba, type ZoneCardActionProps as bb, type ZoneCardActionResult as bc, ZoneCardAt as bd, type ZoneCardAtProps as be, type ZoneCardRenderItem as bf, ZoneItem as bg, type ZoneItemProps as bh, ZoneList as bi, type ZoneListProps as bj, ZonePileCards as bk, type ZonePileCardsProps as bl, type ZonePileContextValue as bm, ZonePileCount as bn, type ZonePileCountProps as bo, ZonePileDescription as bp, type ZonePileDescriptionProps as bq, ZonePileLabel as br, type ZonePileLabelProps as bs, ZonePileRoot as bt, type ZonePileRootProps as bu, ZonePileTrigger as bv, type ZonePileTriggerProps as bw, ZoneRoot as bx, type ZoneRootProps as by, ZoneTopCard as bz, BoardHexGrid as c, type BoardHexGridInteractionFilter as d, type BoardHexGridInteractions as e, type BoardHexGridProps as f, BoardHexView as g, type BoardHexViewProps as h, BoardRoot as i, type BoardRootProps as j, BoardSpaceTarget as k, type BoardSpaceTargetProps as l, BoardState as m, type BoardStateProps as n, BoardTarget as o, type BoardTargetExtraInputs as p, type BoardTargetProps as q, BoardVertexTarget as r, type BoardVertexTargetProps as s, type DiceComponents as t, DiceRoot as u, type DiceRootProps as v, type DiceState as w, type DiceValue as x, DiceValues as y, type DiceValuesProps as z };