@nice2dev/game-engine 1.3.13 → 1.3.14

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

@@ -1,237 +0,0 @@
-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

@@ -1,216 +0,0 @@
-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

@@ -1,224 +0,0 @@
-/**
- * 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>;