@nice2dev/game-engine 1.3.13 → 1.3.14

package/dist/types/editor/NiceNodeGraph.d.ts

@@ -1,87 +0,0 @@
-import React from 'react';
-import { VisualScriptGraph } from '../visual-scripting/VisualScriptGraph';
-export interface NodePosition {
-    x: number;
-    y: number;
-}
-export interface NodeGraphTheme {
-    background: string;
-    gridColor: string;
-    gridMajorColor: string;
-    nodeBackground: string;
-    nodeBorder: string;
-    nodeSelectedBorder: string;
-    nodeHeaderBackground: string;
-    pinExecution: string;
-    pinBoolean: string;
-    pinNumber: string;
-    pinString: string;
-    pinVector: string;
-    pinObject: string;
-    pinArray: string;
-    pinAny: string;
-    connectionLine: string;
-    connectionLineExecution: string;
-    textPrimary: string;
-    textSecondary: string;
-    groupBackground: string;
-    groupBorder: string;
-    breakpointColor: string;
-    executionHighlight: string;
-}
-export interface NodeCategory {
-    id: string;
-    name: string;
-    icon: string;
-    color: string;
-}
-export interface NodeGraphState {
-    zoom: number;
-    panOffset: NodePosition;
-    selectedNodes: string[];
-    hoveredNode: string | null;
-    hoveredPin: {
-        nodeId: string;
-        pinId: string;
-        isOutput: boolean;
-    } | null;
-    draggingNode: string | null;
-    connecting: {
-        sourceNodeId: string;
-        sourcePinId: string;
-        isOutput: boolean;
-        mousePos: NodePosition;
-    } | null;
-    selectionBox: {
-        start: NodePosition;
-        end: NodePosition;
-    } | null;
-    contextMenu: {
-        x: number;
-        y: number;
-        type: 'canvas' | 'node' | 'connection';
-        targetId?: string;
-    } | null;
-    searchQuery: string;
-    showLibrary: boolean;
-    showVariables: boolean;
-    showCodePreview: boolean;
-    activeBreakpoints: Set<string>;
-    executingNode: string | null;
-}
-export interface NiceNodeGraphProps {
-    graph?: VisualScriptGraph;
-    theme?: Partial<NodeGraphTheme>;
-    readOnly?: boolean;
-    onGraphChange?: (graph: VisualScriptGraph) => void;
-    className?: string;
-    style?: React.CSSProperties;
-}
-export interface NiceNodeGraphRef {
-    getGraph: () => VisualScriptGraph;
-    addNode: (typeId: string, position: NodePosition) => void;
-    zoomToFit: () => void;
-    clearSelection: () => void;
-}
-export declare const NiceNodeGraph: React.ForwardRefExoticComponent<NiceNodeGraphProps & React.RefAttributes<NiceNodeGraphRef>>;
-export default NiceNodeGraph;

package/dist/types/editor/NiceParticleEditor.d.ts

@@ -1,127 +0,0 @@
-import { type NiceComponentTutorial } from '@nice2dev/ui';
-import React from 'react';
-export interface ParticleCurve {
-    type: 'constant' | 'linear' | 'curve' | 'randomBetweenCurves';
-    value?: number;
-    min?: number;
-    max?: number;
-    keys?: Array<{
-        time: number;
-        value: number;
-        inTangent?: number;
-        outTangent?: number;
-    }>;
-    keys2?: Array<{
-        time: number;
-        value: number;
-        inTangent?: number;
-        outTangent?: number;
-    }>;
-}
-export interface ParticleGradient {
-    type: 'constant' | 'gradient' | 'randomBetweenGradients';
-    color?: {
-        r: number;
-        g: number;
-        b: number;
-        a: number;
-    };
-    keys?: Array<{
-        time: number;
-        color: {
-            r: number;
-            g: number;
-            b: number;
-            a: number;
-        };
-    }>;
-    keys2?: Array<{
-        time: number;
-        color: {
-            r: number;
-            g: number;
-            b: number;
-            a: number;
-        };
-    }>;
-}
-export interface EmitterShape {
-    type: 'sphere' | 'hemisphere' | 'cone' | 'box' | 'circle' | 'edge' | 'mesh';
-    radius?: number;
-    angle?: number;
-    arc?: number;
-    length?: number;
-    boxSize?: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    emitFromShell?: boolean;
-    randomDirection?: boolean;
-}
-export interface ParticleModule {
-    id: string;
-    type: ParticleModuleType;
-    enabled: boolean;
-    properties: Record<string, unknown>;
-}
-export type ParticleModuleType = 'emission' | 'shape' | 'velocity' | 'lifetime' | 'speed' | 'size' | 'rotation' | 'color' | 'gravity' | 'noise' | 'collision' | 'subEmitters' | 'textureSheet' | 'trails' | 'lights' | 'customData';
-export interface ParticleSystemData {
-    id: string;
-    name: string;
-    duration: number;
-    looping: boolean;
-    prewarm: boolean;
-    startDelay: ParticleCurve;
-    startLifetime: ParticleCurve;
-    startSpeed: ParticleCurve;
-    startSize: ParticleCurve;
-    startRotation: ParticleCurve;
-    startColor: ParticleGradient;
-    gravityModifier: ParticleCurve;
-    simulationSpace: 'local' | 'world';
-    simulationSpeed: number;
-    maxParticles: number;
-    playOnAwake: boolean;
-    modules: ParticleModule[];
-    renderMode: 'billboard' | 'stretchedBillboard' | 'horizontalBillboard' | 'verticalBillboard' | 'mesh';
-    material?: string;
-    mesh?: string;
-    sortMode: 'none' | 'distance' | 'oldestFirst' | 'youngestFirst';
-    blendMode: 'additive' | 'alpha' | 'multiply' | 'premultiply';
-}
-export interface ParticleEditorTheme {
-    background: string;
-    panelBackground: string;
-    headerBackground: string;
-    moduleBackground: string;
-    moduleBackgroundAlt: string;
-    moduleHeader: string;
-    previewBackground: string;
-    gridColor: string;
-    curveColor: string;
-    curveHandle: string;
-    gradientTrack: string;
-    textPrimary: string;
-    textSecondary: string;
-    accent: string;
-    danger: string;
-}
-export interface NiceParticleEditorProps {
-    system?: ParticleSystemData;
-    theme?: Partial<ParticleEditorTheme>;
-    readOnly?: boolean;
-    onSystemChange?: (system: ParticleSystemData) => void;
-    className?: string;
-    style?: React.CSSProperties;
-    /** Optional "?" guided tour. Off by default; `true` uses the built-in tour. */
-    tutorial?: NiceComponentTutorial;
-}
-export interface NiceParticleEditorRef {
-    getSystem: () => ParticleSystemData;
-    play: () => void;
-    pause: () => void;
-    restart: () => void;
-}
-export declare const NiceParticleEditor: React.ForwardRefExoticComponent<NiceParticleEditorProps & React.RefAttributes<NiceParticleEditorRef>>;
-export default NiceParticleEditor;

package/dist/types/editor/behavior-tree/BTDebugPanel.d.ts

@@ -1,102 +0,0 @@
-/**
- * @file Behavior Tree Editor - Debug Panel
- * @description Debug panel for runtime inspection and debugging
- * PRO-1.4: Professional Editor Features
- */
-import type { BTStatus } from '../../ai/BehaviorTree';
-import type { BTDebugState, BTWatchExpression, BTExecutionStep, BTDebugStatistics } from './types';
-export declare class BTDebugPanel {
-    private state;
-    private listeners;
-    onStartDebug?: () => void;
-    onStopDebug?: () => void;
-    onStepDebug?: () => void;
-    onPauseDebug?: () => void;
-    onResumeDebug?: () => void;
-    onAddBreakpoint?: (nodeId: string) => void;
-    onRemoveBreakpoint?: (nodeId: string) => void;
-    constructor();
-    private createInitialState;
-    /** Start debugging */
-    start(): void;
-    /** Stop debugging */
-    stop(): void;
-    /** Step one tick */
-    step(): void;
-    /** Pause execution */
-    pause(): void;
-    /** Resume execution */
-    resume(): void;
-    /** Toggle pause state */
-    togglePause(): void;
-    /** Update debug state from runtime */
-    updateState(updates: Partial<BTDebugState>): void;
-    /** Set current node being executed */
-    setCurrentNode(nodeId: string | undefined): void;
-    /** Update blackboard snapshot */
-    updateBlackboard(snapshot: Record<string, unknown>): void;
-    /** Record execution step */
-    recordStep(step: BTExecutionStep): void;
-    /** Update statistics */
-    updateStatistics(updates: Partial<BTDebugStatistics>): void;
-    /** Add breakpoint */
-    addBreakpoint(nodeId: string): void;
-    /** Remove breakpoint */
-    removeBreakpoint(nodeId: string): void;
-    /** Toggle breakpoint */
-    toggleBreakpoint(nodeId: string): void;
-    /** Clear all breakpoints */
-    clearBreakpoints(): void;
-    /** Check if node has breakpoint */
-    hasBreakpoint(nodeId: string): boolean;
-    /** Add watch expression */
-    addWatch(expression: string): BTWatchExpression;
-    /** Remove watch expression */
-    removeWatch(watchId: string): void;
-    /** Update watch expression */
-    updateWatch(watchId: string, expression: string): void;
-    /** Clear all watches */
-    clearWatches(): void;
-    /** Evaluate a watch expression */
-    private evaluateWatch;
-    /** Re-evaluate all watches */
-    evaluateWatches(): void;
-    /** Get execution history */
-    getHistory(): BTExecutionStep[];
-    /** Clear execution history */
-    clearHistory(): void;
-    /** Get history for specific node */
-    getNodeHistory(nodeId: string): BTExecutionStep[];
-    /** Get last N steps */
-    getRecentHistory(count?: number): BTExecutionStep[];
-    /** Get statistics */
-    getStatistics(): BTDebugStatistics;
-    /** Get node execution count */
-    getNodeExecutionCount(nodeId: string): number;
-    /** Get node failure count */
-    getNodeFailureCount(nodeId: string): number;
-    /** Get node success rate */
-    getNodeSuccessRate(nodeId: string): number;
-    /** Get full state */
-    getState(): BTDebugState;
-    /** Check if debugging */
-    isDebugging(): boolean;
-    /** Check if paused */
-    isPaused(): boolean;
-    /** Get current node */
-    getCurrentNodeId(): string | undefined;
-    /** Subscribe to state changes */
-    subscribe(listener: () => void): () => void;
-    private notifyListeners;
-}
-export declare function createBTDebugPanel(): BTDebugPanel;
-/** Get status display info */
-export declare function getStatusInfo(status: BTStatus): {
-    label: string;
-    color: string;
-    icon: string;
-};
-/** Format execution time */
-export declare function formatExecutionTime(ms: number): string;
-/** Format blackboard value for display */
-export declare function formatBlackboardValue(value: unknown): string;

package/dist/types/editor/behavior-tree/BTEditorCanvas.d.ts

@@ -1,79 +0,0 @@
-/**
- * @file Behavior Tree Editor - Canvas
- * @description Canvas component for visual editing of behavior trees
- * PRO-1.4: Professional Editor Features
- */
-import type { Vec2 } from '../../core/types';
-import type { BehaviorTreeEditor } from './BehaviorTreeEditor';
-import { BTEditorNodeRenderer, BTConnectionRenderer } from './BTEditorNode';
-import type { BTEditorConfig } from './types';
-export interface BTEditorCanvasState {
-    isDragging: boolean;
-    isPanning: boolean;
-    isBoxSelecting: boolean;
-    dragStartPosition: Vec2 | null;
-    dragStartNodePositions: Map<string, Vec2>;
-    boxSelectStart: Vec2 | null;
-    boxSelectEnd: Vec2 | null;
-    hoveredNodeId: string | null;
-    hoveredConnectionId: string | null;
-    contextMenuPosition: Vec2 | null;
-}
-export declare class BTEditorCanvas {
-    private canvas;
-    private ctx;
-    private editor;
-    private config;
-    private nodeRenderer;
-    private connectionRenderer;
-    private state;
-    private animationFrameId;
-    private resizeObserver;
-    onNodeClick?: (nodeId: string, event: MouseEvent) => void;
-    onNodeDoubleClick?: (nodeId: string, event: MouseEvent) => void;
-    onNodeContextMenu?: (nodeId: string, position: Vec2, event: MouseEvent) => void;
-    onConnectionContextMenu?: (connectionId: string, position: Vec2, event: MouseEvent) => void;
-    onCanvasContextMenu?: (position: Vec2, event: MouseEvent) => void;
-    onDrop?: (dataTransfer: DataTransfer, position: Vec2) => void;
-    constructor(canvas: HTMLCanvasElement, editor: BehaviorTreeEditor, config?: Partial<BTEditorConfig>);
-    /** Clean up resources */
-    dispose(): void;
-    private setupEventListeners;
-    private removeEventListeners;
-    private handleMouseDown;
-    private handleMouseMove;
-    private handleMouseUp;
-    private handleMouseLeave;
-    private handleWheel;
-    private handleDoubleClick;
-    private handleContextMenu;
-    private handleDragOver;
-    private handleDrop;
-    private handleKeyDown;
-    private startConnection;
-    private completeConnection;
-    private findNodeAtPosition;
-    private findConnectionAtPosition;
-    private updateHoverState;
-    private setupResizeObserver;
-    private resizeCanvas;
-    private startRenderLoop;
-    private render;
-    private renderGrid;
-    private renderBoxSelection;
-    private renderMinimap;
-    private getCanvasPosition;
-    private snapToGrid;
-    private normalizeRect;
-    /** Force redraw */
-    redraw(): void;
-    /** Get canvas element */
-    getCanvas(): HTMLCanvasElement;
-    /** Update configuration */
-    updateConfig(config: Partial<BTEditorConfig>): void;
-    /** Set custom node renderer */
-    setNodeRenderer(renderer: BTEditorNodeRenderer): void;
-    /** Set custom connection renderer */
-    setConnectionRenderer(renderer: BTConnectionRenderer): void;
-}
-export declare function createBTEditorCanvas(canvas: HTMLCanvasElement, editor: BehaviorTreeEditor, config?: Partial<BTEditorConfig>): BTEditorCanvas;

package/dist/types/editor/behavior-tree/BTEditorNode.d.ts

@@ -1,58 +0,0 @@
-/**
- * @file Behavior Tree Editor - Editor Node
- * @description Visual representation of a behavior tree node in the editor
- * PRO-1.4: Professional Editor Features
- */
-import type { Vec2 } from '../../core/types';
-import type { BTEditorNodeData, BTEditorConfig } from './types';
-import { BT_NODE_COLORS, BT_STATUS_COLORS } from './types';
-export interface BTEditorNodeRenderer {
-    /** Render the node to a canvas context */
-    render(ctx: CanvasRenderingContext2D, node: BTEditorNodeData, config: BTEditorConfig): void;
-    /** Check if point is inside node */
-    hitTest(point: Vec2, node: BTEditorNodeData): boolean;
-    /** Check if point is on input connector */
-    hitTestInput(point: Vec2, node: BTEditorNodeData, config: BTEditorConfig): boolean;
-    /** Check if point is on output connector */
-    hitTestOutput(point: Vec2, node: BTEditorNodeData, config: BTEditorConfig): boolean;
-    /** Get input connector position */
-    getInputPosition(node: BTEditorNodeData, config: BTEditorConfig): Vec2;
-    /** Get output connector position */
-    getOutputPosition(node: BTEditorNodeData, config: BTEditorConfig): Vec2;
-}
-export declare class DefaultBTNodeRenderer implements BTEditorNodeRenderer {
-    private connectorRadius;
-    private connectorHitRadius;
-    render(ctx: CanvasRenderingContext2D, node: BTEditorNodeData, config: BTEditorConfig): void;
-    hitTest(point: Vec2, node: BTEditorNodeData): boolean;
-    hitTestInput(point: Vec2, node: BTEditorNodeData, config: BTEditorConfig): boolean;
-    hitTestOutput(point: Vec2, node: BTEditorNodeData, config: BTEditorConfig): boolean;
-    getInputPosition(node: BTEditorNodeData, config: BTEditorConfig): Vec2;
-    getOutputPosition(node: BTEditorNodeData, _config: BTEditorConfig): Vec2;
-    private drawConnector;
-    private drawBadge;
-    private roundRect;
-    private truncateText;
-    /** Small category marker drawn as a shape (no glyph fonts on the canvas). */
-    private drawCategoryMarker;
-}
-export interface BTConnectionRenderer {
-    /** Render connection */
-    render(ctx: CanvasRenderingContext2D, startPos: Vec2, endPos: Vec2, selected: boolean, active: boolean, config: BTEditorConfig): void;
-    /** Hit test connection */
-    hitTest(point: Vec2, startPos: Vec2, endPos: Vec2, config: BTEditorConfig): boolean;
-}
-export declare class DefaultBTConnectionRenderer implements BTConnectionRenderer {
-    render(ctx: CanvasRenderingContext2D, startPos: Vec2, endPos: Vec2, selected: boolean, active: boolean, config: BTEditorConfig): void;
-    hitTest(point: Vec2, startPos: Vec2, endPos: Vec2, config: BTEditorConfig): boolean;
-    private getBezierPoint;
-}
-export interface BTNodeTheme {
-    name: string;
-    colors: typeof BT_NODE_COLORS;
-    statusColors: typeof BT_STATUS_COLORS;
-}
-export declare const defaultTheme: BTNodeTheme;
-export declare const lightTheme: BTNodeTheme;
-export declare function createNodeRenderer(): BTEditorNodeRenderer;
-export declare function createConnectionRenderer(): BTConnectionRenderer;

package/dist/types/editor/behavior-tree/BTEditorToolbar.d.ts

@@ -1,75 +0,0 @@
-/**
- * @file Behavior Tree Editor - Toolbar
- * @description Toolbar component for editor actions
- * PRO-1.4: Professional Editor Features
- */
-import type { BehaviorTreeEditor } from './BehaviorTreeEditor';
-import type { BTEditorMode } from './types';
-export interface BTToolbarAction {
-    id: string;
-    label: string;
-    icon: string;
-    shortcut?: string;
-    tooltip?: string;
-    disabled?: boolean;
-    active?: boolean;
-    group?: string;
-    execute: () => void;
-}
-export interface BTToolbarGroup {
-    id: string;
-    label?: string;
-    actions: BTToolbarAction[];
-}
-export declare class BTEditorToolbar {
-    private editor;
-    private customActions;
-    private listeners;
-    constructor(editor: BehaviorTreeEditor);
-    /** Get all toolbar groups */
-    getGroups(): BTToolbarGroup[];
-    private getFileGroup;
-    private getEditGroup;
-    private getViewGroup;
-    private getLayoutGroup;
-    private getDebugGroup;
-    private getCustomGroups;
-    private handleDelete;
-    onSave?: () => void;
-    onExport?: () => void;
-    onImport?: () => void;
-    onValidate?: (result: {
-        valid: boolean;
-        errors: string[];
-        warnings: string[];
-    }) => void;
-    private triggerSave;
-    private triggerExport;
-    private triggerImport;
-    private triggerValidation;
-    /** Add custom toolbar action */
-    addAction(action: BTToolbarAction): void;
-    /** Remove custom toolbar action */
-    removeAction(actionId: string): void;
-    /** Get action by ID */
-    getAction(actionId: string): BTToolbarAction | undefined;
-    /** Execute action by ID */
-    executeAction(actionId: string): void;
-    /** Get all keyboard shortcuts */
-    getShortcuts(): Map<string, BTToolbarAction>;
-    /** Handle keyboard shortcut */
-    handleShortcut(event: KeyboardEvent): boolean;
-    private formatShortcut;
-    /** Update toolbar state */
-    update(): void;
-    /** Get current mode */
-    getMode(): BTEditorMode;
-    /** Check if modified */
-    isModified(): boolean;
-    /** Subscribe to state changes */
-    subscribe(listener: () => void): () => void;
-    private notifyListeners;
-}
-export declare function createBTEditorToolbar(editor: BehaviorTreeEditor): BTEditorToolbar;
-/** Toolbar icon id -> NiceIcon builtin name (render with `<NiceIcon name={…} />`). */
-export declare const TOOLBAR_ICONS: Record<string, string>;

package/dist/types/editor/behavior-tree/BTNodePalette.d.ts

@@ -1,72 +0,0 @@
-/**
- * @file Behavior Tree Editor - Node Palette
- * @description Node palette for selecting and adding nodes to the behavior tree
- * PRO-1.4: Professional Editor Features
- */
-import type { BTNodeDefinition, BTNodeType } from '../../ai/BehaviorTree';
-import type { BTPaletteCategory, BTPaletteNode } from './types';
-export interface BTNodePaletteState {
-    searchQuery: string;
-    expandedCategories: Set<BTNodeType>;
-    favorites: Set<string>;
-    recentlyUsed: string[];
-    maxRecentlyUsed: number;
-}
-export declare class BTNodePalette {
-    private definitions;
-    private state;
-    private listeners;
-    onNodeDragStart?: (definition: BTNodeDefinition, event: DragEvent) => void;
-    onNodeAdd?: (definition: BTNodeDefinition) => void;
-    constructor();
-    /** Set available node definitions */
-    setDefinitions(definitions: BTNodeDefinition[]): void;
-    /** Get all definitions */
-    getDefinitions(): BTNodeDefinition[];
-    /** Get definition by type */
-    getDefinition(type: string): BTNodeDefinition | undefined;
-    /** Get categories with filtered nodes */
-    getCategories(): BTPaletteCategory[];
-    private createCategory;
-    private toPaletteNode;
-    private generateSearchTerms;
-    /** Update search query */
-    setSearchQuery(query: string): void;
-    /** Get current search query */
-    getSearchQuery(): string;
-    /** Check if definition matches search */
-    private matchesSearch;
-    /** Get filtered nodes across all categories */
-    getFilteredNodes(): BTPaletteNode[];
-    /** Toggle category expansion */
-    toggleCategory(category: BTNodeType): void;
-    /** Expand all categories */
-    expandAll(): void;
-    /** Collapse all categories */
-    collapseAll(): void;
-    /** Toggle favorite status */
-    toggleFavorite(type: string): void;
-    /** Check if node is favorite */
-    isFavorite(type: string): boolean;
-    /** Get favorite nodes */
-    getFavorites(): BTPaletteNode[];
-    private loadFavorites;
-    private saveFavorites;
-    /** Add to recently used */
-    addRecentlyUsed(type: string): void;
-    /** Get recently used nodes */
-    getRecentlyUsed(): BTPaletteNode[];
-    /** Clear recently used */
-    clearRecentlyUsed(): void;
-    private loadRecentlyUsed;
-    private saveRecentlyUsed;
-    /** Handle node drag start */
-    handleDragStart(type: string, event: DragEvent): void;
-    /** Handle node click (add node) */
-    handleNodeClick(type: string): void;
-    /** Subscribe to state changes */
-    subscribe(listener: () => void): () => void;
-    private notifyListeners;
-}
-export declare function createBTNodePalette(): BTNodePalette;
-export declare function getBuiltInNodeDefinitions(): Partial<BTNodeDefinition>[];

package/dist/types/editor/behavior-tree/BTPropertyPanel.d.ts

@@ -1,66 +0,0 @@
-/**
- * @file Behavior Tree Editor - Property Panel
- * @description Property panel for editing selected node properties
- * PRO-1.4: Professional Editor Features
- */
-import type { BTNodeDefinition, BTPropertyDef } from '../../ai/BehaviorTree';
-import type { BTEditorNodeData, BTBlackboardKeyDef } from './types';
-export interface BTPropertyValue {
-    name: string;
-    value: unknown;
-    definition?: BTPropertyDef;
-    error?: string;
-    modified: boolean;
-}
-export interface BTPropertyPanelState {
-    selectedNode: BTEditorNodeData | null;
-    nodeDefinition: BTNodeDefinition | null;
-    properties: BTPropertyValue[];
-    blackboardKeys: BTBlackboardKeyDef[];
-    collapsed: boolean;
-}
-export declare class BTPropertyPanel {
-    private state;
-    private listeners;
-    onPropertyChange?: (nodeId: string, property: string, value: unknown) => void;
-    onNameChange?: (nodeId: string, name: string) => void;
-    onCommentChange?: (nodeId: string, comment: string) => void;
-    constructor();
-    /** Set the selected node */
-    setSelectedNode(node: BTEditorNodeData | null, definition: BTNodeDefinition | null): void;
-    /** Get selected node */
-    getSelectedNode(): BTEditorNodeData | null;
-    /** Set blackboard keys for key selection */
-    setBlackboardKeys(keys: BTBlackboardKeyDef[]): void;
-    private buildProperties;
-    /** Update property value */
-    setProperty(name: string, value: unknown): void;
-    /** Reset property to default */
-    resetProperty(name: string): void;
-    /** Set node name */
-    setName(name: string): void;
-    /** Set node comment */
-    setComment(comment: string): void;
-    private validateProperty;
-    /** Validate all properties */
-    validateAll(): boolean;
-    /** Get current state */
-    getState(): BTPropertyPanelState;
-    /** Toggle collapsed state */
-    toggleCollapsed(): void;
-    /** Subscribe to state changes */
-    subscribe(listener: () => void): () => void;
-    private notifyListeners;
-}
-export interface BTPropertyEditorProps<T = unknown> {
-    value: T;
-    definition: BTPropertyDef;
-    onChange: (value: T) => void;
-    error?: string;
-    disabled?: boolean;
-}
-/** Get editor type for property */
-export declare function getPropertyEditorType(definition: BTPropertyDef): string;
-export declare function createBTPropertyPanel(): BTPropertyPanel;
-export declare function formatPropertyValue(value: unknown, definition?: BTPropertyDef): string;
-export declare function parsePropertyValue(input: string, definition: BTPropertyDef): unknown;