@almadar/ui 5.79.0 → 5.79.1

package/dist/components/game/shared/game.d.ts

@@ -1,92 +0,0 @@
-/**
- * Game Types — Generalized
- *
- * Core type definitions for tactical game state.
- * Extracted from Trait Wars and generalized for any game project.
- */
-export interface Position {
-    x: number;
-    y: number;
-}
-export interface GameUnit {
-    id: string;
-    name: string;
-    characterType: string;
-    team: 'player' | 'enemy' | 'neutral';
-    position: Position;
-    health: number;
-    maxHealth: number;
-    movement: number;
-    attack: number;
-    defense: number;
-    traits: UnitTrait[];
-}
-export interface UnitTrait {
-    name: string;
-    currentState: string;
-    states: string[];
-    cooldown: number;
-}
-export interface BoardTile {
-    terrain: string;
-    unitId?: string;
-    isBlocked?: boolean;
-}
-export type GamePhase = 'observation' | 'planning' | 'execution' | 'tick';
-export interface GameState {
-    board: BoardTile[][];
-    units: Record<string, GameUnit>;
-    currentPhase: GamePhase;
-    currentTurn: number;
-    activeTeam: 'player' | 'enemy' | 'neutral';
-    selectedUnitId?: string;
-    validMoves: Position[];
-    attackTargets: Position[];
-}
-export type GameAction = {
-    type: 'SELECT_UNIT';
-    unitId: string;
-} | {
-    type: 'MOVE_UNIT';
-    from: Position;
-    to: Position;
-} | {
-    type: 'ATTACK';
-    attackerId: string;
-    targetId: string;
-} | {
-    type: 'END_TURN';
-} | {
-    type: 'EXECUTE_TRAITS';
-};
-/**
- * Create the initial game state with board and units.
- *
- * @param {number} width - Board width in tiles
- * @param {number} height - Board height in tiles
- * @param {GameUnit[]} units - Initial units to place on the board
- * @param {string} [defaultTerrain] - Default terrain type for empty tiles
- * @returns {GameState} The initialized game state
- */
-export declare function createInitialGameState(width: number, height: number, units: GameUnit[], defaultTerrain?: string): GameState;
-/**
- * Calculate valid movement positions for a unit.
- *
- * Returns all tiles within the unit's movement range that are
- * not blocked and don't contain other units.
- *
- * @param {GameState} state - Current game state
- * @param {string} unitId - ID of the unit to calculate moves for
- * @returns {Position[]} Array of valid move positions
- */
-export declare function calculateValidMoves(state: GameState, unitId: string): Position[];
-/**
- * Calculate valid attack targets for a unit.
- *
- * Returns adjacent positions containing enemy units that can be attacked.
- *
- * @param {GameState} state - Current game state
- * @param {string} unitId - ID of the unit to calculate targets for
- * @returns {Position[]} Array of valid attack target positions
- */
-export declare function calculateAttackTargets(state: GameState, unitId: string): Position[];

package/dist/components/game/shared/hooks/useAssetLoader.d.ts

@@ -1,58 +0,0 @@
-import * as THREE from 'three';
-import { AssetLoader, LoadedModel } from '../lib/AssetLoader';
-export interface UseAssetLoaderOptions {
-    /** URLs to preload on mount */
-    preloadUrls?: string[];
-    /** Asset loader instance (uses singleton if not provided) */
-    loader?: AssetLoader;
-}
-export interface AssetLoadingState {
-    /** Whether assets are currently loading */
-    isLoading: boolean;
-    /** Loading progress (0-100) */
-    progress: number;
-    /** Number of loaded assets */
-    loaded: number;
-    /** Total assets to load */
-    total: number;
-    /** Any loading errors */
-    errors: string[];
-}
-export interface UseAssetLoaderReturn extends AssetLoadingState {
-    /** Load a single model */
-    loadModel: (url: string) => Promise<LoadedModel>;
-    /** Load a single OBJ model */
-    loadOBJ: (url: string) => Promise<THREE.Group>;
-    /** Load a single texture */
-    loadTexture: (url: string) => Promise<THREE.Texture>;
-    /** Preload multiple assets */
-    preload: (urls: string[]) => Promise<void>;
-    /** Check if model is cached */
-    hasModel: (url: string) => boolean;
-    /** Check if texture is cached */
-    hasTexture: (url: string) => boolean;
-    /** Get cached model */
-    getModel: (url: string) => LoadedModel | undefined;
-    /** Get cached texture */
-    getTexture: (url: string) => THREE.Texture | undefined;
-    /** Clear all caches */
-    clearCache: () => void;
-}
-/**
- * Hook for managing 3D asset loading in React components
- *
- * @example
- * ```tsx
- * const { loadModel, isLoading, progress } = useAssetLoader({
- *     preloadUrls: ['/assets/model.glb']
- * });
- *
- * useEffect(() => {
- *     loadModel('/assets/character.glb').then((model) => {
- *         scene.add(model.scene);
- *     });
- * }, []);
- * ```
- */
-export declare function useAssetLoader(options?: UseAssetLoaderOptions): UseAssetLoaderReturn;
-export default useAssetLoader;

package/dist/components/game/shared/hooks/useBattleState.d.ts

@@ -1,47 +0,0 @@
-import type { EventEmit, EntityRow } from '@almadar/core';
-import type { BattlePhase } from '../../2d/organisms/BattleBoard';
-export interface BattleStateEventConfig {
-    tileClickEvent?: EventEmit<{
-        x: number;
-        y: number;
-    }>;
-    unitClickEvent?: EventEmit<{
-        unitId: string;
-    }>;
-    endTurnEvent?: EventEmit<Record<string, never>>;
-    cancelEvent?: EventEmit<Record<string, never>>;
-    gameEndEvent?: EventEmit<{
-        result: 'victory' | 'defeat';
-    }>;
-    playAgainEvent?: EventEmit<Record<string, never>>;
-    attackEvent?: EventEmit<{
-        attackerId: string;
-        targetId: string;
-        damage: number;
-    }>;
-}
-export interface BattleStateCallbacks {
-    /** Called when a unit attacks another */
-    onAttack?: (attacker: EntityRow, target: EntityRow, damage: number) => void;
-    /** Called when battle ends */
-    onGameEnd?: (result: 'victory' | 'defeat') => void;
-    /** Called after a unit moves */
-    onUnitMove?: (unit: EntityRow, to: {
-        x: number;
-        y: number;
-    }) => void;
-    /** Custom combat damage calculator */
-    calculateDamage?: (attacker: EntityRow, target: EntityRow) => number;
-}
-export interface BattleStateResult {
-    units: EntityRow[];
-    selectedUnitId: string | null;
-    phase: BattlePhase;
-    turn: number;
-    gameResult: 'victory' | 'defeat' | null;
-    handleTileClick: (x: number, y: number) => void;
-    handleUnitClick: (unitId: string) => void;
-    handleEndTurn: () => void;
-    handleRestart: () => void;
-}
-export declare function useBattleState(initialUnits: EntityRow[], eventConfig?: BattleStateEventConfig, callbacks?: BattleStateCallbacks): BattleStateResult;

package/dist/components/game/shared/hooks/useCamera.d.ts

@@ -1,57 +0,0 @@
-import type { CameraState } from '../isometricTypes';
-interface CameraResult {
-    /** Mutable camera state ref (x, y, zoom) */
-    cameraRef: React.MutableRefObject<CameraState>;
-    /** Target camera position for smooth lerp centering. Set to null when reached. */
-    targetCameraRef: React.MutableRefObject<{
-        x: number;
-        y: number;
-    } | null>;
-    /** Whether the user is currently dragging */
-    isDragging: () => boolean;
-    /** Total drag distance — used to distinguish click from pan (threshold: 5px) */
-    dragDistance: () => number;
-    /** Mouse down handler — starts panning */
-    handleMouseDown: (e: React.MouseEvent) => void;
-    /** Mouse up handler — stops panning */
-    handleMouseUp: () => void;
-    /** Mouse move handler — pans camera if dragging, returns true if panning */
-    handleMouseMove: (e: React.MouseEvent, drawFn?: () => void) => boolean;
-    /** Mouse leave handler — cancels drag */
-    handleMouseLeave: () => void;
-    /** Wheel handler — zoom in/out */
-    handleWheel: (e: React.WheelEvent, drawFn?: () => void) => void;
-    /** Pointer down — starts panning (mouse/touch/pen via Pointer Events). */
-    handlePointerDown: (e: React.PointerEvent) => void;
-    /** Pointer up — stops panning. */
-    handlePointerUp: () => void;
-    /** Pointer move — pans camera if dragging, returns true if panning. */
-    handlePointerMove: (e: React.PointerEvent, drawFn?: () => void) => boolean;
-    /** Apply a two-finger pan delta (screen px) directly to the camera. */
-    panBy: (dx: number, dy: number, drawFn?: () => void) => void;
-    /**
-     * Multiplicative zoom by `factor` keeping the world point under (centerX,centerY)
-     * — screen px relative to the canvas — fixed. Used by wheel + pinch.
-     */
-    zoomAtPoint: (factor: number, centerX: number, centerY: number, viewportSize: {
-        width: number;
-        height: number;
-    }, drawFn?: () => void) => void;
-    /** Convert screen coordinates to world coordinates (inverse camera transform) */
-    screenToWorld: (clientX: number, clientY: number, canvas: HTMLCanvasElement, viewportSize: {
-        width: number;
-        height: number;
-    }) => {
-        x: number;
-        y: number;
-    };
-    /** Lerp camera toward target. Call in animation loop. Returns true if still animating. */
-    lerpToTarget: (t?: number) => boolean;
-}
-/**
- * Camera hook for pan/zoom canvas rendering.
- *
- * @returns Camera state, event handlers, and coordinate conversion
- */
-export declare function useCamera(): CameraResult;
-export {};

package/dist/components/game/shared/hooks/useCanvasEffects.d.ts

@@ -1,27 +0,0 @@
-import type { AssetUrl } from '@almadar/core';
-import type { CombatActionType, EffectAssetManifest } from '../effects';
-export interface UseCanvasEffectsOptions {
-    /** Effect asset manifest (baseUrl + particles + animations) */
-    manifest: EffectAssetManifest;
-}
-export interface UseCanvasEffectsResult {
-    /** All effect sprite URLs for preloading via useImageCache */
-    effectSpriteUrls: AssetUrl[];
-    /** Spawn a combat effect at the given screen position */
-    spawnEffect: (type: CombatActionType, screenX: number, screenY: number) => void;
-    /** Draw all active effects — call inside draw() after units, before ctx.restore() */
-    drawEffects: (ctx: CanvasRenderingContext2D, animTime: number, getImage: (url: string) => HTMLImageElement | undefined) => void;
-    /** Whether there are active effects (keeps RAF alive) */
-    hasActiveEffects: boolean;
-    /** Screen shake offset to apply to container transform */
-    screenShake: {
-        x: number;
-        y: number;
-    };
-    /** Screen flash overlay (null = no flash) */
-    screenFlash: {
-        color: string;
-        alpha: number;
-    } | null;
-}
-export declare function useCanvasEffects({ manifest, }: UseCanvasEffectsOptions): UseCanvasEffectsResult;

package/dist/components/game/shared/hooks/useGameAudio.d.ts

@@ -1,47 +0,0 @@
-export interface SoundEntry {
-    /** Single path or array of paths — array picks randomly on each play */
-    path: string | string[];
-    /** Volume 0–1 (multiplied by masterVolume; default 1) */
-    volume?: number;
-    /** Whether this sound loops (background music) */
-    loop?: boolean;
-    /** Number of concurrent Audio instances in the pool (default 1) */
-    poolSize?: number;
-    /** Start automatically on first user interaction */
-    autostart?: boolean;
-    /** Use crossfade transitions when played via playMusic() */
-    crossfade?: boolean;
-    /** Crossfade duration in ms (default 1500) */
-    crossfadeDurationMs?: number;
-}
-export type AudioManifest = Record<string, SoundEntry>;
-export interface GameAudioControls {
-    /** Play a sound effect (instant, pooled) */
-    play: (key: string) => void;
-    /** Stop all instances of a sound effect */
-    stop: (key: string) => void;
-    /** Stop all sounds including music */
-    stopAll: () => void;
-    /** Crossfade to a new music track */
-    playMusic: (key: string) => void;
-    /** Fade out and stop the current music */
-    stopMusic: (fadeDurationMs?: number) => void;
-    muted: boolean;
-    setMuted: (muted: boolean) => void;
-    masterVolume: number;
-    setMasterVolume: (volume: number) => void;
-}
-export interface UseGameAudioOptions {
-    /** Sound definitions keyed by logical name */
-    manifest: AudioManifest;
-    /** Prefix prepended to all `path` values (default '') */
-    baseUrl?: string;
-    /** Start muted (default false) */
-    initialMuted?: boolean;
-    /** Master volume 0–1 (default 1) */
-    initialVolume?: number;
-}
-export declare function useGameAudio({ manifest, baseUrl, initialMuted, initialVolume, }: UseGameAudioOptions): GameAudioControls;
-export declare namespace useGameAudio {
-    var displayName: string;
-}

package/dist/components/game/shared/hooks/useGameCanvas3DEvents.d.ts

@@ -1,123 +0,0 @@
-import type { EventEmit } from '@almadar/core';
-import type { IsometricTile, IsometricUnit, IsometricFeature } from '../isometricTypes';
-export interface GameCanvas3DEventConfig {
-    /** Event name for tile clicks */
-    tileClickEvent?: EventEmit<{
-        tileId: string;
-        x: number;
-        z: number;
-        type?: string;
-        terrain?: string;
-        elevation?: number;
-    }>;
-    /** Event name for unit clicks */
-    unitClickEvent?: EventEmit<{
-        unitId: string;
-        x: number;
-        z: number;
-        unitType?: string;
-        name?: string;
-        team?: string;
-        faction?: string;
-        health?: number;
-        maxHealth?: number;
-    }>;
-    /** Event name for feature clicks */
-    featureClickEvent?: EventEmit<{
-        featureId: string;
-        x: number;
-        z: number;
-        type?: string;
-        elevation?: number;
-    }>;
-    /** Event name for canvas clicks */
-    canvasClickEvent?: EventEmit<{
-        clientX: number;
-        clientY: number;
-        button: number;
-    }>;
-    /** Event name for tile hover */
-    tileHoverEvent?: EventEmit<{
-        tileId: string;
-        x: number;
-        z: number;
-        type?: string;
-    }>;
-    /** Event name for tile leave */
-    tileLeaveEvent?: EventEmit<Record<string, never>>;
-    /** Event name for unit animation changes */
-    unitAnimationEvent?: EventEmit<{
-        unitId: string;
-        state: string;
-        timestamp: number;
-    }>;
-    /** Event name for camera changes */
-    cameraChangeEvent?: EventEmit<{
-        position: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        timestamp: number;
-    }>;
-}
-/** Minimal mouse event interface — satisfied by both React.MouseEvent and ThreeEvent<MouseEvent> */
-export interface MinimalMouseEvent {
-    clientX: number;
-    clientY: number;
-    button: number;
-}
-export interface UseGameCanvas3DEventsOptions extends GameCanvas3DEventConfig {
-    /** Callback for tile clicks (direct) */
-    onTileClick?: (tile: IsometricTile, event: MinimalMouseEvent) => void;
-    /** Callback for unit clicks (direct) */
-    onUnitClick?: (unit: IsometricUnit, event: MinimalMouseEvent) => void;
-    /** Callback for feature clicks (direct) */
-    onFeatureClick?: (feature: IsometricFeature, event: MinimalMouseEvent) => void;
-    /** Callback for canvas clicks (direct) */
-    onCanvasClick?: (event: MinimalMouseEvent) => void;
-    /** Callback for tile hover (direct) */
-    onTileHover?: (tile: IsometricTile | null, event: MinimalMouseEvent) => void;
-    /** Callback for unit animation changes (direct) */
-    onUnitAnimation?: (unitId: string, state: string) => void;
-}
-export interface UseGameCanvas3DEventsReturn {
-    /** Handle tile click - emits event and calls callback */
-    handleTileClick: (tile: IsometricTile, event: MinimalMouseEvent) => void;
-    /** Handle unit click - emits event and calls callback */
-    handleUnitClick: (unit: IsometricUnit, event: MinimalMouseEvent) => void;
-    /** Handle feature click - emits event and calls callback */
-    handleFeatureClick: (feature: IsometricFeature, event: MinimalMouseEvent) => void;
-    /** Handle canvas click - emits event and calls callback */
-    handleCanvasClick: (event: MinimalMouseEvent) => void;
-    /** Handle tile hover - emits event and calls callback */
-    handleTileHover: (tile: IsometricTile | null, event: MinimalMouseEvent) => void;
-    /** Handle unit animation - emits event and calls callback */
-    handleUnitAnimation: (unitId: string, state: string) => void;
-    /** Handle camera change - emits event */
-    handleCameraChange: (position: {
-        x: number;
-        y: number;
-        z: number;
-    }) => void;
-}
-/**
- * Hook for integrating GameCanvas3D with the event bus
- *
- * Supports both declarative event props (tileClickEvent) and
- * direct callback props (onTileClick).
- *
- * @example
- * ```tsx
- * const events = useGameCanvas3DEvents({
- *     tileClickEvent: 'TILE_SELECTED',
- *     unitClickEvent: 'UNIT_SELECTED',
- *     onTileClick: (tile) => console.log('Tile:', tile)
- * });
- *
- * // In component:
- * <TileRenderer onTileClick={events.handleTileClick} />
- * ```
- */
-export declare function useGameCanvas3DEvents(options: UseGameCanvas3DEventsOptions): UseGameCanvas3DEventsReturn;
-export default useGameCanvas3DEvents;

package/dist/components/game/shared/hooks/useRaycaster.d.ts

@@ -1,86 +0,0 @@
-import * as THREE from 'three';
-export interface RaycastHit {
-    /** Intersected object */
-    object: THREE.Object3D;
-    /** Intersection point */
-    point: THREE.Vector3;
-    /** Distance from camera */
-    distance: number;
-    /** UV coordinates (if available) */
-    uv?: THREE.Vector2;
-    /** Face normal */
-    face?: THREE.Face;
-    /** Face index */
-    faceIndex?: number;
-    /** Instance ID (for instanced meshes) */
-    instanceId?: number;
-}
-export interface GridHit {
-    /** Grid X coordinate */
-    gridX: number;
-    /** Grid Z coordinate */
-    gridZ: number;
-    /** World position */
-    worldPosition: THREE.Vector3;
-    /** Intersected object type */
-    objectType?: 'tile' | 'unit' | 'feature';
-    /** Object ID if available */
-    objectId?: string;
-}
-export interface UseRaycasterOptions {
-    /** Camera reference */
-    camera: THREE.Camera | null;
-    /** Canvas element for coordinate conversion */
-    canvas: HTMLCanvasElement | null;
-    /** Grid cell size */
-    cellSize?: number;
-    /** Grid offset X */
-    offsetX?: number;
-    /** Grid offset Z */
-    offsetZ?: number;
-}
-export interface UseRaycasterReturn {
-    /** Raycaster instance */
-    raycaster: React.MutableRefObject<THREE.Raycaster>;
-    /** Mouse vector instance */
-    mouse: React.MutableRefObject<THREE.Vector2>;
-    /** Get intersection at client coordinates */
-    getIntersection: (clientX: number, clientY: number, objects: THREE.Object3D[]) => RaycastHit | null;
-    /** Get all intersections at client coordinates */
-    getAllIntersections: (clientX: number, clientY: number, objects: THREE.Object3D[]) => RaycastHit[];
-    /** Get grid coordinates at client position */
-    getGridCoordinates: (clientX: number, clientY: number) => {
-        x: number;
-        z: number;
-    } | null;
-    /** Get tile at client position from scene */
-    getTileAtPosition: (clientX: number, clientY: number, scene: THREE.Scene) => GridHit | null;
-    /** Convert client coordinates to normalized device coordinates */
-    clientToNDC: (clientX: number, clientY: number) => {
-        x: number;
-        y: number;
-    };
-    /** Check if point is within canvas bounds */
-    isWithinCanvas: (clientX: number, clientY: number) => boolean;
-}
-/**
- * Hook for 3D raycasting operations
- *
- * @example
- * ```tsx
- * const { getIntersection, getGridCoordinates } = useRaycaster({
- *     camera,
- *     canvas: canvasRef.current
- * });
- *
- * const handleClick = (e: MouseEvent) => {
- *     const hit = getIntersection(e.clientX, e.clientY, tileMeshes);
- *     if (hit) {
- *         const grid = getGridCoordinates(e.clientX, e.clientY);
- *         console.log('Clicked grid:', grid);
- *     }
- * };
- * ```
- */
-export declare function useRaycaster(options: UseRaycasterOptions): UseRaycasterReturn;
-export default useRaycaster;

package/dist/components/game/shared/hooks/useSceneGraph.d.ts

@@ -1,67 +0,0 @@
-import * as THREE from 'three';
-import type { JsonObject } from '@almadar/core';
-export type NodeType = 'tile' | 'unit' | 'feature' | 'highlight' | 'effect';
-export interface SceneGraphNode {
-    /** Unique node identifier */
-    id: string;
-    /** Node type classification */
-    type: NodeType;
-    /** Three.js object */
-    mesh: THREE.Object3D;
-    /** World position */
-    position: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    /** Grid position */
-    gridPosition: {
-        x: number;
-        z: number;
-    };
-    /** Optional metadata */
-    metadata?: JsonObject;
-}
-export interface UseSceneGraphReturn {
-    /** Reference to the nodes map */
-    nodesRef: React.MutableRefObject<Map<string, SceneGraphNode>>;
-    /** Add a node to the scene */
-    addNode: (node: SceneGraphNode) => void;
-    /** Remove a node from the scene */
-    removeNode: (id: string) => void;
-    /** Get a node by ID */
-    getNode: (id: string) => SceneGraphNode | undefined;
-    /** Update node position */
-    updateNodePosition: (id: string, x: number, y: number, z: number) => void;
-    /** Update node grid position */
-    updateNodeGridPosition: (id: string, gridX: number, gridZ: number) => void;
-    /** Get node at grid position */
-    getNodeAtGrid: (x: number, z: number, type?: NodeType) => SceneGraphNode | undefined;
-    /** Get all nodes of a specific type */
-    getNodesByType: (type: NodeType) => SceneGraphNode[];
-    /** Get all nodes within a bounding box */
-    getNodesInBounds: (minX: number, maxX: number, minZ: number, maxZ: number) => SceneGraphNode[];
-    /** Clear all nodes */
-    clearNodes: () => void;
-    /** Count nodes by type */
-    countNodes: (type?: NodeType) => number;
-}
-/**
- * Hook for managing the 3D scene graph
- *
- * @example
- * ```tsx
- * const { addNode, removeNode, getNodeAtGrid } = useSceneGraph();
- *
- * // Add a tile
- * addNode({
- *     id: 'tile-0-0',
- *     type: 'tile',
- *     mesh: tileMesh,
- *     position: { x: 0, y: 0, z: 0 },
- *     gridPosition: { x: 0, z: 0 }
- * });
- * ```
- */
-export declare function useSceneGraph(): UseSceneGraphReturn;
-export default useSceneGraph;

package/dist/components/game/shared/hooks/useThree.d.ts

@@ -1,58 +0,0 @@
-import * as THREE from 'three';
-import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
-import { AssetLoader } from '../lib/AssetLoader';
-export type CameraMode = 'isometric' | 'perspective' | 'top-down';
-export interface UseThreeOptions {
-    /** Camera mode for viewing the scene */
-    cameraMode?: CameraMode;
-    /** Initial camera position [x, y, z] */
-    cameraPosition?: [number, number, number];
-    /** Background color */
-    backgroundColor?: string;
-    /** Enable shadows */
-    shadows?: boolean;
-    /** Enable grid helper */
-    showGrid?: boolean;
-    /** Grid size */
-    gridSize?: number;
-    /** Asset loader instance */
-    assetLoader?: AssetLoader;
-}
-export interface UseThreeReturn {
-    /** Canvas element reference (for React Three Fiber) */
-    canvasRef: React.RefObject<HTMLCanvasElement | null>;
-    /** Three.js renderer */
-    renderer: THREE.WebGLRenderer | null;
-    /** Three.js scene */
-    scene: THREE.Scene | null;
-    /** Three.js camera */
-    camera: THREE.Camera | null;
-    /** Orbit controls */
-    controls: OrbitControls | null;
-    /** Is scene ready */
-    isReady: boolean;
-    /** Canvas dimensions */
-    dimensions: {
-        width: number;
-        height: number;
-    };
-    /** 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 initial position */
-    resetCamera: () => void;
-    /** Fit view to bounds */
-    fitView: (bounds: {
-        minX: number;
-        maxX: number;
-        minZ: number;
-        maxZ: number;
-    }) => void;
-}
-/**
- * Hook for managing a Three.js scene
- * This is a lower-level hook used by GameCanvas3D
- */
-export declare function useThree(options?: UseThreeOptions): UseThreeReturn;
-export default useThree;