addComponentAnimation(componentAnimation: {
    component: any,
    id: string
  })

// Add a hit animation component
engine.addComponentAnimation({
  id: 'hit',
  component: HitComponent
});

// Add an explosion effect component
engine.addComponentAnimation({
  id: 'explosion',
  component: ExplosionComponent
});

addEventComponentResolver(resolver: EventComponentResolver)

addSound(sound: any, id?: string): any

// Simple sound object
engine.addSound({ id: 'click', src: 'click.mp3' });

// With explicit ID
engine.addSound({ src: 'music.mp3' }, 'background-music');

addSpriteComponentBehind(component: any)

// Add a shadow component behind all sprites
engine.addSpriteComponentBehind(ShadowComponent);

// Add a component with static props
engine.addSpriteComponentBehind({ 
  component: LightHalo, 
  props: { radius: 30 } 
});

// Add a component with dynamic props and dependencies
engine.addSpriteComponentBehind({ 
  component: HealthBar, 
  props: (object) => ({ hp: object.hp(), maxHp: object.param.maxHp() }),
  dependencies: (object) => [object.hp, object.param.maxHp]
});

addSpriteComponentInFront(component: any | { component: any, props: (object: any) => any, dependencies?: (object: any) => any[] })

// Add a health bar component in front of all sprites
engine.addSpriteComponentInFront(HealthBarComponent);

// Add a component with static props
engine.addSpriteComponentInFront({ 
  component: StatusIndicator, 
  props: { type: 'poison' } 
});

// Add a component with dynamic props and dependencies
engine.addSpriteComponentInFront({ 
  component: HealthBar, 
  props: (object) => ({ hp: object.hp(), maxHp: object.param.maxHp() }),
  dependencies: (object) => [object.hp, object.param.maxHp]
});

cameraFollowRevision

cameraFollowSmoothMove: CameraFollowSmoothMove

cameraFollowTargetId

clear(): void

// In test cleanup
afterEach(() => {
  clientEngine.clear();
});

clearClientPredictionStates()

// Clear prediction states when changing maps
engine.clearClientPredictionStates();

dashDefaults: Partial<RpgDashInput>

flash(spriteId?: string, options?: {
      type?: 'alpha' | 'tint' | 'both';
      duration?: number;
      cycles?: number;
      alpha?: number;
      tint?: number | string;
    }): void

// Flash the current player with default settings
engine.flash();

// Flash a specific sprite with red tint
engine.flash('sprite-id', { type: 'tint', tint: 0xff0000 });

// Flash with both alpha and tint for dramatic effect
engine.flash(undefined, { 
  type: 'both', 
  alpha: 0.5, 
  tint: 0xff0000,
  duration: 200,
  cycles: 2
});

// Quick damage flash on current player
engine.flash(undefined, { 
  type: 'tint', 
  tint: 'red', 
  duration: 150,
  cycles: 1
});

getComponentAnimation(id: string): AnimationManager

// Get the hit animation and display it
const hitAnimation = engine.getComponentAnimation('hit');
hitAnimation.displayEffect({ text: "Critical!" }, player);

getSound(id: string): any | Promise<any>

// Synchronous usage
const sound = engine.getSound('my-sound');

// Asynchronous usage (when resolver returns Promise)
const sound = await engine.getSound('dynamic-sound');

getSoundVolume(channel: RpgAudioChannel): number

const musicVolume = engine.getSoundVolume('music')

getSpriteComponent(id: string)

getSpriteSheet(id: string | number): any | Promise<any>

// Synchronous usage
const spritesheet = engine.getSpriteSheet('my-sprite');

// Asynchronous usage (when resolver returns Promise)
const spritesheet = await engine.getSpriteSheet('dynamic-sprite');

interactions: RpgClientInteractions

engine.interactions.use('Guard', {
  cursor: 'pointer',
  click(ctx) {
    ctx.action('guard:talk', { eventId: ctx.target.id })
  }
})

interruptCurrentPlayerMovement(player?: any): boolean

engine.interruptCurrentPlayerMovement();

mapShakeTrigger: ConfigurableTrigger<MapShakeOptions>

music

playClientVisual(packet: ClientVisualPacket)

playSound(soundId: string, options?: RpgPlaySoundOptions): Promise<void>

// Play a sound synchronously
engine.playSound('item-pickup');

// Play a sound with volume and loop
engine.playSound('background-music', { volume: 0.5, loop: true });

// Play a sound asynchronously (when resolver returns Promise)
await engine.playSound('dynamic-sound', { volume: 0.8 });

// Play a spatial sound without exposing CanvasEngine signals
await engine.playSound('enemy-hit', {
  channel: 'sfx',
  position: { x: enemy.x(), y: enemy.y() },
  listener: { x: player.x(), y: player.y() },
});

pointer: ClientPointerContext

const target = engine.pointer.world()
if (target) engine.processAction('projectile:shoot', { target })

processAction(action: RpgActionName | RpgActionInput, data?: any): void

engine.processAction('projectile:shoot', {
  target: engine.pointer.world(),
  source: 'map-click',
})

processDash(input?: Partial<RpgDashInput>): Promise<void>

await engine.processDash({
  direction: { x: 1, y: 0 },
  additionalSpeed: 10,
  duration: 220,
  cooldown: 600,
})

registerClientVisual(name: string, handler: ClientVisualHandler)

registerClientVisuals(visuals: ClientVisualMap)

registerSpriteComponent(id: string, component: any)

engine.registerSpriteComponent('guildBadge', GuildBadgeComponent);

resolveEventComponent(event: RpgClientEvent): EventComponentConfig | null

setCameraFollow(targetId: string | null, smoothMove?: CameraFollowSmoothMove): void

// Follow another player with default smooth animation
engine.setCameraFollow(otherPlayerId, true);

// Follow an event with custom smooth animation
engine.setCameraFollow(eventId, {
  time: 1000,
  ease: "easeInOutQuad"
});

// Follow without animation (instant)
engine.setCameraFollow(targetId, false);

// Return to following current player
engine.setCameraFollow(null);

setKeyboardControls(controlInstance: any)

// The method is automatically called when a sprite is displayed:
// client.setKeyboardControls(element.directives.controls)

// Later, retrieve and use the controls instance:
import { Input, inject, KeyboardControls } from '@rpgjs/client'

const controls = inject(KeyboardControls)
const control = controls.getControl(Input.Enter)

if (control) {
  console.log(control.actionName) // 'action'
}

setSoundResolver(resolver: (id: string) => any | Promise<any>): void

// Synchronous resolver
engine.setSoundResolver((id) => {
  if (id === 'dynamic-sound') {
    return { id: 'dynamic-sound', src: 'path/to/sound.mp3' };
  }
  return undefined;
});

// Asynchronous resolver (loading from API)
engine.setSoundResolver(async (id) => {
  const response = await fetch(`/api/sounds/${id}`);
  const data = await response.json();
  return data;
});

setSoundVolume(channel: RpgAudioChannel, value: number): void

engine.setSoundVolume('music', 0.6)
engine.setSoundVolume('master', 0.8)

setSpritesheetResolver(resolver: (id: string | number) => any | Promise<any>): void

// Synchronous resolver
engine.setSpritesheetResolver((id) => {
  if (id === 'dynamic-sprite') {
    return { id: 'dynamic-sprite', image: 'path/to/image.png', framesWidth: 32, framesHeight: 32 };
  }
  return undefined;
});

// Asynchronous resolver (loading from API)
engine.setSpritesheetResolver(async (id) => {
  const response = await fetch(`/api/spritesheets/${id}`);
  const data = await response.json();
  return data;
});

startTransition(id: string, props?: any): Promise<void>

// Start a fade transition
engine.startTransition('fade', { duration: 1000, color: 'black' });

// Start with onFinish callback
engine.startTransition('fade', {
  duration: 1000,
  onFinish: () => console.log('Fade complete')
});

// Wait until the transition component calls onFinish
await engine.startTransition('fade', { duration: 1000 });

stopAllSounds(): void

// Stop all sounds
engine.stopAllSounds();

stopSound(soundId: string): void

// Start a looping sound
engine.playSound('background-music', { loop: true });

// Later, stop it
engine.stopSound('background-music');

visualPause