@nice2dev/game-engine 1.1.5 → 1.1.7

package/dist/types/visual-scripting/VisualScriptExecutor.d.ts

@@ -0,0 +1,100 @@
+import { type ExecutionContext, type VisualScriptEvent } from './types';
+import { VisualScriptDebugger } from './VisualScriptDebugger';
+import { VisualScriptGraph } from './VisualScriptGraph';
+import { LatentNode } from './VisualScriptNode';
+export interface ExecutorConfig {
+    /** Maximum nodes to execute per update (prevents infinite loops) */
+    maxNodesPerUpdate: number;
+    /** Enable profiling */
+    profiling: boolean;
+    /** Debugger instance */
+    debugger?: VisualScriptDebugger;
+}
+export interface ExecutionStats {
+    /** Total nodes executed */
+    nodesExecuted: number;
+    /** Execution time in ms */
+    totalTime: number;
+    /** Per-node timing */
+    nodeTiming: Map<string, number>;
+    /** Errors encountered */
+    errors: Error[];
+}
+export declare class VisualScriptExecutor {
+    /** Configuration */
+    private config;
+    /** Active graph being executed */
+    private graph;
+    /** Execution context */
+    private context;
+    /** Currently executing latent nodes */
+    private latentNodes;
+    /** Pending execution queue */
+    private executionQueue;
+    /** Is currently executing? */
+    private isExecuting;
+    /** Execution stats */
+    private stats;
+    /** Debugger reference */
+    private debugger?;
+    constructor(config?: Partial<ExecutorConfig>);
+    private createDefaultContext;
+    /** Set the execution context */
+    setContext(context: Partial<ExecutionContext>): void;
+    /** Get current context */
+    getContext(): ExecutionContext;
+    /** Update context for new frame */
+    updateContext(deltaTime: number): void;
+    /** Set a global variable */
+    setGlobal(name: string, value: unknown): void;
+    /** Get a global variable */
+    getGlobal(name: string): unknown;
+    /** Bind a graph for execution */
+    bindGraph(graph: VisualScriptGraph): void;
+    /** Get bound graph */
+    getGraph(): VisualScriptGraph | null;
+    /** Trigger a visual script event */
+    triggerEvent(event: VisualScriptEvent): void;
+    /** Check if event node matches the event */
+    private matchesEvent;
+    /** Process event data into node outputs */
+    private processEventNode;
+    /** Queue a node for execution */
+    private queueExecution;
+    /** Process execution queue */
+    private processExecutionQueue;
+    /** Execute a single node */
+    private executeNode;
+    /** Resolve input values from connected nodes */
+    private resolveInputs;
+    /** Recursively resolve pure nodes */
+    private resolvePureNode;
+    /** Handle execution result and queue next nodes */
+    private handleExecutionResult;
+    /** Update latent nodes */
+    updateLatentNodes(): void;
+    /** Register a latent node */
+    registerLatentNode(nodeId: string, node: LatentNode): void;
+    /** Cancel all latent nodes */
+    cancelAllLatent(): void;
+    /** Get a local variable value */
+    getVariable(name: string): unknown;
+    /** Set a local variable value */
+    setVariable(name: string, value: unknown): void;
+    /** Get execution stats */
+    getStats(): ExecutionStats;
+    private createEmptyStats;
+    /** Set debugger */
+    setDebugger(debugger_: VisualScriptDebugger): void;
+    /** Step execution (debug mode) */
+    stepExecution(): void;
+    /** Continue execution (debug mode) */
+    continueExecution(): void;
+    /** Is there pending execution? */
+    hasPendingExecution(): boolean;
+    /** Stop all execution */
+    stop(): void;
+    /** Reset executor state */
+    reset(): void;
+}
+export declare function createExecutor(config?: Partial<ExecutorConfig>): VisualScriptExecutor;

package/dist/types/visual-scripting/VisualScriptGraph.d.ts

@@ -0,0 +1,173 @@
+import { type VisualScriptGraphData, type PinConnection, type VariableDefinition, type GraphComment } from './types';
+import { VisualScriptNode } from './VisualScriptNode';
+export declare class VisualScriptGraph {
+    /** Graph ID */
+    readonly id: string;
+    /** Graph name */
+    name: string;
+    /** Description */
+    description: string;
+    /** Graph type */
+    type: 'event' | 'function' | 'macro';
+    /** All nodes in graph */
+    private nodes;
+    /** All connections */
+    private connections;
+    /** Local variables */
+    private variables;
+    /** Comments/annotations */
+    private comments;
+    /** Node ID counter */
+    private nodeIdCounter;
+    /** Connection ID counter */
+    private connectionIdCounter;
+    /** Change listeners */
+    private changeListeners;
+    constructor(id: string, name?: string, type?: 'event' | 'function' | 'macro');
+    /** Add a new node to the graph */
+    addNode(typeId: string, position: {
+        x: number;
+        y: number;
+    }): VisualScriptNode | null;
+    /** Remove a node and all its connections */
+    removeNode(nodeId: string): boolean;
+    /** Get a node by ID */
+    getNode(nodeId: string): VisualScriptNode | undefined;
+    /** Get all nodes */
+    getAllNodes(): VisualScriptNode[];
+    /** Get nodes by type */
+    getNodesByType(typeId: string): VisualScriptNode[];
+    /** Get event nodes (entry points) */
+    getEventNodes(): VisualScriptNode[];
+    /** Move a node to a new position */
+    moveNode(nodeId: string, position: {
+        x: number;
+        y: number;
+    }): void;
+    /** Duplicate a node */
+    duplicateNode(nodeId: string, offset?: {
+        x: number;
+        y: number;
+    }): VisualScriptNode | null;
+    /** Create a connection between two pins */
+    connect(sourceNodeId: string, sourcePinId: string, targetNodeId: string, targetPinId: string): PinConnection | null;
+    /** Remove a connection */
+    removeConnection(connectionId: string): boolean;
+    /** Get a connection by ID */
+    getConnection(connectionId: string): PinConnection | undefined;
+    /** Get all connections */
+    getAllConnections(): PinConnection[];
+    /** Get connections for a specific node */
+    getNodeConnections(nodeId: string): PinConnection[];
+    /** Get connections coming into a pin */
+    getInputConnections(nodeId: string, pinId: string): PinConnection[];
+    /** Get connections going out of a pin */
+    getOutputConnections(nodeId: string, pinId: string): PinConnection[];
+    /** Check if connecting would create a cycle */
+    wouldCreateCycle(sourceNodeId: string, targetNodeId: string): boolean;
+    /** Add a variable */
+    addVariable(variable: Omit<VariableDefinition, 'id'>): VariableDefinition;
+    /** Remove a variable */
+    removeVariable(variableId: string): boolean;
+    /** Get a variable */
+    getVariable(variableId: string): VariableDefinition | undefined;
+    /** Get variable by name */
+    getVariableByName(name: string): VariableDefinition | undefined;
+    /** Get all variables */
+    getAllVariables(): VariableDefinition[];
+    /** Update a variable */
+    updateVariable(variableId: string, updates: Partial<VariableDefinition>): boolean;
+    /** Add a comment */
+    addComment(comment: Omit<GraphComment, 'id'>): GraphComment;
+    /** Remove a comment */
+    removeComment(commentId: string): boolean;
+    /** Get all comments */
+    getAllComments(): GraphComment[];
+    /** Update a comment */
+    updateComment(commentId: string, updates: Partial<GraphComment>): boolean;
+    /** Validate the entire graph */
+    validate(): GraphValidationResult;
+    /** Check for cycles in execution flow */
+    private hasCycles;
+    /** Serialize graph to data */
+    toData(): VisualScriptGraphData;
+    /** Load graph from data */
+    static fromData(data: VisualScriptGraphData): VisualScriptGraph;
+    /** Subscribe to graph changes */
+    onChange(listener: (event: GraphChangeEvent) => void): () => void;
+    /** Emit a change event */
+    private emitChange;
+    /** Clear the graph */
+    clear(): void;
+    /** Get graph statistics */
+    getStats(): GraphStats;
+}
+export type GraphChangeEvent = {
+    type: 'node_added';
+    nodeId: string;
+    node: VisualScriptNode;
+} | {
+    type: 'node_removed';
+    nodeId: string;
+} | {
+    type: 'node_moved';
+    nodeId: string;
+    position: {
+        x: number;
+        y: number;
+    };
+} | {
+    type: 'connection_added';
+    connectionId: string;
+    connection: PinConnection;
+} | {
+    type: 'connection_removed';
+    connectionId: string;
+} | {
+    type: 'variable_added';
+    variableId: string;
+    variable: VariableDefinition;
+} | {
+    type: 'variable_removed';
+    variableId: string;
+} | {
+    type: 'variable_updated';
+    variableId: string;
+    variable: VariableDefinition;
+} | {
+    type: 'comment_added';
+    commentId: string;
+    comment: GraphComment;
+} | {
+    type: 'comment_removed';
+    commentId: string;
+} | {
+    type: 'comment_updated';
+    commentId: string;
+    comment: GraphComment;
+} | {
+    type: 'graph_cleared';
+};
+export interface GraphValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationWarning[];
+}
+export interface ValidationError {
+    type: string;
+    nodeId?: string;
+    pinId?: string;
+    message: string;
+}
+export interface ValidationWarning {
+    type: string;
+    nodeId?: string;
+    pinId?: string;
+    message: string;
+}
+export interface GraphStats {
+    nodeCount: number;
+    connectionCount: number;
+    variableCount: number;
+    eventNodeCount: number;
+}

package/dist/types/visual-scripting/VisualScriptNode.d.ts

@@ -0,0 +1,157 @@
+import { type NodeMetadata, type NodeState as _NodeState, type Pin, type PinDefinition, type ExecutionContext, type ExecutionResult } from './types';
+export type { NodeMetadata, PinDefinition } from './types';
+export declare abstract class VisualScriptNode {
+    /** Node instance ID */
+    readonly id: string;
+    /** Node type metadata. Subclasses may set via constructor(metadata) or assign as a property. */
+    metadata: NodeMetadata;
+    /** Input pin definitions (mutable so subclasses can call addInputPin). */
+    inputPins: PinDefinition[];
+    /** Output pin definitions (mutable so subclasses can call addOutputPin). */
+    outputPins: PinDefinition[];
+    /** Position in graph */
+    position: {
+        x: number;
+        y: number;
+    };
+    /** Is node visually collapsed? */
+    collapsed: boolean;
+    /** User comment */
+    comment?: string;
+    /** Has breakpoint */
+    hasBreakpoint: boolean;
+    /** Custom property values */
+    properties: Record<string, unknown>;
+    /** Input pin values (overrides/defaults) */
+    inputValues: Map<string, unknown>;
+    /** Runtime input pins */
+    private _inputPinInstances;
+    /** Runtime output pins */
+    private _outputPinInstances;
+    constructor(idOrMetadata?: string | NodeMetadata, id?: string);
+    /** Add a single input pin definition. Used by node subclasses in setupPins(). */
+    addInputPin(def: PinDefinition): void;
+    /** Add a single output pin definition. Used by node subclasses in setupPins(). */
+    addOutputPin(def: PinDefinition): void;
+    /** Initialize pin instances from definitions */
+    initializePins(): void;
+    private createPinInstance;
+    /** Get input pin by ID */
+    getInputPin(pinId: string): Pin | undefined;
+    /** Get output pin by ID */
+    getOutputPin(pinId: string): Pin | undefined;
+    /** Get all input pins */
+    getInputPins(): Pin[];
+    /** Get all output pins */
+    getOutputPins(): Pin[];
+    /** Set input pin value */
+    setInputValue(pinId: string, value: unknown): void;
+    /** Get input pin value */
+    getInputValue(pinId: string): unknown;
+    /** Set output pin value */
+    setOutputValue(pinId: string, value: unknown): void;
+    /** Get output pin value */
+    getOutputValue(pinId: string): unknown;
+    /** Has execution input pin? */
+    hasExecutionInput(): boolean;
+    /** Has execution output pin? */
+    hasExecutionOutput(): boolean;
+    /** Get execution input pin */
+    getExecutionInput(): Pin | undefined;
+    /** Get execution output pins */
+    getExecutionOutputs(): Pin[];
+    /**
+     * Execute this node.
+     * Override in subclasses to implement node-specific logic.
+     */
+    execute(_context: ExecutionContext): ExecutionResult | Promise<ExecutionResult>;
+    /**
+     * Get the ID of the next execution pin to follow.
+     * Override for nodes with multiple execution outputs (like Branch).
+     */
+    getNextExecutionPin(result: ExecutionResult): string | null;
+    /** Serialize node to state */
+    toState(): _NodeState;
+    /** Restore node from state */
+    fromState(state: _NodeState): void;
+    /** Validate node configuration */
+    validate(): string[];
+    /** Get display title */
+    getTitle(): string;
+    /** Get tooltip text */
+    getTooltip(): string;
+    /** Get node color */
+    getColor(): string;
+    /** Get icon */
+    getIcon(): string | undefined;
+}
+/**
+ * Base class for pure function nodes.
+ * Pure nodes have no execution pins and produce outputs from inputs.
+ */
+export declare abstract class PureFunctionNode extends VisualScriptNode {
+    constructor(idOrMetadata?: string | NodeMetadata, id?: string);
+    /** Override to define data input pins */
+    getDataInputPins(): PinDefinition[];
+    /** Override to define data output pins */
+    getDataOutputPins(): PinDefinition[];
+    /** Calculate outputs from inputs */
+    compute(_inputs: Record<string, unknown>): Record<string, unknown>;
+    execute(context: ExecutionContext): ExecutionResult;
+}
+/**
+ * Base class for event nodes.
+ * Event nodes are entry points with only output execution pins.
+ */
+export declare abstract class EventNode extends VisualScriptNode {
+    constructor(idOrMetadata?: string | NodeMetadata, id?: string);
+    /** Data inputs for the event (usually none or few) */
+    getEventInputPins(): PinDefinition[];
+    /** Additional data outputs (event-specific data) */
+    getEventOutputPins(): PinDefinition[];
+    /** Process event and set output values */
+    processEvent(_event: unknown, _context: ExecutionContext): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(_result?: ExecutionResult): string | null;
+}
+/**
+ * Base class for flow control nodes.
+ * These nodes control execution flow (Branch, Sequence, ForLoop, etc.)
+ */
+export declare abstract class FlowControlNode extends VisualScriptNode {
+    /** Determine which execution pin to follow based on state */
+    determineNextPin(_context: ExecutionContext): string | null;
+    getNextExecutionPin(result: ExecutionResult): string | null;
+}
+/**
+ * Base class for latent/async nodes.
+ * These nodes can pause execution and resume later (Delay, Wait, etc.)
+ */
+export declare abstract class LatentNode extends VisualScriptNode {
+    /** Is this node currently executing? */
+    isExecuting: boolean;
+    /** Start async execution */
+    startAsync(_context?: ExecutionContext): void | Promise<void>;
+    /** Called each frame while executing */
+    updateAsync(_context: ExecutionContext): boolean;
+    /** Cancel async execution */
+    cancelAsync(): void;
+    execute(context: ExecutionContext): ExecutionResult | Promise<ExecutionResult>;
+}
+export type NodeConstructor = new (id: string) => VisualScriptNode;
+/** Register a node type */
+export declare function registerNodeType(typeId: string, constructor: NodeConstructor): void;
+/** Get the underlying node registry map */
+export declare function getNodeRegistry(): Map<string, NodeConstructor>;
+/** Convenience alias for registerNodeType that also accepts no-arg classes (used by node subclasses).
+ *  When the class has a no-arg constructor, it's wrapped to satisfy the (id) => Node signature.
+ */
+export declare function registerNode(typeId: string, ctor: NodeConstructor | (new () => VisualScriptNode)): void;
+/** Create a node instance by type ID */
+export declare function createNode(typeId: string, id: string): VisualScriptNode | null;
+/** Get all registered node types */
+export declare function getRegisteredNodeTypes(): string[];
+/** Get node metadata by type ID */
+export declare function getNodeMetadata(typeId: string): NodeMetadata | null;
+/** Search nodes by keyword */
+export declare function searchNodes(query: string): NodeMetadata[];

package/dist/types/visual-scripting/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './VisualScriptNode';
+export * from './VisualScriptGraph';
+export * from './VisualScriptExecutor';
+export * from './VisualScriptDebugger';
+export * from './nodes/index';

package/dist/types/visual-scripting/nodes/ActionNodes.d.ts

@@ -0,0 +1,152 @@
+import type { ExecutionContext, ExecutionResult } from '../types';
+import { VisualScriptNode, LatentNode, type NodeMetadata } from '../VisualScriptNode';
+export declare class PrintStringNode extends VisualScriptNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class PrintWarningNode extends VisualScriptNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class SpawnEntityNode extends VisualScriptNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class DestroyEntityNode extends VisualScriptNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class GetEntityByNameNode extends VisualScriptNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class SetPositionNode extends VisualScriptNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class GetPositionNode extends VisualScriptNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+}
+export declare class SetRotationNode extends VisualScriptNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class SetScaleNode extends VisualScriptNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class TranslateNode extends VisualScriptNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class RotateNode extends VisualScriptNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class LookAtNode extends VisualScriptNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class AddForceNode extends VisualScriptNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class SetVelocityNode extends VisualScriptNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class PlaySoundNode extends VisualScriptNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class StopSoundNode extends VisualScriptNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class DispatchEventNode extends VisualScriptNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class LoadSceneNode extends LatentNode {
+    static readonly metadata: NodeMetadata;
+    private loaded;
+    constructor();
+    protected setupPins(): void;
+    startAsync(): void;
+    updateAsync(context: ExecutionContext): boolean;
+    cancelAsync(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class PlayAnimationNode extends VisualScriptNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class StopAnimationNode extends VisualScriptNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class SetActiveNode extends VisualScriptNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(_context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}

package/dist/types/visual-scripting/nodes/EventNodes.d.ts

@@ -0,0 +1,95 @@
+import type { ExecutionContext, ExecutionResult } from '../types';
+import { EventNode, type NodeMetadata } from '../VisualScriptNode';
+export declare class BeginPlayEventNode extends EventNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class TickEventNode extends EventNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class EndPlayEventNode extends EventNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class InputActionEventNode extends EventNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(result: ExecutionResult): string | null;
+}
+export declare class KeyInputEventNode extends EventNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class CollisionEnterEventNode extends EventNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class CollisionExitEventNode extends EventNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class TriggerEnterEventNode extends EventNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class TriggerExitEventNode extends EventNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class CustomEventNode extends EventNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class TimerEventNode extends EventNode {
+    static readonly metadata: NodeMetadata;
+    private lastFireTime;
+    private fireCount;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class MouseEventNode extends EventNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}
+export declare class TouchEventNode extends EventNode {
+    static readonly metadata: NodeMetadata;
+    constructor();
+    protected setupPins(): void;
+    execute(_context: ExecutionContext): ExecutionResult;
+    getNextExecutionPin(): string | null;
+}