@almadar/ui 2.0.0 → 2.0.1

package/dist/components/organisms/WizardContainer.d.ts

@@ -0,0 +1,160 @@
+/**
+ * WizardContainer Component
+ *
+ * Multi-step wizard pattern with progress indicator.
+ * Composes Box, Typography, and Button atoms.
+ *
+ * Uses wireframe theme styling (high contrast, sharp edges).
+ */
+import React from "react";
+/** Form field definition for wizard sections */
+export interface WizardField {
+    id: string;
+    type: string;
+    label?: string;
+    required?: boolean;
+    repeatable?: boolean;
+    options?: Array<{
+        value: string;
+        label: string;
+        isDefault?: boolean;
+    }>;
+    defaultValue?: unknown;
+    condition?: unknown[];
+    placeholder?: string;
+    entityField?: string;
+    minLength?: number;
+    maxLength?: number;
+    dataSource?: Record<string, unknown>;
+    displayFields?: string[];
+    searchConfig?: Record<string, unknown>;
+    hiddenCalculations?: Array<{
+        variable: string;
+        expression: unknown;
+        scope?: string;
+    }>;
+    signatureConfig?: Record<string, unknown>;
+    displayTemplate?: Record<string, unknown>;
+    lawReference?: Record<string, unknown>;
+    contextMenu?: string[];
+    calculated?: Record<string, unknown>;
+    readOnly?: boolean;
+    minDate?: unknown;
+    stats?: Array<{
+        label: string;
+        value: unknown;
+        icon?: string;
+    }>;
+    items?: Array<{
+        id: string;
+        label: string;
+        autoCheck?: unknown;
+    }>;
+    [key: string]: unknown;
+}
+/** Section within a wizard step */
+export interface WizardSection {
+    id: string;
+    title?: string;
+    description?: string;
+    fields?: WizardField[];
+    subsections?: WizardSection[];
+    condition?: unknown[];
+    repeatable?: boolean;
+    minItems?: number;
+    addButtonLabel?: string;
+    hiddenCalculations?: Array<{
+        variable: string;
+        expression: unknown;
+        scope?: string;
+    }>;
+    dataSource?: Record<string, unknown>;
+    readOnly?: boolean;
+    [key: string]: unknown;
+}
+/** Entity mapping configuration */
+export interface WizardEntityMapping {
+    entity: string;
+    mode: "search_or_create" | "create_multiple" | "select_one" | "update" | string;
+    parentField?: string;
+    idField?: string;
+    [key: string]: unknown;
+}
+/** Validation rule for wizard steps */
+export interface WizardValidationRule {
+    condition: unknown[];
+    message: string;
+}
+/** Law reference for compliance */
+export interface WizardLawReference {
+    law: string;
+    article: string;
+    description?: string;
+}
+export interface WizardStep {
+    /** Step identifier */
+    id?: string;
+    /** Tab identifier (schema-driven) */
+    tabId?: string;
+    /** Step title */
+    title?: string;
+    /** Step name (schema-driven, used as title if title not provided) */
+    name?: string;
+    /** Step description (optional) */
+    description?: string;
+    /** Step content (React component mode) */
+    content?: React.ReactNode;
+    /** Whether this step can be skipped */
+    optional?: boolean;
+    /** Custom validation for this step */
+    isValid?: () => boolean;
+    /** Form sections within this step */
+    sections?: WizardSection[];
+    /** Global variables required before entering this step */
+    globalVariablesRequired?: string[];
+    /** Global variables set by this step */
+    globalVariablesSet?: string[];
+    /** Local variables scoped to this step */
+    localVariables?: string[];
+    /** Entity mapping configuration */
+    entityMapping?: WizardEntityMapping;
+    /** Validation rules for this step */
+    validationRules?: WizardValidationRule[];
+    /** Law references for compliance */
+    lawReferences?: WizardLawReference[];
+    /** Phase of the inspection process */
+    phase?: string;
+    /** Context menu actions */
+    contextMenu?: string[];
+    /** Allow additional properties from schema */
+    [key: string]: unknown;
+}
+export interface WizardContainerProps {
+    /** Wizard steps */
+    steps: WizardStep[];
+    /** Current step index (controlled) - accepts unknown for generated code compatibility */
+    currentStep?: number | string | unknown;
+    /** Callback when step changes */
+    onStepChange?: (stepIndex: number) => void;
+    /** Callback when wizard is completed */
+    onComplete?: () => void;
+    /** Show progress indicator */
+    showProgress?: boolean;
+    /** Allow navigation to previous steps */
+    allowBack?: boolean;
+    /** Modal mode (compact header, no padding) */
+    compact?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** Loading state indicator */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Entity type name (schema-driven) */
+    entity?: string;
+}
+/**
+ * WizardContainer - Multi-step wizard
+ */
+export declare const WizardContainer: React.FC<WizardContainerProps>;
+export default WizardContainer;

package/dist/components/organisms/book/BookChapterView.d.ts

@@ -0,0 +1,17 @@
+/**
+ * BookChapterView Organism
+ *
+ * Renders a single chapter: title + optional orbital diagram +
+ * rich content via ContentRenderer.
+ *
+ * Event Contract:
+ * - Delegates to ContentRenderer children
+ */
+import React from 'react';
+import type { EntityDisplayProps } from '../types';
+import type { BookChapter } from './types';
+export interface BookChapterViewProps extends EntityDisplayProps {
+    chapter: BookChapter;
+    direction?: 'rtl' | 'ltr';
+}
+export declare const BookChapterView: React.FC<BookChapterViewProps>;

package/dist/components/organisms/book/BookCoverPage.d.ts

@@ -0,0 +1,19 @@
+/**
+ * BookCoverPage Molecule
+ *
+ * Renders a book cover with title, subtitle, author, and optional image.
+ * Centered layout suitable for the first "page" of a BookViewer.
+ *
+ * Event Contract:
+ * - Emits: UI:BOOK_START
+ */
+import React from 'react';
+import type { EntityDisplayProps } from '../types';
+export interface BookCoverPageProps extends EntityDisplayProps {
+    title: string;
+    subtitle?: string;
+    author?: string;
+    coverImageUrl?: string;
+    direction?: 'rtl' | 'ltr';
+}
+export declare const BookCoverPage: React.FC<BookCoverPageProps>;

package/dist/components/organisms/book/BookNavBar.d.ts

@@ -0,0 +1,18 @@
+/**
+ * BookNavBar Molecule
+ *
+ * Navigation bar for the BookViewer with prev/next, page indicator,
+ * print button, and TOC toggle.
+ *
+ * Event Contract:
+ * - Emits: UI:BOOK_PAGE_PREV, UI:BOOK_PAGE_NEXT, UI:BOOK_PRINT, UI:BOOK_SHOW_TOC
+ */
+import React from 'react';
+import type { EntityDisplayProps } from '../types';
+export interface BookNavBarProps extends EntityDisplayProps {
+    currentPage: number;
+    totalPages: number;
+    chapterTitle?: string;
+    direction?: 'rtl' | 'ltr';
+}
+export declare const BookNavBar: React.FC<BookNavBarProps>;

package/dist/components/organisms/book/BookTableOfContents.d.ts

@@ -0,0 +1,18 @@
+/**
+ * BookTableOfContents Molecule
+ *
+ * Renders a clickable table of contents grouped by parts.
+ * Highlights the current chapter.
+ *
+ * Event Contract:
+ * - Emits: UI:BOOK_NAVIGATE { chapterId }
+ */
+import React from 'react';
+import type { EntityDisplayProps } from '../types';
+import type { BookPart } from './types';
+export interface BookTableOfContentsProps extends EntityDisplayProps {
+    parts: BookPart[];
+    currentChapterId?: string;
+    direction?: 'rtl' | 'ltr';
+}
+export declare const BookTableOfContents: React.FC<BookTableOfContentsProps>;

package/dist/components/organisms/book/BookViewer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * BookViewer Organism
+ *
+ * Flippable book reader with cover, TOC, chapter views, and navigation.
+ * Supports RTL layout (Arabic), CSS slide transitions, and print mode.
+ *
+ * Page model:
+ *   0 = cover, 1 = TOC, 2+ = chapters (flattened from parts)
+ *
+ * Field mapping:
+ *   Entity data may use non-English field names (e.g. Arabic .orb schemas).
+ *   Pass a `fieldMap` prop to translate entity fields to canonical BookData.
+ *   Default: IDENTITY_BOOK_FIELDS (English field names, no translation).
+ *
+ * Event Contract:
+ * - Emits: UI:BOOK_PAGE_CHANGE { pageIndex, chapterId? }
+ * - Listens: UI:BOOK_START, UI:BOOK_NAVIGATE, UI:BOOK_PAGE_PREV/NEXT, UI:BOOK_PRINT, UI:BOOK_SHOW_TOC
+ */
+import React from 'react';
+import type { EntityDisplayProps } from '../types';
+import type { BookFieldMap } from './types';
+export interface BookViewerProps extends EntityDisplayProps {
+    /** Initial page index (default: 0 = cover) */
+    initialPage?: number;
+    /** Field name translation map — a BookFieldMap object or locale key ("ar") */
+    fieldMap?: BookFieldMap | string;
+}
+export declare const BookViewer: React.FC<BookViewerProps>;

package/dist/components/organisms/book/index.d.ts

@@ -0,0 +1,7 @@
+export { BookViewer, type BookViewerProps } from './BookViewer';
+export { BookChapterView, type BookChapterViewProps } from './BookChapterView';
+export { BookCoverPage, type BookCoverPageProps } from './BookCoverPage';
+export { BookTableOfContents, type BookTableOfContentsProps } from './BookTableOfContents';
+export { BookNavBar, type BookNavBarProps } from './BookNavBar';
+export type { BookData, BookPart, BookChapter, BookFieldMap } from './types';
+export { mapBookData, resolveFieldMap, IDENTITY_BOOK_FIELDS, AR_BOOK_FIELDS } from './types';

package/dist/components/organisms/book/types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * BookViewer shared types
+ *
+ * Field names are canonical English. When entity data arrives from a
+ * schema with non-English field names (e.g. Arabic .orb), a field map
+ * translates them before passing to BookViewer. See `mapBookData()`.
+ */
+export interface BookData {
+    title: string;
+    subtitle?: string;
+    author?: string;
+    coverImageUrl?: string;
+    direction?: 'rtl' | 'ltr';
+    parts: BookPart[];
+}
+export interface BookPart {
+    title: string;
+    chapters: BookChapter[];
+}
+export interface BookChapter {
+    id: string;
+    title: string;
+    content: string;
+    orbitalSchema?: unknown;
+}
+/**
+ * Maps raw entity field names to canonical BookData field names.
+ * Each key is a canonical field, each value is the entity field name.
+ *
+ * @example
+ * ```ts
+ * // Arabic schema
+ * const AR_BOOK_FIELDS: BookFieldMap = {
+ *   title: 'العنوان',
+ *   subtitle: 'العنوان_الفرعي',
+ *   author: 'المؤلف',
+ *   coverImageUrl: 'صورة_الغلاف',
+ *   direction: 'الاتجاه',
+ *   parts: 'الأجزاء',
+ *   partTitle: 'العنوان',
+ *   chapters: 'الفصول',
+ *   chapterId: 'المعرف',
+ *   chapterTitle: 'العنوان',
+ *   chapterContent: 'المحتوى',
+ *   chapterOrbitalSchema: 'المخطط_المداري',
+ * };
+ * ```
+ */
+export interface BookFieldMap {
+    title: string;
+    subtitle: string;
+    author: string;
+    coverImageUrl: string;
+    direction: string;
+    parts: string;
+    partTitle: string;
+    chapters: string;
+    chapterId: string;
+    chapterTitle: string;
+    chapterContent: string;
+    chapterOrbitalSchema: string;
+}
+/** Identity map — entity already uses canonical English field names */
+export declare const IDENTITY_BOOK_FIELDS: BookFieldMap;
+/** Arabic field map for الأمة_الرقمية schema */
+export declare const AR_BOOK_FIELDS: BookFieldMap;
+/**
+ * Resolves a fieldMap prop to a BookFieldMap object.
+ * Accepts a BookFieldMap object directly, a locale string key ("ar"),
+ * or undefined (defaults to identity/English).
+ */
+export declare function resolveFieldMap(fieldMap: BookFieldMap | string | undefined): BookFieldMap;
+/**
+ * Maps a raw entity record to a typed BookData using a field map.
+ * Pass `IDENTITY_BOOK_FIELDS` for English schemas, `AR_BOOK_FIELDS` for Arabic, etc.
+ */
+export declare function mapBookData(raw: Record<string, unknown>, fields?: BookFieldMap): BookData;

package/dist/components/organisms/game/BattleBoard.d.ts

@@ -0,0 +1,167 @@
+/**
+ * BattleBoard
+ *
+ * Core rendering organism for turn-based battles.
+ *
+ * This is a **controlled-only** component: all game state (units, phase,
+ * turn, gameResult, selectedUnitId) must be provided via the `entity` prop.
+ * User interactions are communicated via event bus emissions so the parent
+ * (typically an Orbital trait or the `useBattleState` hook) can manage
+ * state transitions.
+ *
+ * For a self-managing version, use `UncontrolledBattleBoard` which
+ * composes this component with the `useBattleState` hook.
+ *
+ * Animation-only state (movement interpolation, screen shake, hover) is
+ * always managed locally.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import type { IsometricTile, IsometricFeature } from './types/isometric';
+import type { ResolvedFrame } from './types/spriteAnimation';
+/** Battle phases an encounter walks through */
+export type BattlePhase = 'observation' | 'selection' | 'movement' | 'action' | 'enemy_turn' | 'game_over';
+/** A unit participating in battle */
+export interface BattleUnit {
+    id: string;
+    name: string;
+    unitType?: string;
+    heroId?: string;
+    sprite?: string;
+    team: 'player' | 'enemy';
+    position: {
+        x: number;
+        y: number;
+    };
+    health: number;
+    maxHealth: number;
+    movement: number;
+    attack: number;
+    defense: number;
+    traits?: {
+        name: string;
+        currentState: string;
+        states: string[];
+        cooldown?: number;
+    }[];
+}
+/** Minimal tile for map generation */
+export interface BattleTile {
+    x: number;
+    y: number;
+    terrain: string;
+    terrainSprite?: string;
+}
+/** Entity prop containing all board data.
+ *
+ * BattleBoard is **controlled-only**: all game-state fields (`units`, `phase`,
+ * `turn`, `gameResult`, `selectedUnitId`) must be provided.  Mutations are
+ * communicated via event bus emissions — the component never calls `setState`
+ * for game-logic values.
+ *
+ * For a self-managing variant, use `UncontrolledBattleBoard`.
+ *
+ * Animation-only state (`movingPositions`, `isShaking`, `hoveredTile`) is
+ * always managed locally.
+ */
+export interface BattleEntity {
+    id: string;
+    tiles: IsometricTile[];
+    features?: IsometricFeature[];
+    boardWidth?: number;
+    boardHeight?: number;
+    assetManifest?: {
+        baseUrl: string;
+        terrains?: Record<string, string>;
+        units?: Record<string, string>;
+        features?: Record<string, string>;
+        effects?: Record<string, string>;
+    };
+    backgroundImage?: string;
+    /** Current unit state. */
+    units: BattleUnit[];
+    /** Current battle phase. */
+    phase: BattlePhase;
+    /** Current turn number. */
+    turn: number;
+    /** Game result. `null` = still in progress. */
+    gameResult: 'victory' | 'defeat' | null;
+    /** Currently selected unit ID. */
+    selectedUnitId: string | null;
+}
+/** Context exposed to render-prop slots */
+export interface BattleSlotContext {
+    phase: BattlePhase;
+    turn: number;
+    selectedUnit: BattleUnit | null;
+    hoveredUnit: BattleUnit | null;
+    playerUnits: BattleUnit[];
+    enemyUnits: BattleUnit[];
+    gameResult: 'victory' | 'defeat' | null;
+    onEndTurn: () => void;
+    onCancel: () => void;
+    onReset: () => void;
+    attackTargets: Array<{
+        x: number;
+        y: number;
+    }>;
+    /** Resolve screen position of a tile for overlays */
+    tileToScreen: (x: number, y: number) => {
+        x: number;
+        y: number;
+    };
+}
+export interface BattleBoardProps {
+    /** Entity containing all board data */
+    entity: BattleEntity;
+    /** Canvas render scale */
+    scale?: number;
+    /** Unit draw-size multiplier */
+    unitScale?: number;
+    /** Header area -- receives battle context */
+    header?: (ctx: BattleSlotContext) => React.ReactNode;
+    /** Sidebar content (combat log, unit roster, etc.) */
+    sidebar?: (ctx: BattleSlotContext) => React.ReactNode;
+    /** Floating action buttons */
+    actions?: (ctx: BattleSlotContext) => React.ReactNode;
+    /** Floating overlays above the canvas (damage popups, tooltips) */
+    overlay?: (ctx: BattleSlotContext) => React.ReactNode;
+    /** Game-over screen overlay */
+    gameOverOverlay?: (ctx: BattleSlotContext) => React.ReactNode;
+    /** Called when a unit attacks another */
+    onAttack?: (attacker: BattleUnit, target: BattleUnit, damage: number) => void;
+    /** Called when battle ends */
+    onGameEnd?: (result: 'victory' | 'defeat') => void;
+    /** Called after a unit moves */
+    onUnitMove?: (unit: BattleUnit, to: {
+        x: number;
+        y: number;
+    }) => void;
+    /** Custom combat damage calculator */
+    calculateDamage?: (attacker: BattleUnit, target: BattleUnit) => number;
+    onDrawEffects?: (ctx: CanvasRenderingContext2D, timestamp: number) => void;
+    hasActiveEffects?: boolean;
+    effectSpriteUrls?: string[];
+    resolveUnitFrame?: (unitId: string) => ResolvedFrame | null;
+    /** Emits UI:{tileClickEvent} with { x, y } on tile click */
+    tileClickEvent?: string;
+    /** Emits UI:{unitClickEvent} with { unitId } on unit click */
+    unitClickEvent?: string;
+    /** Emits UI:{endTurnEvent} with {} on end turn */
+    endTurnEvent?: string;
+    /** Emits UI:{cancelEvent} with {} on cancel */
+    cancelEvent?: string;
+    /** Emits UI:{gameEndEvent} with { result } on game end */
+    gameEndEvent?: string;
+    /** Emits UI:{playAgainEvent} with {} on play again / reset */
+    playAgainEvent?: string;
+    /** Emits UI:{attackEvent} with { attackerId, targetId, damage } on attack */
+    attackEvent?: string;
+    className?: string;
+}
+export declare function BattleBoard({ entity, scale, unitScale, header, sidebar, actions, overlay, gameOverOverlay, onAttack, onGameEnd, onUnitMove, calculateDamage, onDrawEffects, hasActiveEffects, effectSpriteUrls, resolveUnitFrame, tileClickEvent, unitClickEvent, endTurnEvent, cancelEvent, gameEndEvent, playAgainEvent, attackEvent, className, }: BattleBoardProps): React.JSX.Element;
+export declare namespace BattleBoard {
+    var displayName: string;
+}
+export default BattleBoard;

package/dist/components/organisms/game/CanvasEffect.d.ts

@@ -0,0 +1,68 @@
+/**
+ * CanvasEffect Component
+ *
+ * Renders animated visual effects using a `<canvas>` element with
+ * sprite-based particles, frame-sequence animations, and overlays.
+ * This is a render-ui pattern that can be placed in any slot —
+ * it renders on top of whatever occupies that slot.
+ *
+ * Pattern: canvas-effect
+ *
+ * When an EffectAssetManifest is provided (via assetManifest prop),
+ * the component uses the full particle engine with tinted sprites.
+ * Without a manifest, it falls back to emoji-based rendering.
+ *
+ * **State categories (closed-circuit compliant):**
+ * - Configuration (actionType, position, duration, manifest) → received via props
+ * - Animation state (particles, shake, flash, RAF loop, phase timers) → local only
+ * - Completion event → emitted via `useEventBus()` for trait integration
+ *
+ * This is an **ephemeral fire-and-forget** animation component.  All
+ * internal state is rendering-only (particle physics, screen shake decay,
+ * flash alpha, emoji phase timers).  No game logic lives here.
+ *
+ * @packageDocumentation
+ */
+import * as React from 'react';
+import type { CombatActionType, EffectAssetManifest } from './types/effects';
+export type { CombatActionType } from './types/effects';
+export type { EffectAssetManifest } from './types/effects';
+export interface CanvasEffectProps {
+    /** The type of combat action to visualise */
+    actionType: CombatActionType;
+    /** Screen-space X position (center of the effect) */
+    x: number;
+    /** Screen-space Y position (center of the effect) */
+    y: number;
+    /** Duration in ms before auto-dismiss (default 2000 for canvas, 800 for emoji) */
+    duration?: number;
+    /** Optional intensity multiplier (1 = normal, 2 = double size/brightness) */
+    intensity?: number;
+    /** Callback when the effect animation completes */
+    onComplete?: () => void;
+    /** Declarative event: emits UI:{completeEvent} when the effect animation completes */
+    completeEvent?: string;
+    /** Additional CSS classes */
+    className?: string;
+    /** Loading state indicator */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Sprite URL for the effect (emoji fallback mode).
+     *  When set without assetManifest, renders this image instead of emoji. */
+    effectSpriteUrl?: string;
+    /** Base URL for remote assets. Prepended to relative effectSpriteUrl paths. */
+    assetBaseUrl?: string;
+    /** Full effect asset manifest for the sprite particle engine.
+     *  When provided, enables the canvas-based particle system. */
+    assetManifest?: EffectAssetManifest;
+    /** Canvas width (default 400) */
+    width?: number;
+    /** Canvas height (default 300) */
+    height?: number;
+}
+export declare function CanvasEffect(props: CanvasEffectProps): React.JSX.Element | null;
+export declare namespace CanvasEffect {
+    var displayName: string;
+}
+export default CanvasEffect;

package/dist/components/organisms/game/CastleBoard.d.ts

@@ -0,0 +1,85 @@
+/**
+ * CastleBoard
+ *
+ * Self-contained castle / base-management game board organism. Encapsulates all
+ * isometric canvas rendering, hover/selection state, and slot-based layout.
+ * Designed to be consumed by CastleTemplate (thin wrapper) or embedded directly
+ * in any page that needs an isometric castle view.
+ *
+ * Accepts an `entity` prop conforming to `CastleEntity` and optional declarative
+ * event props (`featureClickEvent`, `unitClickEvent`, `tileClickEvent`) that
+ * emit through the Orbital event bus.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import type { IsometricTile, IsometricUnit, IsometricFeature } from './types/isometric';
+/** Entity shape consumed by CastleBoard */
+export interface CastleEntity {
+    id: string;
+    tiles: IsometricTile[];
+    features?: IsometricFeature[];
+    units?: IsometricUnit[];
+    assetManifest?: {
+        baseUrl: string;
+        terrains?: Record<string, string>;
+        units?: Record<string, string>;
+        features?: Record<string, string>;
+    };
+    backgroundImage?: string;
+}
+/** Context exposed to render-prop slots */
+export interface CastleSlotContext {
+    /** Currently hovered tile coordinates (null when not hovering) */
+    hoveredTile: {
+        x: number;
+        y: number;
+    } | null;
+    /** Feature that sits on the hovered tile, if any */
+    hoveredFeature: IsometricFeature | null;
+    /** Unit that sits on the hovered tile, if any */
+    hoveredUnit: IsometricUnit | null;
+    /** The clicked feature (e.g. building) for detail view */
+    selectedFeature: IsometricFeature | null;
+    /** Clear selected feature */
+    clearSelection: () => void;
+    /** Resolve screen position for overlay positioning */
+    tileToScreen: (x: number, y: number) => {
+        x: number;
+        y: number;
+    };
+    /** Canvas scale */
+    scale: number;
+}
+export interface CastleBoardProps {
+    /** Castle entity data */
+    entity: CastleEntity;
+    /** Canvas render scale */
+    scale?: number;
+    /** Top bar / header */
+    header?: (ctx: CastleSlotContext) => React.ReactNode;
+    /** Side panel content (buildings list, recruit tab, garrison tab) */
+    sidePanel?: (ctx: CastleSlotContext) => React.ReactNode;
+    /** Canvas overlay (hover tooltips, etc.) */
+    overlay?: (ctx: CastleSlotContext) => React.ReactNode;
+    /** Bottom bar (income summary, etc.) */
+    footer?: (ctx: CastleSlotContext) => React.ReactNode;
+    /** Called when a feature (building) is clicked */
+    onFeatureClick?: (feature: IsometricFeature) => void;
+    /** Called when a unit is clicked */
+    onUnitClick?: (unit: IsometricUnit) => void;
+    /** Called when any tile is clicked */
+    onTileClick?: (x: number, y: number) => void;
+    /** Event name to emit via event bus when a feature is clicked (emits UI:{featureClickEvent}) */
+    featureClickEvent?: string;
+    /** Event name to emit via event bus when a unit is clicked (emits UI:{unitClickEvent}) */
+    unitClickEvent?: string;
+    /** Event name to emit via event bus when a tile is clicked (emits UI:{tileClickEvent}) */
+    tileClickEvent?: string;
+    className?: string;
+}
+export declare function CastleBoard({ entity, scale, header, sidePanel, overlay, footer, onFeatureClick, onUnitClick, onTileClick, featureClickEvent, unitClickEvent, tileClickEvent, className, }: CastleBoardProps): React.JSX.Element;
+export declare namespace CastleBoard {
+    var displayName: string;
+}
+export default CastleBoard;