@nice2dev/game-engine 1.0.28 → 1.1.6

package/dist/types/systems/NiceSpawner.d.ts

@@ -0,0 +1,237 @@
+export type SpawnerId = string;
+export type SpawnPointId = string;
+export type SpawnZoneId = string;
+export type WaveId = string;
+export type EntityTypeId = string;
+export type SpawnGroupId = string;
+export type SpawnPattern = 'random' | 'sequential' | 'circular' | 'grid' | 'cluster' | 'line' | 'wave-radial';
+export type SpawnTrigger = 'auto' | 'proximity' | 'event' | 'timer' | 'condition' | 'manual';
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface SpawnTransform {
+    position: Vec3;
+    rotation?: Vec3;
+    scale?: Vec3;
+}
+export interface SpawnPointDefinition {
+    id: SpawnPointId;
+    position: Vec3;
+    /** Spawn radius */
+    radius?: number;
+    /** Spawn direction */
+    direction?: Vec3;
+    /** Entity types this point can spawn */
+    entityTypes?: EntityTypeId[];
+    /** Tags */
+    tags?: string[];
+    /** Active state */
+    active: boolean;
+    /** Cooldown after spawn */
+    cooldown?: number;
+    /** Max entities from this point */
+    maxEntities?: number;
+}
+export interface SpawnZoneDefinition {
+    id: SpawnZoneId;
+    name: string;
+    /** Zone bounds */
+    bounds: {
+        min: Vec3;
+        max: Vec3;
+    };
+    /** Spawn points within zone */
+    spawnPoints: SpawnPointId[];
+    /** Spawn pattern */
+    pattern: SpawnPattern;
+    /** Zone-wide population cap */
+    maxPopulation: number;
+    /** Current population */
+    currentPopulation: number;
+    /** Respawn delay */
+    respawnDelay: number;
+    /** Active state */
+    active: boolean;
+    /** Tags */
+    tags?: string[];
+}
+export interface SpawnEntityDefinition {
+    typeId: EntityTypeId;
+    name: string;
+    /** Factory function or prefab ID */
+    factory?: () => unknown;
+    prefabId?: string;
+    /** Base spawn weight */
+    weight: number;
+    /** Min level to spawn */
+    minLevel?: number;
+    /** Max level to spawn */
+    maxLevel?: number;
+    /** Is boss/elite */
+    isBoss?: boolean;
+    isElite?: boolean;
+    /** Population count (how many slots this takes) */
+    populationCost: number;
+    /** Spawn requirements */
+    conditions?: SpawnCondition[];
+    /** Tags */
+    tags?: string[];
+}
+export interface WaveEntry {
+    entityType: EntityTypeId;
+    count: number;
+    delay?: number;
+    /** Specific spawn points */
+    spawnPoints?: SpawnPointId[];
+    /** Spawn offset pattern */
+    pattern?: SpawnPattern;
+}
+export interface WaveDefinition {
+    id: WaveId;
+    name?: string;
+    entries: WaveEntry[];
+    /** Time before next wave */
+    nextWaveDelay: number;
+    /** Must clear this wave to proceed */
+    mustClear: boolean;
+    /** Bonus on wave clear */
+    clearBonus?: {
+        type: string;
+        value: number;
+    };
+    /** Modifiers for this wave */
+    modifiers?: {
+        healthMultiplier?: number;
+        damageMultiplier?: number;
+        speedMultiplier?: number;
+        experienceMultiplier?: number;
+    };
+}
+export interface WaveState {
+    waveId: WaveId;
+    waveNumber: number;
+    entriesSpawned: number;
+    totalEntries: number;
+    enemiesAlive: number;
+    startTime: number;
+    completed: boolean;
+    cleared: boolean;
+}
+export interface SpawnCondition {
+    type: 'time' | 'population' | 'level' | 'wave' | 'flag' | 'custom';
+    params: {
+        /** For time: min/max game time */
+        minTime?: number;
+        maxTime?: number;
+        /** For population */
+        minPopulation?: number;
+        maxPopulation?: number;
+        /** For level */
+        minPlayerLevel?: number;
+        maxPlayerLevel?: number;
+        /** For wave */
+        minWave?: number;
+        maxWave?: number;
+        /** For flag */
+        flag?: string;
+        flagValue?: boolean;
+    };
+    customCheck?: () => boolean;
+}
+export interface SpawnRequest {
+    entityType: EntityTypeId;
+    count: number;
+    position?: Vec3;
+    spawnPoint?: SpawnPointId;
+    zone?: SpawnZoneId;
+    pattern?: SpawnPattern;
+    delay?: number;
+    spread?: number;
+    modifiers?: Record<string, number>;
+    tags?: string[];
+}
+export interface SpawnResult {
+    success: boolean;
+    spawnedCount: number;
+    entities: unknown[];
+    positions: Vec3[];
+    reason?: string;
+}
+export interface SpawnerState {
+    spawnerId: SpawnerId;
+    totalSpawned: number;
+    activeEntities: Set<unknown>;
+    lastSpawnTime: number;
+    currentWave: number;
+    waveState: WaveState | null;
+    paused: boolean;
+    active: boolean;
+}
+export type SpawnerEventType = 'entity-spawned' | 'entity-despawned' | 'wave-started' | 'wave-completed' | 'wave-cleared' | 'all-waves-completed' | 'spawner-activated' | 'spawner-deactivated' | 'population-changed' | 'spawn-failed';
+export interface SpawnerEvent {
+    type: SpawnerEventType;
+    timestamp: number;
+    spawnerId?: SpawnerId;
+    data: unknown;
+}
+export type SpawnerEventCallback = (event: SpawnerEvent) => void;
+export interface SpawnerConfig {
+    /** Global population cap */
+    globalMaxPopulation: number;
+    /** Default spawn cooldown */
+    defaultCooldown: number;
+    /** Use object pooling */
+    usePooling: boolean;
+    /** Storage key */
+    storageKey: string;
+}
+export declare const DEFAULT_SPAWNER_CONFIG: SpawnerConfig;
+export declare class NiceSpawner {
+    private config;
+    private entityTypes;
+    private spawnPoints;
+    private spawnZones;
+    private waves;
+    private spawnerStates;
+    private activeEntities;
+    private entityToSpawner;
+    private pendingSpawns;
+    private globalPopulation;
+    private flags;
+    private playerLevel;
+    private gameTime;
+    private eventListeners;
+    constructor(config?: Partial<SpawnerConfig>);
+    on(event: SpawnerEventType, callback: SpawnerEventCallback): () => void;
+    private emit;
+    registerEntityType(entity: SpawnEntityDefinition): void;
+    registerSpawnPoint(point: SpawnPointDefinition): void;
+    registerSpawnZone(zone: SpawnZoneDefinition): void;
+    registerWave(wave: WaveDefinition): void;
+    createSpawner(id: SpawnerId): SpawnerState;
+    getSpawner(id: SpawnerId): SpawnerState | undefined;
+    spawn(request: SpawnRequest, spawnerId?: SpawnerId): SpawnResult;
+    spawnDelayed(request: SpawnRequest, delay: number, callback?: (result: SpawnResult) => void): void;
+    private createEntity;
+    private getSpawnPositions;
+    private generatePatternPositions;
+    private getRandomPositionInZone;
+    despawn(entity: unknown): void;
+    despawnAll(spawnerId?: SpawnerId): void;
+    private getEntityDefForEntity;
+    startWaves(spawnerId: SpawnerId, waveIds: WaveId[]): void;
+    startWave(spawnerId: SpawnerId, waveId: WaveId): void;
+    private checkConditions;
+    private checkCondition;
+    setPlayerLevel(level: number): void;
+    setGameTime(time: number): void;
+    setFlag(flag: string, value?: boolean): void;
+    update(_deltaTime: number): void;
+    getPopulation(): number;
+    getActiveEntityCount(): number;
+    getSpawnerEntityCount(spawnerId: SpawnerId): number;
+    destroy(): void;
+}
+export declare function createSpawnerSystem(config?: Partial<SpawnerConfig>): NiceSpawner;

package/dist/types/systems/NiceSpell.d.ts

@@ -0,0 +1,216 @@
+export type SpellId = string;
+export type SchoolId = string;
+export type EffectId = string;
+export type SpellTargetType = 'self' | 'single' | 'aoe' | 'cone' | 'line' | 'ground' | 'chain';
+export type ResourceType = 'mana' | 'stamina' | 'energy' | 'rage' | 'focus' | 'health' | 'custom';
+export interface SpellDefinition {
+    id: SpellId;
+    name: string;
+    description: string;
+    schoolId: SchoolId;
+    element?: string;
+    targetType: SpellTargetType;
+    range: number;
+    radius?: number;
+    maxTargets?: number;
+    requiresLineOfSight: boolean;
+    resourceCost: number;
+    resourceType: ResourceType;
+    healthCost?: number;
+    castTime: number;
+    channeled: boolean;
+    channelDuration?: number;
+    channelTicks?: number;
+    cooldown: number;
+    globalCooldown: number;
+    effects: SpellEffect[];
+    levelRequired: number;
+    classRequired?: string[];
+    questRequired?: string;
+    canCrit: boolean;
+    critMultiplier?: number;
+    baseDamage?: number;
+    baseHealing?: number;
+    scaling?: SpellScaling;
+    icon: string;
+    castAnimation?: string;
+    projectileId?: string;
+    impactVfx?: string;
+    soundId?: string;
+    interruptible: boolean;
+    movementCancels: boolean;
+    damageCancels: boolean;
+    passive: boolean;
+    hidden: boolean;
+    comboSpellId?: SpellId;
+    comboWindow?: number;
+    tags?: string[];
+}
+export interface SpellEffect {
+    id: EffectId;
+    type: 'damage' | 'heal' | 'buff' | 'debuff' | 'summon' | 'teleport' | 'dispel' | 'interrupt' | 'knockback' | 'stun' | 'slow' | 'root' | 'silence' | 'custom';
+    delay?: number;
+    duration?: number;
+    tickInterval?: number;
+    baseValue?: number;
+    scaling?: SpellScaling;
+    applyTo: 'target' | 'caster' | 'area';
+    maxStacks?: number;
+    stackBehavior?: 'refresh' | 'add' | 'extend';
+    effectData?: Record<string, unknown>;
+}
+export interface SpellScaling {
+    stat: string;
+    coefficient: number;
+    perLevel?: number;
+}
+export interface SpellSchool {
+    id: SchoolId;
+    name: string;
+    description?: string;
+    color: string;
+    icon?: string;
+    resistanceStat?: string;
+    strongAgainst?: SchoolId[];
+    weakAgainst?: SchoolId[];
+}
+export interface ActiveSpell {
+    spellId: SpellId;
+    casterId: string;
+    targetId?: string;
+    targetPosition?: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    state: 'casting' | 'channeling' | 'traveling' | 'complete' | 'interrupted';
+    startTime: number;
+    progress: number;
+    ticksCompleted?: number;
+    hitTargets?: string[];
+    totalDamage?: number;
+    totalHealing?: number;
+}
+export interface CooldownState {
+    spellId: SpellId;
+    startTime: number;
+    duration: number;
+    remainingTime: number;
+    charges?: number;
+    maxCharges?: number;
+}
+export interface CasterState {
+    entityId: string;
+    resources: Map<ResourceType, {
+        current: number;
+        max: number;
+        regenRate: number;
+    }>;
+    cooldowns: Map<SpellId, CooldownState>;
+    globalCooldownEnd: number;
+    currentCast?: ActiveSpell;
+    castSpeed: number;
+    cooldownReduction: number;
+    resourceCostReduction: number;
+    knownSpells: Set<SpellId>;
+    spellRanks: Map<SpellId, number>;
+    spellPowerBonus: number;
+    critChance: number;
+    critMultiplier: number;
+}
+export interface CastResult {
+    success: boolean;
+    error?: string;
+    spell: SpellDefinition;
+    caster: CasterState;
+    targets?: Array<{
+        targetId: string;
+        effects: Array<{
+            effectId: EffectId;
+            value: number;
+            isCrit: boolean;
+            resisted?: boolean;
+        }>;
+    }>;
+    resourceSpent?: number;
+    healthSpent?: number;
+    castTime: number;
+    timestamp: number;
+}
+export type SpellEventType = 'spell-learned' | 'spell-unlearned' | 'cast-started' | 'cast-completed' | 'cast-interrupted' | 'cast-failed' | 'channel-tick' | 'spell-hit' | 'spell-miss' | 'spell-crit' | 'cooldown-started' | 'cooldown-ended' | 'resource-changed';
+export interface SpellEvent {
+    type: SpellEventType;
+    timestamp: number;
+    data?: unknown;
+}
+export type SpellEventCallback = (event: SpellEvent) => void;
+export interface SpellConfig {
+    globalCooldown: number;
+    maxCastQueue: number;
+    defaultCritChance: number;
+    defaultCritMultiplier: number;
+    resourceRegenInterval: number;
+    allowMovingWhileCasting: boolean;
+    storageKey: string;
+}
+export declare const DEFAULT_SPELL_CONFIG: SpellConfig;
+export declare class NiceSpell {
+    private config;
+    private spells;
+    private schools;
+    private casters;
+    private eventListeners;
+    private regenInterval?;
+    private updateInterval?;
+    constructor(config?: Partial<SpellConfig>);
+    on(event: SpellEventType, callback: SpellEventCallback): () => void;
+    private emit;
+    private startLoops;
+    registerSpell(spell: SpellDefinition): void;
+    registerSchool(school: SpellSchool): void;
+    registerCaster(entityId: string, initialState?: Partial<CasterState>): CasterState;
+    getCaster(entityId: string): CasterState | undefined;
+    learnSpell(casterId: string, spellId: SpellId, rank?: number): boolean;
+    unlearnSpell(casterId: string, spellId: SpellId): boolean;
+    knowsSpell(casterId: string, spellId: SpellId): boolean;
+    canCast(casterId: string, spellId: SpellId): {
+        canCast: boolean;
+        reason?: string;
+    };
+    startCast(casterId: string, spellId: SpellId, targetId?: string, targetPosition?: {
+        x: number;
+        y: number;
+        z?: number;
+    }): CastResult | null;
+    completeCast(casterId: string): CastResult | null;
+    interruptCast(casterId: string, interrupterId?: string): boolean;
+    private applySpellEffects;
+    private calculateEffectValue;
+    private resolveTargets;
+    private startCooldown;
+    private updateCooldowns;
+    private updateCasts;
+    private updateResourceRegen;
+    private calculateCastTime;
+    private calculateResourceCost;
+    getSpell(id: SpellId): SpellDefinition | undefined;
+    getAllSpells(): SpellDefinition[];
+    getSpellsBySchool(schoolId: SchoolId): SpellDefinition[];
+    getSchool(id: SchoolId): SpellSchool | undefined;
+    getAllSchools(): SpellSchool[];
+    getKnownSpells(casterId: string): SpellDefinition[];
+    getCooldown(casterId: string, spellId: SpellId): CooldownState | undefined;
+    getResource(casterId: string, type: ResourceType): {
+        current: number;
+        max: number;
+    } | undefined;
+    isOnGlobalCooldown(casterId: string): boolean;
+    getCurrentCast(casterId: string): ActiveSpell | undefined;
+    setResource(casterId: string, type: ResourceType, current: number, max?: number): void;
+    modifyResource(casterId: string, type: ResourceType, amount: number): void;
+    private save;
+    private load;
+    reset(): void;
+    destroy(): void;
+}
+export declare function createSpellSystem(config?: Partial<SpellConfig>): NiceSpell;

package/dist/types/systems/NiceState.d.ts

@@ -0,0 +1,224 @@
+/**
+ * NiceState - Game Engine State Machine System
+ *
+ * Comprehensive state machine system supporting:
+ * - Finite State Machines (FSM)
+ * - Hierarchical State Machines (HSM)
+ * - Parallel states
+ * - State history
+ * - Guarded transitions
+ * - Entry/Exit/Update actions
+ * - State data and context
+ * - Pushdown automata (stack-based states)
+ *
+ * @packageDocumentation
+ */
+import { EventEmitter } from 'events';
+export type StateId = string;
+export type MachineId = string;
+export type TransitionId = string;
+export type ActionId = string;
+export type StateStatus = 'inactive' | 'entering' | 'active' | 'exiting';
+export interface StateContext<TData extends Record<string, unknown> = Record<string, unknown>> {
+    machineId: MachineId;
+    stateId: StateId;
+    data: TData;
+    deltaTime: number;
+    elapsedTime: number;
+    previousState?: StateId;
+    event?: StateEvent;
+}
+export type ActionFunction<TData extends Record<string, unknown> = Record<string, unknown>> = (context: StateContext<TData>) => void | Promise<void>;
+export type GuardFunction<TData extends Record<string, unknown> = Record<string, unknown>> = (context: StateContext<TData>) => boolean;
+export type ConditionFunction<TData extends Record<string, unknown> = Record<string, unknown>> = (context: StateContext<TData>) => boolean;
+export interface StateEvent {
+    type: string;
+    payload?: unknown;
+    timestamp: number;
+}
+export interface StateTransition<TData extends Record<string, unknown> = Record<string, unknown>> {
+    id: TransitionId;
+    from: StateId | StateId[];
+    to: StateId;
+    event?: string;
+    guard?: GuardFunction<TData>;
+    actions?: ActionFunction<TData>[];
+    internal?: boolean;
+}
+export interface StateDefinition<TData extends Record<string, unknown> = Record<string, unknown>> {
+    id: StateId;
+    name?: string;
+    onEnter?: ActionFunction<TData>;
+    onExit?: ActionFunction<TData>;
+    onUpdate?: ActionFunction<TData>;
+    children?: StateDefinition<TData>[];
+    initialChild?: StateId;
+    parallel?: StateDefinition<TData>[];
+    historyType?: 'none' | 'shallow' | 'deep';
+    metadata?: Record<string, unknown>;
+    timeout?: {
+        duration: number;
+        target: StateId;
+        guard?: GuardFunction<TData>;
+    };
+}
+export interface StateMachineDefinition<TData extends Record<string, unknown> = Record<string, unknown>> {
+    id: MachineId;
+    name?: string;
+    initialData?: TData;
+    initialState: StateId;
+    states: StateDefinition<TData>[];
+    transitions: StateTransition<TData>[];
+    globalActions?: {
+        onEnter?: ActionFunction<TData>;
+        onExit?: ActionFunction<TData>;
+        onUpdate?: ActionFunction<TData>;
+        onTransition?: ActionFunction<TData>;
+    };
+}
+export interface StateInstance {
+    id: StateId;
+    status: StateStatus;
+    enteredAt: number;
+    elapsedTime: number;
+    activeChildren: StateId[];
+    history?: StateId;
+}
+export interface MachineInstance<TData extends Record<string, unknown> = Record<string, unknown>> {
+    id: string;
+    machineId: MachineId;
+    currentState: StateId;
+    previousState?: StateId;
+    stateStack: StateId[];
+    data: TData;
+    isRunning: boolean;
+    states: Map<StateId, StateInstance>;
+    eventQueue: StateEvent[];
+    startTime: number;
+    lastUpdateTime: number;
+}
+export type StateMachineEventType = 'started' | 'stopped' | 'state-enter' | 'state-exit' | 'state-update' | 'transition' | 'event-processed' | 'error';
+export interface StateMachineEvent {
+    type: StateMachineEventType;
+    instanceId: string;
+    machineId: MachineId;
+    stateId?: StateId;
+    previousState?: StateId;
+    event?: StateEvent;
+    error?: Error;
+    timestamp: number;
+}
+export type StateMachineEventCallback = (event: StateMachineEvent) => void;
+export interface StateMachineConfig {
+    maxEventQueueSize: number;
+    maxStackDepth: number;
+    enableHistory: boolean;
+    asyncActions: boolean;
+    logTransitions: boolean;
+}
+export declare const DEFAULT_STATE_CONFIG: StateMachineConfig;
+export declare class NiceState extends EventEmitter {
+    private config;
+    private definitions;
+    private instances;
+    private stateMap;
+    private nextInstanceId;
+    private destroyed;
+    constructor(config?: Partial<StateMachineConfig>);
+    registerMachine<TData extends Record<string, unknown> = Record<string, unknown>>(definition: StateMachineDefinition<TData>): void;
+    private buildStateMap;
+    getMachineDefinition(machineId: MachineId): StateMachineDefinition | undefined;
+    unregisterMachine(machineId: MachineId): void;
+    create<TData extends Record<string, unknown> = Record<string, unknown>>(machineId: MachineId, initialData?: Partial<TData>): string;
+    start(instanceId: string): void;
+    stop(instanceId: string): void;
+    destroyInstance(instanceId: string): void;
+    getInstance(instanceId: string): MachineInstance | undefined;
+    private enterState;
+    private exitState;
+    transition(instanceId: string, targetState: StateId): boolean;
+    private performTransition;
+    send(instanceId: string, eventType: string, payload?: unknown): void;
+    private processEvents;
+    private transitionMatches;
+    pushState(instanceId: string, stateId: StateId): boolean;
+    popState(instanceId: string): StateId | undefined;
+    getStateStack(instanceId: string): StateId[];
+    update(_deltaTime: number): void;
+    private updateState;
+    private checkTimeout;
+    private executeAction;
+    private createContext;
+    getData<TData extends Record<string, unknown> = Record<string, unknown>>(instanceId: string): TData | undefined;
+    setData<TData extends Record<string, unknown> = Record<string, unknown>>(instanceId: string, data: Partial<TData>): void;
+    updateData<TData extends Record<string, unknown> = Record<string, unknown>>(instanceId: string, updater: (data: TData) => TData): void;
+    getCurrentState(instanceId: string): StateId | undefined;
+    isInState(instanceId: string, stateId: StateId): boolean;
+    canTransitionTo(instanceId: string, targetState: StateId): boolean;
+    getStateElapsedTime(instanceId: string, stateId?: StateId): number;
+    getAvailableTransitions(instanceId: string): StateTransition[];
+    getHistory(instanceId: string, stateId: StateId): StateId | undefined;
+    restoreHistory(instanceId: string, stateId: StateId): boolean;
+    clearHistory(instanceId: string, stateId?: StateId): void;
+    getAllInstances(): MachineInstance[];
+    getRunningInstances(): MachineInstance[];
+    getInstancesByMachine(machineId: MachineId): MachineInstance[];
+    getStats(): {
+        definitions: number;
+        instances: number;
+        runningInstances: number;
+    };
+    on(event: 'statemachine', callback: StateMachineEventCallback): this;
+    off(event: 'statemachine', callback: StateMachineEventCallback): this;
+    destroy(): void;
+}
+export declare function createStateMachine(config?: Partial<StateMachineConfig>): NiceState;
+export declare class StateBuilder<TData extends Record<string, unknown> = Record<string, unknown>> {
+    private state;
+    constructor(id: StateId, name?: string);
+    onEnter(action: ActionFunction<TData>): this;
+    onExit(action: ActionFunction<TData>): this;
+    onUpdate(action: ActionFunction<TData>): this;
+    withChildren(children: StateDefinition<TData>[], initialChild: StateId): this;
+    withParallel(states: StateDefinition<TData>[]): this;
+    withHistory(type: 'shallow' | 'deep'): this;
+    withTimeout(duration: number, target: StateId, guard?: GuardFunction<TData>): this;
+    withMetadata(metadata: Record<string, unknown>): this;
+    build(): StateDefinition<TData>;
+}
+export declare class TransitionBuilder<TData extends Record<string, unknown> = Record<string, unknown>> {
+    private transition;
+    constructor(id: TransitionId, from: StateId | StateId[], to: StateId);
+    onEvent(eventType: string): this;
+    guard(condition: GuardFunction<TData>): this;
+    withActions(...actions: ActionFunction<TData>[]): this;
+    internal(): this;
+    build(): StateTransition<TData>;
+}
+export declare class MachineBuilder<TData extends Record<string, unknown> = Record<string, unknown>> {
+    private machine;
+    constructor(id: MachineId, name?: string);
+    withInitialData(data: TData): this;
+    initialState(stateId: StateId): this;
+    addState(state: StateDefinition<TData>): this;
+    addStates(...states: StateDefinition<TData>[]): this;
+    addTransition(transition: StateTransition<TData>): this;
+    addTransitions(...transitions: StateTransition<TData>[]): this;
+    withGlobalActions(actions: {
+        onEnter?: ActionFunction<TData>;
+        onExit?: ActionFunction<TData>;
+        onUpdate?: ActionFunction<TData>;
+        onTransition?: ActionFunction<TData>;
+    }): this;
+    build(): StateMachineDefinition<TData>;
+}
+export declare function state<TData extends Record<string, unknown> = Record<string, unknown>>(id: StateId, name?: string): StateBuilder<TData>;
+export declare function transition<TData extends Record<string, unknown> = Record<string, unknown>>(id: TransitionId, from: StateId | StateId[], to: StateId): TransitionBuilder<TData>;
+export declare function machine<TData extends Record<string, unknown> = Record<string, unknown>>(id: MachineId, name?: string): MachineBuilder<TData>;
+export declare function createSimpleFSM<TData extends Record<string, unknown> = Record<string, unknown>>(machineId: MachineId, states: string[], transitions: Array<{
+    from: string;
+    to: string;
+    event: string;
+}>): StateMachineDefinition<TData>;
+export declare function createToggleMachine<TData extends Record<string, unknown> = Record<string, unknown>>(machineId: MachineId, offState?: StateId, onState?: StateId, toggleEvent?: string): StateMachineDefinition<TData>;
+export declare function createSequenceMachine<TData extends Record<string, unknown> = Record<string, unknown>>(machineId: MachineId, states: StateId[], advanceEvent?: string): StateMachineDefinition<TData>;