@almadar/ui 5.105.0 → 5.107.0

package/dist/components/game/2d/organisms/SimulatorBoard.d.ts

@@ -1,58 +0,0 @@
-/**
- * SimulatorBoard
- *
- * Parameter-slider game board. The player adjusts two parameters (A and B)
- * and observes the machine-derived output. Correct parameter values must
- * bring the output within tolerance of the target to win.
- *
- * Good for: physics, economics, system design stories.
- *
- * Controlled-only: params, output, attempts, and result are owned by the
- * gameplay machine and read off the bound entity. Slider/check/play-again
- * interactions are emitted as events; the machine recomputes and re-renders.
- */
-import React from 'react';
-import type { EventEmit, EntityRow, Asset } from '@almadar/core';
-import type { DisplayStateProps } from '../../../core/organisms/types';
-/** A tunable simulation parameter slider descriptor (UI value DTO read off the entity). */
-export interface SimulatorParameter {
-    id: string;
-    label: string;
-    unit: string;
-    min: number;
-    max: number;
-    step: number;
-    initial: number;
-    correct: number;
-    tolerance: number;
-}
-export interface SimulatorBoardProps extends DisplayStateProps {
-    /** Puzzle board-state entity (single row or array). The board reads the
-     *  `parameters` slider descriptors plus the machine-owned `paramA`/`paramB`/
-     *  `output`/`target`/`tolerance`/`attempts`/`result` fields off the row. */
-    entity?: EntityRow | readonly EntityRow[];
-    completeEvent?: EventEmit<{
-        success: boolean;
-        attempts: number;
-    }>;
-    /** Emits UI:{setAEvent} with { value } when parameter A's slider changes. */
-    setAEvent?: EventEmit<{
-        value: number;
-    }>;
-    /** Emits UI:{setBEvent} with { value } when parameter B's slider changes. */
-    setBEvent?: EventEmit<{
-        value: number;
-    }>;
-    /** Emits UI:{checkEvent} with {} on simulate / check. */
-    checkEvent?: EventEmit<Record<string, never>>;
-    /** Emits UI:{playAgainEvent} with {} on reset / play again. */
-    playAgainEvent?: EventEmit<Record<string, never>>;
-    /** Optional per-semantic-key asset overrides for icons (correct/incorrect/play/reset). */
-    assetManifest?: {
-        ui?: Record<string, Asset>;
-    };
-}
-export declare function SimulatorBoard({ entity, completeEvent, setAEvent, setBEvent, checkEvent, playAgainEvent, assetManifest, className, }: SimulatorBoardProps): React.JSX.Element | null;
-export declare namespace SimulatorBoard {
-    var displayName: string;
-}

package/dist/components/game/2d/organisms/StateArchitectBoard.d.ts

@@ -1,61 +0,0 @@
-/**
- * StateArchitectBoard Organism
- *
- * Contains ALL game logic for the State Architect tier (ages 13+).
- * Kids design state machines via a visual graph editor, then run
- * them to see if the behavior matches the puzzle goal.
- *
- * @packageDocumentation
- */
-import React from 'react';
-import type { EventEmit, EntityRow } from '@almadar/core';
-import type { DisplayStateProps } from '../../../core/organisms/types';
-/** A kid-built transition in the visual graph editor (UI value DTO). */
-export interface StateArchitectTransition {
-    id: string;
-    from: string;
-    to: string;
-    event: string;
-    guardHint?: string;
-}
-/** A puzzle test case (UI value DTO). */
-export interface TestCase {
-    /** Sequence of events to fire */
-    events: string[];
-    /** Expected final state */
-    expectedState: string;
-    /** Description */
-    label: string;
-}
-export interface StateArchitectBoardProps extends DisplayStateProps {
-    /** Puzzle board-state entity (single row or array). The board reads
-     *  `variables` / `states` / `transitions` / `testCases` etc. off the row. */
-    entity?: EntityRow | readonly EntityRow[];
-    /** Playback speed */
-    stepDurationMs?: number;
-    /** Emits UI:{testEvent} */
-    testEvent?: EventEmit<Record<string, never>>;
-    /** Emits UI:{completeEvent} with { success, passedTests } */
-    completeEvent?: EventEmit<{
-        success: boolean;
-        passedTests: number;
-    }>;
-    /** Emits UI:{addTransitionEvent} — lolo handles ADD_TRANSITION */
-    addTransitionEvent?: EventEmit<{
-        id: string;
-        from: string;
-        to: string;
-        event: string;
-    }>;
-    /** Emits UI:{removeTransitionEvent} — lolo handles REMOVE_TRANSITION */
-    removeTransitionEvent?: EventEmit<{
-        id: string;
-    }>;
-    /** Emits UI:{playAgainEvent} — lolo handles PLAY_AGAIN */
-    playAgainEvent?: EventEmit<Record<string, never>>;
-}
-export declare function StateArchitectBoard({ entity, stepDurationMs, testEvent, completeEvent, addTransitionEvent, removeTransitionEvent, playAgainEvent, className, }: StateArchitectBoardProps): React.JSX.Element | null;
-export declare namespace StateArchitectBoard {
-    var displayName: string;
-}
-export default StateArchitectBoard;

package/dist/components/game/3d/atoms/EventMarker3D.d.ts

@@ -1,17 +0,0 @@
-/**
- * EventMarker3D
- *
- * Floating combat/feedback marker for one `GameEvent` — billboarded text above
- * the cell. Lifetime is LOLO-owned: boards append events on actions and expire
- * them in their tick (same contract as the 2D effects array).
- *
- * @packageDocumentation
- */
-import React from 'react';
-import type { GameEvent } from '../molecules/GameCanvas3D';
-export interface EventMarker3DProps {
-    event: GameEvent;
-    position: [number, number, number];
-}
-export declare function EventMarker3D({ event, position }: EventMarker3DProps): React.JSX.Element;
-export default EventMarker3D;

package/dist/components/game/3d/molecules/FeatureMesh3D.d.ts

@@ -1,21 +0,0 @@
-/**
- * FeatureMesh3D
- *
- * Default feature renderer for GameCanvas3D. GLB model when resolved (tinted
- * via `feature.color`); otherwise a procedural tree or rock primitive using
- * the `game3dTheme` default palette.
- *
- * @packageDocumentation
- */
-import React from 'react';
-import type { Asset } from '@almadar/core';
-import type { IsometricFeature } from '../../shared/isometricTypes';
-import type { MinimalMouseEvent } from '../../shared/hooks/useGameCanvas3DEvents';
-export interface FeatureMesh3DProps {
-    feature: IsometricFeature;
-    position: [number, number, number];
-    model?: Asset;
-    onFeatureClick: (feature: IsometricFeature, event: MinimalMouseEvent | null) => void;
-}
-export declare function FeatureMesh3D({ feature, position, model, onFeatureClick, }: FeatureMesh3DProps): React.JSX.Element | null;
-export default FeatureMesh3D;

package/dist/components/game/3d/molecules/GameCanvas3D.d.ts

@@ -1,259 +0,0 @@
-/**
- * GameCanvas3D
- *
- * 3D game canvas component using Three.js.
- * Mirrors the IsometricCanvas API for easy migration.
- *
- * **State categories (closed-circuit compliant):**
- * - All game data (tiles, units, features, selection, validMoves) → received via props
- * - Rendering state (hoveredTile, internalError, asset loading, camera) → local only
- * - Events → emitted via `useGameCanvas3DEvents()` hook for trait integration
- *
- * This component is a **pure 3D renderer** — it holds no game logic state.
- *
- * @packageDocumentation
- */
-import React from 'react';
-import type { EventEmit, Asset } from '@almadar/core';
-import type { Platform, SidePlayer } from '../../2d/molecules/Canvas2D';
-import * as THREE from 'three';
-import { AssetLoader } from '../../shared/lib/AssetLoader';
-import { type MinimalMouseEvent } from '../../shared/hooks/useGameCanvas3DEvents';
-import type { IsometricTile, IsometricUnit, IsometricFeature } from '../../shared/isometricTypes';
-import './GameCanvas3D.css';
-export type { IsometricTile, IsometricUnit, IsometricFeature };
-/** Game event for canvas display */
-export interface GameEvent {
-    id: string;
-    type: string;
-    x: number;
-    z?: number;
-    y?: number;
-    message?: string;
-}
-/** Camera mode for 3D view.
- *  - `follow` tracks the side-view player (or the selected unit) from a fixed offset.
- *  - `chase` sits behind + above the followed unit relative to its `heading` (driving). */
-export type CameraMode = 'isometric' | 'perspective' | 'top-down' | 'follow' | 'chase';
-/** Per-role model manifest — the 3D analogue of Canvas2D's assetManifest (values are GLB Assets). */
-export interface GameCanvas3DAssetManifest {
-    terrains?: Record<string, Asset>;
-    units?: Record<string, Asset>;
-    features?: Record<string, Asset>;
-    effects?: Record<string, Asset>;
-}
-/** Map orientation */
-export type MapOrientation = 'standard' | 'rotated';
-/** Overlay control */
-export type OverlayControl = 'default' | 'hidden' | 'minimap';
-/** Props for GameCanvas3D component */
-export interface GameCanvas3DProps {
-    /** Additional CSS classes */
-    className?: string;
-    /** Children to render inside the 3D canvas (e.g., physics objects, custom meshes) */
-    children?: React.ReactNode;
-    /** Loading state indicator */
-    isLoading?: boolean;
-    /** Error state */
-    error?: string | null;
-    /** Array of tiles to render */
-    tiles?: IsometricTile[];
-    /** Array of units to render */
-    units?: IsometricUnit[];
-    /** Array of features to render */
-    features?: IsometricFeature[];
-    /** Array of events to display */
-    events?: Array<GameEvent>;
-    /** Fog of war data */
-    fogOfWar?: boolean[][];
-    /** Map orientation */
-    orientation?: MapOrientation;
-    /** Camera mode */
-    cameraMode?: CameraMode;
-    /** Show grid */
-    showGrid?: boolean;
-    /** Show coordinates overlay */
-    showCoordinates?: boolean;
-    /** Show tile information */
-    showTileInfo?: boolean;
-    /** Overlay control mode */
-    overlay?: OverlayControl;
-    /** Enable shadows */
-    shadows?: boolean;
-    /** Background color */
-    backgroundColor?: string;
-    /** Callback when a tile is clicked */
-    onTileClick?: (tile: IsometricTile, event: MinimalMouseEvent) => void;
-    /** Callback when a unit is clicked */
-    onUnitClick?: (unit: IsometricUnit, event: MinimalMouseEvent) => void;
-    /** Callback when a feature is clicked */
-    onFeatureClick?: (feature: IsometricFeature, event: MinimalMouseEvent) => void;
-    /** Callback when canvas is clicked (background) */
-    onCanvasClick?: (event: MinimalMouseEvent) => void;
-    /** Callback when mouse moves over a tile */
-    onTileHover?: (tile: IsometricTile | null, event: MinimalMouseEvent) => void;
-    /** Callback for unit animation state change */
-    onUnitAnimation?: (unitId: string, state: string) => void;
-    /** Asset loader instance (uses global singleton if not provided) */
-    assetLoader?: AssetLoader;
-    /** Custom tile renderer component */
-    tileRenderer?: React.FC<{
-        tile: IsometricTile;
-        position: [number, number, number];
-    }>;
-    /** Custom unit renderer component */
-    unitRenderer?: React.FC<{
-        unit: IsometricUnit;
-        position: [number, number, number];
-    }>;
-    /** Custom feature renderer component */
-    featureRenderer?: React.FC<{
-        feature: IsometricFeature;
-        position: [number, number, number];
-    }>;
-    /** URLs to preload */
-    preloadAssets?: string[];
-    /** Declarative event: tile click */
-    tileClickEvent?: EventEmit<{
-        tileId: string;
-        x: number;
-        z: number;
-        type?: string;
-        terrain?: string;
-        elevation?: number;
-    }>;
-    /** Declarative event: unit click */
-    unitClickEvent?: EventEmit<{
-        unitId: string;
-        x: number;
-        z: number;
-        unitType?: string;
-        name?: string;
-        team?: string;
-        faction?: string;
-        health?: number;
-        maxHealth?: number;
-    }>;
-    /** Declarative event: feature click */
-    featureClickEvent?: EventEmit<{
-        featureId: string;
-        x: number;
-        z: number;
-        type?: string;
-        elevation?: number;
-    }>;
-    /** Declarative event: canvas click */
-    canvasClickEvent?: EventEmit<{
-        clientX: number;
-        clientY: number;
-        button: number;
-    }>;
-    /** Declarative event: tile hover */
-    tileHoverEvent?: EventEmit<{
-        tileId: string;
-        x: number;
-        z: number;
-        type?: string;
-    }>;
-    /** Declarative event: tile leave */
-    tileLeaveEvent?: EventEmit<Record<string, never>>;
-    /** Declarative event: unit animation */
-    unitAnimationEvent?: EventEmit<{
-        unitId: string;
-        state: string;
-        timestamp: number;
-    }>;
-    /** Declarative event: camera change */
-    cameraChangeEvent?: EventEmit<{
-        position: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        timestamp: number;
-    }>;
-    /** Loading message */
-    loadingMessage?: string;
-    /** Whether to use instancing for tiles */
-    useInstancing?: boolean;
-    /** Valid move positions */
-    validMoves?: Array<{
-        x: number;
-        z: number;
-    }>;
-    /** Attack target positions */
-    attackTargets?: Array<{
-        x: number;
-        z: number;
-    }>;
-    /** Selected tile IDs */
-    selectedTileIds?: string[];
-    /** Selected unit ID */
-    selectedUnitId?: string | null;
-    /** Unit draw-size multiplier. 1 = default tile-proportional size. */
-    unitScale?: number;
-    /** Board zoom/group scale. Applied to the scene group. Default 0.45. */
-    scale?: number;
-    /** Maps a keydown `e.code` → the board's SEMANTIC event, e.g. `{ ArrowLeft: "LEFT", Space: "JUMP" }`.
-     *  The input layer emits `UI:<event>` so the FSM stays device-agnostic — keyboard and d-pad converge. */
-    keyMap?: Record<string, string>;
-    /** Maps a keyup `e.code` → the board's SEMANTIC event, e.g. `{ ArrowLeft: "STOP" }`. */
-    keyUpMap?: Record<string, string>;
-    /** Side-view player (pixel coords, LOLO-owned physics) — presence switches to side-scroller rendering. */
-    player?: SidePlayer;
-    /** Side-view level geometry (pixel AABBs, same contract as Canvas2D). */
-    platforms?: Platform[];
-    /** Side-view world size in pixels. */
-    worldWidth?: number;
-    /** Side-view world size in pixels. */
-    worldHeight?: number;
-    /** Pixel→world-unit divisor for side view (default 32 = one 2D tile per 3D cell). */
-    pixelsPerUnit?: number;
-    /** Player model — named for 2D parity; in 3D the Asset's url is a GLB. */
-    playerSprite?: Asset;
-    /** Platform-type → model map — named for 2D parity; values are GLB Assets. */
-    tileSprites?: Record<string, Asset>;
-    /** Per-role model manifest; resolves tiles/units/features without explicit modelUrl/assetUrl. */
-    assetManifest?: GameCanvas3DAssetManifest;
-    /** Opt-in: smooth-lerp unit positions between LOLO tick snapshots. DEFAULT OFF. */
-    interpolateUnits?: boolean;
-}
-/** Imperative handle for GameCanvas3D */
-export interface GameCanvas3DHandle {
-    /** Get current camera position */
-    getCameraPosition: () => THREE.Vector3 | null;
-    /** Set camera position */
-    setCameraPosition: (x: number, y: number, z: number) => void;
-    /** Look at a specific point */
-    lookAt: (x: number, y: number, z: number) => void;
-    /** Reset camera to default position */
-    resetCamera: () => void;
-    /** Take a screenshot */
-    screenshot: () => string | null;
-    /** Export current view as data */
-    export: () => {
-        tiles: IsometricTile[];
-        units: IsometricUnit[];
-        features: IsometricFeature[];
-    };
-}
-/**
- * GameCanvas3D Component
- *
- * 3D game canvas that mirrors the IsometricCanvas API.
- * Uses Three.js and React Three Fiber for rendering.
- *
- * @example
- * ```tsx
- * <GameCanvas3D
- *   tiles={tiles}
- *   units={units}
- *   features={features}
- *   cameraMode="isometric"
- *   tileClickEvent="TILE_SELECTED"
- *   onTileClick={(tile) => console.log('Clicked:', tile)}
- * />
- * ```
- */
-export declare const GameCanvas3D: React.ForwardRefExoticComponent<GameCanvas3DProps & React.RefAttributes<GameCanvas3DHandle>>;
-export default GameCanvas3D;

package/dist/components/game/3d/molecules/SideScene3D.d.ts

@@ -1,31 +0,0 @@
-/**
- * SideScene3D
- *
- * Side-scroller scene: renders the LOLO-owned pixel-space `player`/`platforms`
- * as 3D geometry. Physics stays in the board's tick (same contract as Canvas2D's
- * SideView) — this only maps px → world units and draws. Platform and player
- * fallback colors come from `game3dTheme` defaults.
- *
- * @packageDocumentation
- */
-import React from 'react';
-import type { Asset } from '@almadar/core';
-import type { Platform, SidePlayer } from '../../2d/molecules/Canvas2D';
-import type { IsometricFeature } from '../../shared/isometricTypes';
-import type { GameEvent, GameCanvas3DAssetManifest } from './GameCanvas3D';
-export interface SideScene3DProps {
-    player: SidePlayer;
-    platforms: Platform[];
-    worldHeight: number;
-    ppu: number;
-    playerSprite?: Asset;
-    tileSprites?: Record<string, Asset>;
-    interpolate: boolean;
-    /** Side-view features (collectibles/props) — x/y are PIXELS like platforms. */
-    features?: IsometricFeature[];
-    /** Feedback markers — x/y are PIXELS in side view. */
-    events?: GameEvent[];
-    assetManifest?: GameCanvas3DAssetManifest;
-}
-export declare function SideScene3D({ player, platforms, worldHeight, ppu, playerSprite, tileSprites, interpolate, features, events, assetManifest, }: SideScene3DProps): React.JSX.Element;
-export default SideScene3D;

package/dist/components/game/3d/molecules/TileMesh3D.d.ts

@@ -1,28 +0,0 @@
-/**
- * TileMesh3D
- *
- * Default tile renderer for GameCanvas3D. GLB tile when a model is resolved
- * (with a box fallback while loading/on error); otherwise a colored plate
- * whose terrain color and highlight emissive come from `game3dTheme` defaults,
- * overridable per-tile via `tile.color`.
- *
- * @packageDocumentation
- */
-import React from 'react';
-import type { Asset } from '@almadar/core';
-import type { IsometricTile } from '../../shared/isometricTypes';
-import type { MinimalMouseEvent } from '../../shared/hooks/useGameCanvas3DEvents';
-export interface TileMesh3DProps {
-    /** `color` is an optional per-tile override of the terrain default. */
-    tile: IsometricTile;
-    position: [number, number, number];
-    model?: Asset;
-    isSelected: boolean;
-    isHovered: boolean;
-    isValidMove: boolean;
-    isAttackTarget: boolean;
-    onTileClick: (tile: IsometricTile, event: MinimalMouseEvent) => void;
-    onTileHover: (tile: IsometricTile | null, event: MinimalMouseEvent) => void;
-}
-export declare function TileMesh3D({ tile, position, model, isSelected, isHovered, isValidMove, isAttackTarget, onTileClick, onTileHover, }: TileMesh3DProps): React.JSX.Element;
-export default TileMesh3D;

package/dist/components/game/3d/molecules/UnitMesh3D.d.ts

@@ -1,29 +0,0 @@
-/**
- * UnitMesh3D
- *
- * Default unit renderer for GameCanvas3D. Renders (in priority order) an
- * animated sprite-sheet billboard, a GLB model, or a procedural
- * base/body/head primitive stack — plus a selection ring and health bar.
- * Faction color, selection ring, and health-bar palette come from
- * `game3dTheme` defaults, overridable per-unit via `unit.tint`.
- *
- * @packageDocumentation
- */
-import React from 'react';
-import type { Asset } from '@almadar/core';
-import type { IsometricUnit } from '../../shared/isometricTypes';
-import type { ResolvedFrame } from '../../shared/spriteAnimationTypes';
-import type { MinimalMouseEvent } from '../../shared/hooks/useGameCanvas3DEvents';
-export interface UnitMesh3DProps {
-    /** `tint` is an optional per-unit override of the faction default. */
-    unit: IsometricUnit;
-    position: [number, number, number];
-    model?: Asset;
-    isSelected: boolean;
-    unitScale: number;
-    cellSize: number;
-    resolveUnitFrame: (unitId: string) => ResolvedFrame | null;
-    onUnitClick: (unit: IsometricUnit, event: MinimalMouseEvent) => void;
-}
-export declare function UnitMesh3D({ unit, position, model, isSelected, unitScale, cellSize, resolveUnitFrame, onUnitClick, }: UnitMesh3DProps): React.JSX.Element;
-export default UnitMesh3D;

package/dist/components/game/3d/organisms/GameBoard3D.d.ts

@@ -1,66 +0,0 @@
-/**
- * GameBoard3D
- *
- * Controlled 3D tactics board organism. Reads all gameplay state
- * (selectedUnitId, validMoves, attackTargets, phase, result) from the entity
- * prop and renders <GameCanvas3D> with those controlled values.
- * Emits user interactions via event bus so the parent Orbital trait drives
- * all state transitions.
- *
- * @packageDocumentation
- */
-import React from 'react';
-import type { EventEmit, EntityRow } from '@almadar/core';
-import type { CameraMode } from '../molecules/GameCanvas3D';
-import type { IsometricTile, IsometricFeature } from '../../shared/isometricTypes';
-export interface GameBoard3DProps {
-    /** Entity row carrying all gameplay state (controlled). */
-    entity?: EntityRow | readonly EntityRow[];
-    /** Static tile data (config default). */
-    tiles?: IsometricTile[];
-    /** Static feature data (config default). */
-    features?: IsometricFeature[];
-    /** Camera mode forwarded to GameCanvas3D. */
-    cameraMode?: CameraMode;
-    /** Background color forwarded to GameCanvas3D. */
-    backgroundColor?: string;
-    /** Unit draw-size multiplier forwarded to GameCanvas3D. Default 1. */
-    unitScale?: number;
-    /** Board zoom/group scale forwarded to GameCanvas3D. Default 0.45. */
-    scale?: number;
-    /** Declarative tile click event emitted to the model. */
-    tileClickEvent?: EventEmit<{
-        tileId: string;
-        x: number;
-        z: number;
-    }>;
-    /** Declarative unit click event emitted to the model. */
-    unitClickEvent?: EventEmit<{
-        unitId: string;
-        x: number;
-        z: number;
-    }>;
-    /** Emits UI:{attackEvent} with { attackerId, targetId, damage } on attack. */
-    attackEvent?: EventEmit<{
-        attackerId: string;
-        targetId: string;
-        damage: number;
-    }>;
-    /** Emits UI:{endTurnEvent} with {} on end turn. */
-    endTurnEvent?: EventEmit<Record<string, never>>;
-    /** Emits UI:{cancelEvent} with {} on cancel. */
-    cancelEvent?: EventEmit<Record<string, never>>;
-    /** Emits UI:{playAgainEvent} with {} on play again / reset. */
-    playAgainEvent?: EventEmit<Record<string, never>>;
-    /** Emits UI:{gameEndEvent} with { result } when win/loss is detected. */
-    gameEndEvent?: EventEmit<{
-        result: 'victory' | 'defeat';
-    }>;
-    /** Additional CSS class. */
-    className?: string;
-}
-export declare function GameBoard3D({ entity, tiles, features, cameraMode, backgroundColor, unitScale, scale, tileClickEvent, unitClickEvent, attackEvent, endTurnEvent, cancelEvent, playAgainEvent, gameEndEvent, className, }: GameBoard3DProps): React.JSX.Element | null;
-export declare namespace GameBoard3D {
-    var displayName: string;
-}
-export default GameBoard3D;

package/dist/components/game/3d/templates/GameCanvas3DBattleTemplate.d.ts

@@ -1,82 +0,0 @@
-/**
- * GameCanvas3DBattleTemplate
- *
- * Declarative template for 3D battle/tactical combat.
- * Delegates all interaction state (selectedUnitId, validMoves, attackTargets)
- * to <GameBoard3D> so the model (not this template) owns gameplay state.
- *
- * Page: Battle3DPage
- * Entity: Battle3D / GameBoard3DItem
- * ViewType: detail
- *
- * Events Emitted:
- * - TILE_CLICK - When a tile is clicked
- * - UNIT_CLICK - When a unit is clicked
- * - END_TURN   - When ending turn
- * - EXIT_BATTLE - When exiting battle
- *
- * @packageDocumentation
- */
-import React from 'react';
-import type { IsometricTile, IsometricFeature } from '../../shared/isometricTypes';
-import type { TemplateProps } from '../../../core/templates/types';
-import { type Game3DAssetManifest } from '../../shared/lib/game3dAssetManifest';
-export interface GameCanvas3DBattleTemplateProps extends TemplateProps {
-    /** Fallback tile data when no entity is present (layout only — model URLs resolve from assetManifest) */
-    tiles?: IsometricTile[];
-    /** Fallback feature data when no entity is present */
-    features?: IsometricFeature[];
-    /** GLB model URLs keyed by terrain — owns all asset choice (no hardcoded URLs in this template). */
-    assetManifest?: Game3DAssetManifest;
-    /** 3D camera mode - defaults to perspective for dramatic effect */
-    cameraMode?: 'isometric' | 'perspective' | 'top-down';
-    /** Show grid helper */
-    showGrid?: boolean;
-    /** Enable shadows */
-    shadows?: boolean;
-    /** Background color - darker for battle atmosphere */
-    backgroundColor?: string;
-    /** Event name for tile clicks — forwarded to the model */
-    tileClickEvent?: string;
-    /** Event name for unit clicks — forwarded to the model */
-    unitClickEvent?: string;
-    /** Event name for ending turn */
-    endTurnEvent?: string;
-    /** Event name for cancel/deselect */
-    cancelEvent?: string;
-    /** Event name for attack emission */
-    attackEvent?: string;
-    /** Event name for play again / reset */
-    playAgainEvent?: string;
-    /** Event name for game end detection */
-    gameEndEvent?: string;
-    /** Event name for exiting battle */
-    exitEvent?: string;
-    /** Show turn indicator overlay */
-    showTurnIndicator?: boolean;
-    /** Unit draw-size multiplier forwarded to GameBoard3D. Default 1. */
-    unitScale?: number;
-    /** Board zoom/group scale forwarded to GameBoard3D. Default 0.45. */
-    scale?: number;
-}
-/**
- * GameCanvas3DBattleTemplate Component
- *
- * Template for 3D battle/tactical combat view.
- * Interaction state lives in the entity (model), not in this component.
- *
- * @example
- * ```tsx
- * <GameCanvas3DBattleTemplate
- *     entity={battleEntity}
- *     cameraMode="perspective"
- *     tileClickEvent="TILE_CLICK"
- *     unitClickEvent="UNIT_CLICK"
- * />
- * ```
- */
-export declare function GameCanvas3DBattleTemplate({ entity, tiles: propTiles, features: propFeatures, assetManifest, cameraMode, backgroundColor, tileClickEvent, unitClickEvent, endTurnEvent, cancelEvent, attackEvent, playAgainEvent, gameEndEvent, unitScale, scale, className, }: GameCanvas3DBattleTemplateProps): React.JSX.Element | null;
-export declare namespace GameCanvas3DBattleTemplate {
-    var displayName: string;
-}
-export default GameCanvas3DBattleTemplate;