excalibur 0.33.0-alpha.99 → 1.1.0-alpha.310

package/build/esm/src/engine/plugin.d.ts

@@ -0,0 +1,253 @@
+import type { Engine, EngineOptions } from './engine';
+import type { ExcaliburGraphicsContext, ExcaliburGraphicsContextOptions } from './graphics';
+import type { Scene } from './scene';
+/**
+ * An Excalibur Plugin packages up engine modifications into a convenient bundle.
+ *
+ * Plugins are inspired by the [Bevy Plugin System](https://bevy.org/learn/quick-start/getting-started/plugins/)
+ * and allow third-party libraries to configure multiple aspects of Excalibur through a single install,
+ * rather than requiring users to manually wire up loaders, renderers, post-processors, systems, etc.
+ *
+ * Plugins participate in the engine, graphics, and scene lifecycles through a series of optional
+ * hook methods. Each hook is called at a specific point in the initialization flow, giving plugins
+ * the opportunity to register custom renderers, post-processors, ECS systems, resources, or modify
+ * engine configuration.
+ *
+ * ## Lifecycle Order
+ *
+ * 1. **Engine construction** — `onEnginePreConfig` → (flags frozen) → `onEnginePostConfig`
+ * 2. **Engine start** — `onLoad` → (resources loaded) → `onLoadComplete`
+ * 3. **Engine initialize** — `onEnginePreInitialize` → `onEnginePostInitialize`
+ * 4. **Graphics context construction** — `onGraphicsPreConfig` → `onGraphicsPostConfig`
+ * 5. **Graphics context init** — `onGraphicsPreInitialize` → `onGraphicsPostInitialize`
+ * 6. **Scene initialize** — `onScenePreInitialize` → `onScenePostInitialize`
+ * 7. **Scene activate** — `onScenePreActivate` → `onScenePostActivate`
+ * 8. **Scene deactivate** — `onScenePreDeactivate` → `onScenePostDeactivate`
+ * 9. **Graphics context lost/restored** — `onGraphicsContextLost` → `onGraphicsContextRestored`
+ * 10. **Engine dispose** — `dispose`
+ *
+ * ## Example: SDF Text Plugin
+ *
+ * ```typescript
+ * class SDFPlugin extends Plugin {
+ *   name = 'ex.sdf-text';
+ *   priority = 0;
+ *
+ *   onGraphicsPostInitialize(context: ExcaliburGraphicsContext) {
+ *     context.lazyRegister('ex.sdf-text-renderer', () => new SDFTextRenderer());
+ *   }
+ *
+ *   dispose() {
+ *     // clean up any plugin-owned resources
+ *   }
+ * }
+ *
+ * const game = new Engine({
+ *   plugins: [new SDFPlugin()]
+ * });
+ * ```
+ *
+ * Plugins can also be added after construction via {@apilink Engine.addPlugin}.
+ */
+export declare abstract class Plugin {
+    readonly name: string;
+    /**
+     * Unique name of the plugin, pick something unique (official excalibur plugins use the reserved prefix "ex.").
+     * Used for deduplication — attempting to add a plugin
+     * with a name that is already installed will produce a warning and be skipped.
+     * @param name
+     */
+    constructor(name: string);
+    /**
+     * Plugin priority determines the order hooks are run across all installed plugins.
+     *
+     * Lower numbers run first, higher numbers run last. Default is `0`.
+     * Plugins that need to configure things before others (e.g. registering a base
+     * renderer that other plugins extend) should use a lower priority.
+     */
+    priority: number;
+    /**
+     * Perform any async loading the plugin needs before the engine starts.
+     *
+     * Called during {@apilink Engine.start} before the loader runs. Use this to
+     * fetch configuration, preload data, or set up async resources.
+     *
+     * @returns A promise that resolves when loading is complete
+     */
+    onLoad?(): Promise<void>;
+    /**
+     * Called after all loader resources have finished loading but before the engine
+     * initializes. Use this to finalize any setup that depended on loaded data.
+     *
+     * @returns A promise that resolves when complete
+     */
+    onLoadComplete?(): Promise<void>;
+    /**
+     * Intercept and mutate the @[apilink EngineOptions} passed into the Engine, and/or modify
+     * the engine before any other configuration happens.
+     *
+     * This is the first hook called during engine construction. Feature flags can still
+     * be modified at this point (before {@apilink Flags.freeze}).
+     *
+     * @param engine  The engine being constructed
+     * @param options The user-provided engine options (mutable)
+     */
+    onEnginePreConfig?(engine: Engine, options: EngineOptions): void;
+    /**
+     * Intercept and mutate the engine after core configuration is done but before the
+     * engine is fully constructed.
+     *
+     * Called near the end of the Engine constructor, after inputs and visibility handlers
+     * are wired up. Feature flags are frozen at this point.
+     *
+     * @param engine  The engine being constructed
+     * @param options The user-provided engine options
+     */
+    onEnginePostConfig?(engine: Engine, options: EngineOptions): void;
+    /**
+     * Intercept the engine and modify it before initialization.
+     *
+     * Called during {@apilink Engine.start} after loading completes but before
+     * {@apilink Engine.onInitialize} and the director initialization.
+     *
+     * @param engine The engine about to be initialized
+     */
+    onEnginePreInitialize?(engine: Engine): void;
+    /**
+     * Intercept the engine and modify it after initialization.
+     *
+     * Called after {@apilink Engine.onInitialize} and the director initialization,
+     * and after the `'initialize'` event is emitted.
+     *
+     * @param engine The initialized engine
+     */
+    onEnginePostInitialize?(engine: Engine): void;
+    /**
+     * Intercept the graphics context before it is configured and modify either the
+     * context or the options.
+     *
+     * This is the very first graphics hook, called at the start of the
+     * {@apilink ExcaliburGraphicsContextWebGL} constructor before the WebGL context
+     * is created. Use this to modify graphics options before they are applied.
+     *
+     * @param context The graphics context being constructed
+     * @param options The graphics context options (mutable)
+     */
+    onGraphicsPreConfig?(context: ExcaliburGraphicsContext, options: ExcaliburGraphicsContextOptions): void;
+    /**
+     * Intercept the graphics context after it is configured but before initialization.
+     *
+     * Called after the WebGL context is created and all configuration properties are set,
+     * but before built-in renderers and render targets are initialized.
+     *
+     * @param context The graphics context being constructed
+     * @param options The graphics context options
+     */
+    onGraphicsPostConfig?(context: ExcaliburGraphicsContext, options: ExcaliburGraphicsContextOptions): void;
+    /**
+     * Intercept the graphics context and modify it before initialization.
+     *
+     * Called at the start of the graphics context's `_init()` method, before the
+     * orthographic projection, viewport, built-in renderers, and render targets are set up.
+     *
+     * @param context The graphics context being initialized
+     */
+    onGraphicsPreInitialize?(context: ExcaliburGraphicsContext): void;
+    /**
+     * Intercept the graphics context and modify it after initialization.
+     *
+     * This is the recommended hook for registering custom {@apilink RendererPlugin}s via
+     * {@apilink ExcaliburGraphicsContext.register} or
+     * {@apilink ExcaliburGraphicsContext.lazyRegister}, and for adding
+     * {@apilink PostProcessor}s via {@apilink ExcaliburGraphicsContext.addPostProcessor}.
+     *
+     * Called after all built-in renderers and render targets are initialized.
+     *
+     * @param context The initialized graphics context
+     */
+    onGraphicsPostInitialize?(context: ExcaliburGraphicsContext): void;
+    /**
+     * Intercept a scene and modify it before initialization.
+     *
+     * Called after the scene's ECS systems are initialized but before the user's
+     * {@apilink Scene.onInitialize} runs. Use this to add default ECS systems,
+     * components, or resources to every scene.
+     *
+     * @param scene The scene being initialized
+     */
+    onScenePreInitialize?(scene: Scene): void;
+    /**
+     * Intercept a scene and modify it after initialization.
+     *
+     * Called after the user's {@apilink Scene.onInitialize} and child initialization
+     * are complete, but before the scene's `'initialize'` event is emitted.
+     *
+     * @param scene The initialized scene
+     */
+    onScenePostInitialize?(scene: Scene): void;
+    /**
+     * Intercept a scene before it is activated.
+     *
+     * Called when a scene becomes the current scene, before the user's
+     * {@apilink Scene.onActivate} runs.
+     *
+     * @param scene The scene being activated
+     */
+    onScenePreActivate?(scene: Scene): void;
+    /**
+     * Intercept a scene after it is activated.
+     *
+     * Called after the user's {@apilink Scene.onActivate} completes.
+     *
+     * @param scene The activated scene
+     */
+    onScenePostActivate?(scene: Scene): void;
+    /**
+     * Intercept a scene before it is deactivated.
+     *
+     * Called when a scene is about to stop being the current scene, before the user's
+     * {@apilink Scene.onDeactivate} runs.
+     *
+     * @param scene The scene being deactivated
+     */
+    onScenePreDeactivate?(scene: Scene): void;
+    /**
+     * Intercept a scene after it is deactivated.
+     *
+     * Called after the user's {@apilink Scene.onDeactivate} completes.
+     *
+     * @param scene The deactivated scene
+     */
+    onScenePostDeactivate?(scene: Scene): void;
+    /**
+     * Called when the WebGL graphics context is lost (e.g. GPU driver crash).
+     *
+     * Plugins that manage WebGL resources (shaders, buffers, textures) should
+     * implement this to mark their resources as invalid. The context will be
+     * restored and {@apilink onGraphicsContextRestored} will be called, after which
+     * {@apilink onGraphicsPreInitialize} and {@apilink onGraphicsPostInitialize}
+     * will re-run so resources can be rebuilt.
+     *
+     * @param context The graphics context that was lost
+     */
+    onGraphicsContextLost?(context: ExcaliburGraphicsContext): void;
+    /**
+     * Called when the WebGL graphics context is restored after being lost.
+     *
+     * After this hook, the graphics context's `_init()` method re-runs, which will
+     * call {@apilink onGraphicsPreInitialize} and {@apilink onGraphicsPostInitialize}
+     * again so plugins can rebuild their WebGL resources.
+     *
+     * @param context The graphics context that was restored
+     */
+    onGraphicsContextRestored?(context: ExcaliburGraphicsContext): void;
+    /**
+     * Perform any cleanup necessary when the engine is disposed.
+     *
+     * Called during {@apilink Engine.dispose} after the engine is stopped and
+     * inputs are disabled, but before the canvas is removed and the graphics context
+     * is disposed. Use this to free plugin-owned resources, remove event listeners,
+     * or dispose of custom renderers.
+     */
+    dispose?(): void;
+}

package/build/{dist → esm/src/engine}/resources/resource.d.ts

@@ -15,6 +15,14 @@ export declare const ResourceEvents: {
     Progress: string;
     Error: string;
 };
+/**
+ * Error thrown when a resource fails to load due to network issues,
+ * CORS problems, or the resource being unreachable.
+ */
+export declare class ResourceLoadingError extends Error {
+    path: string;
+    constructor(path: string, message: string);
+}
 /**
  * The {@apilink Resource} type allows games built in Excalibur to load generic resources.
  * For any type of remote resource it is recommended to use {@apilink Resource} for preloading.

package/build/{dist → esm/src/engine}/resources/sound/index.d.ts

@@ -1,4 +1,4 @@
 export * from './sound';
 export * from './sound-manager';
 export * from './audio-context';
-export * from './web-audio-instance';
+export * from './sound-track';

package/build/esm/src/engine/resources/sound/sound-manager.d.ts

@@ -0,0 +1,378 @@
+import type { Loadable } from '../../interfaces/loadable';
+import type { Engine } from '../../engine';
+import { Sound, type PlayOptions } from './sound';
+import type { SoundTrack } from './sound-track';
+export type AnyString = {} & string;
+export interface SoundConfig<Channel extends string = string, SName extends string = string> {
+    sound: Sound<SName>;
+    /**
+     * Optional explicit name for this sound in the manager. If omitted, the
+     * sound's own {@apilink Sound.name} (basename-without-extension) is used.
+     */
+    name?: SName;
+    /**
+     * Mix volume [0-1] for this sound, default 1 (full volume). Multiplies with the
+     * sound's own volume, its channel volume, and the master volume.
+     */
+    volume?: number;
+    /**
+     * The {@apilink SoundChannel} this sound is routed through, for example 'music' or 'sfx'.
+     * Channel volume, mute and effects apply to every sound in the channel. Sounds without a
+     * channel route straight to the manager's master output.
+     */
+    channel?: Channel;
+}
+/**
+ * Context for {@apilink AudioBusBuilder} useful for custom effects
+ */
+export interface AudioBusContext {
+    /**
+     * Browser Web Audio API context
+     */
+    readonly audioContext: AudioContext;
+    /**
+     * Gain the bus sources
+     */
+    readonly input: GainNode;
+    /**
+     * Carries the bus volume and mute, out to speakers
+     */
+    readonly output: GainNode;
+}
+/**
+ * Lifecycle hook that wires a bus ({@apilink SoundChannel} or the {@apilink SoundManager} master)
+ * when it is created, replacing the default `input → output` edge. Use it to insert effects that
+ * apply to every sound on the bus:
+ *
+ * ```typescript
+ * const manager = new ex.SoundManager({
+ *   channels: [
+ *     'sfx',
+ *     {
+ *       name: 'music',
+ *       onConnect: ({ audioContext, input, output }) => {
+ *         const muffle = audioContext.createBiquadFilter();
+ *         muffle.type = 'lowpass';
+ *         input.connect(muffle).connect(output);
+ *       }
+ *     }
+ *   ],
+ *   onConnect: ({ audioContext, input, output }) => {
+ *     input.connect(audioContext.createDynamicsCompressor()).connect(output);
+ *   },
+ *   sounds: [...]
+ * });
+ * ```
+ */
+export type AudioBusBuilder = (ctx: AudioBusContext) => void;
+export interface SoundChannelOptions<Channel extends string = string> {
+    name: Channel;
+    /**
+     * Channel volume [0-1], default 1
+     */
+    volume?: number;
+    /**
+     * Maximum number of simultaneously playing tracks in this channel, default unbounded.
+     * See {@apilink SoundManagerOptions.voiceStealing} for what happens at the cap.
+     */
+    maxConcurrentTracks?: number;
+    /**
+     * What happens when a `maxConcurrentTracks` cap
+     * *`false` (default) drops the new play
+     * *`true` stops the oldest playing track in that scope to make room for it.
+     */
+    voiceStealing?: boolean;
+    /**
+     * Wire the channel's `input` to its `output` through effects, see {@apilink AudioBusBuilder}
+     */
+    onConnect?: AudioBusBuilder;
+}
+export interface SoundManagerOptions<Channel extends string = string, SoundName extends string = string> {
+    /**
+     * Optionally specify the possible channels to avoid typo's, as names or {@apilink SoundChannelOptions}
+     */
+    channels?: readonly (Channel | SoundChannelOptions<Channel>)[];
+    /**
+     * The sounds to manage, each optionally with a mix `volume` and a `channel`.
+     */
+    sounds: readonly (SoundConfig<NoInfer<Channel>, SoundName> | Sound<SoundName>)[];
+    /**
+     * Master volume [0-1] for every sound in this manager
+     *
+     * Default is 1 (100%)
+     */
+    volume?: number;
+    /**
+     * Maximum number of simultaneously playing tracks allowed across ALL sounds
+     * managed by this {@apilink SoundManager}. Default is unbounded (`Infinity`).
+     * Channels can set their own cap with {@apilink SoundChannelOptions.maxConcurrentTracks}.
+     */
+    maxConcurrentTracks?: number;
+    /**
+     * What happens when a `maxConcurrentTracks` cap
+     * *`false` (default) drops the new play
+     * *`true` stops the oldest playing track in that scope to make room for it.
+     */
+    voiceStealing?: boolean;
+    /**
+     * Wire the master `input` to `output` through effects (e.g. a compressor), see {@apilink AudioBusBuilder}
+     */
+    onConnect?: AudioBusBuilder;
+}
+/**
+ * A group of sounds with a shared gain stage: `input → output → SoundManager.output`.
+ *
+ * Every sound in the channel is mixed into {@apilink SoundChannel.input}; {@apilink SoundChannel.output}
+ * carries the channel volume and mute. Insert Web Audio effects between the two to process the
+ * whole channel at once:
+ *
+ * ```typescript
+ * const music = manager.getChannel('music');
+ * const muffle = music.audioContext.createBiquadFilter();
+ * muffle.type = 'lowpass';
+ * music.input.disconnect();
+ * music.input.connect(muffle).connect(music.output);
+ * ```
+ */
+export declare class SoundChannel {
+    readonly name: string;
+    readonly audioContext: AudioContext;
+    /**
+     * Gain node every sound in the channel connects to
+     */
+    readonly input: GainNode;
+    /**
+     * Output gain node that carries the channel volume and mute, connected to the manager's master input
+     */
+    readonly output: GainNode;
+    /**
+     * Maximum number of simultaneously playing tracks in this channel, default Infinity
+     */
+    maxConcurrentTracks: number;
+    /**
+     * What happens when a `maxConcurrentTracks` cap
+     * *`false` (default) drops the new play
+     * *`true` stops the oldest playing track in that scope to make room for it.
+     */
+    voiceStealing: boolean;
+    private _sounds;
+    private _volume;
+    private _muted;
+    constructor(name: string, audioContext: AudioContext, master: AudioNode, options?: Omit<SoundChannelOptions, 'name'>);
+    /**
+     * Sounds currently routed through this channel
+     */
+    get sounds(): readonly Sound[];
+    /**
+     * Number of currently-playing tracks across the channel's sounds
+     */
+    playingCount(): number;
+    /**
+     * Channel volume [0-1], default 1
+     */
+    get volume(): number;
+    set volume(volume: number);
+    get muted(): boolean;
+    /**
+     * Global mute, mutes all sounds managed by the SoundManager by muting the master output node
+     */
+    mute(): void;
+    /**
+     *
+     * Global unmute, unmutes all sounds managed by the SoundManager by setting the gain on the master output node to SoundManager.volume.
+     * **Warning** Does not unmute specifically muted channels
+     */
+    unmute(): void;
+    toggle(): void;
+    private _apply;
+    /**
+     * @internal
+     */
+    _add(sound: Sound): void;
+    /**
+     * @internal
+     */
+    _remove(sound: Sound): void;
+}
+export interface SoundManagerApi {
+    setVolume(name: string, volume?: number): void;
+    play(name: string, options?: number | PlayOptions): Promise<boolean>;
+    stop(name?: string): void;
+    mute(name?: string): void;
+    unmute(name?: string): void;
+    toggle(name?: string): void;
+}
+/**
+ * Operations on {@apilink SoundChannel}s by name, see {@apilink SoundManager.channel}
+ */
+export declare class ChannelCollection<Channel extends string> implements SoundManagerApi {
+    soundManager: SoundManager<Channel, string>;
+    constructor(soundManager: SoundManager<Channel, string>);
+    /**
+     * Get the {@apilink SoundChannel} for direct access to its volume, mute and audio nodes
+     */
+    get(name: Channel): SoundChannel;
+    /**
+     * Stop every sound in the channel
+     */
+    stop(name: Channel): void;
+    /**
+     * Set the channel volume [0-1]
+     */
+    setVolume(name: Channel, volume?: number): void;
+    getVolume(name: Channel): number;
+    /**
+     * Play every sound in the channel, resolves to true if every sound played, false if any was
+     * dropped by a concurrency cap.
+     */
+    play(name: Channel, options?: number | PlayOptions): Promise<boolean>;
+    mute(name: Channel): void;
+    unmute(name: Channel): void;
+    toggle(name: Channel): void;
+    isMuted(name: Channel): boolean;
+}
+/**
+ * Manages a set of sounds through a Web Audio mixer graph:
+ *
+ * `Sound.output → mix gain → SoundChannel (input → output) → SoundManager.output → speakers`
+ *
+ * Master, channel and per-sound mix volumes and mutes compose in the graph, so muting is silent
+ * playback rather than a pause and none of it touches {@apilink Sound.volume}. A SoundManager is
+ * {@apilink Loadable}, add it to a {@apilink Loader} to load every sound it manages.
+ */
+export declare class SoundManager<const Channel extends string, const SoundName extends string> implements SoundManagerApi, Loadable<AudioBuffer[]> {
+    private _audioContext;
+    /**
+     * Master bus input every channel (and channel-less sound) is mixed into
+     */
+    readonly input: GainNode;
+    /**
+     * Master gain carrying the master volume and mute, connected to the audio context destination
+     */
+    readonly output: GainNode;
+    /**
+     * Stop the oldest playing track to make room when a cap is reached instead of dropping the new play
+     */
+    voiceStealing: boolean;
+    private _sounds;
+    private _names;
+    private _mix;
+    private _soundChannel;
+    private _channels;
+    private _engine?;
+    private _logger;
+    private _volume;
+    private _muted;
+    /**
+     * Maximum number of simultaneously playing tracks across ALL managed sounds.
+     * Default is `Infinity` (unbounded). When the cap is reached, new `play()`
+     * calls are dropped.
+     */
+    maxConcurrentTracks: number;
+    channel: ChannelCollection<Channel>;
+    /**
+     * Decoded audio of every managed sound once loaded, see {@apilink Loadable}
+     */
+    data: AudioBuffer[];
+    constructor(options: SoundManagerOptions<Channel, SoundName>);
+    /**
+     * Master volume [0-1], default 1
+     */
+    get volume(): number;
+    set volume(volume: number);
+    /**
+     * Whether the master output is muted
+     */
+    get muted(): boolean;
+    /**
+     * Load every managed sound
+     */
+    load(): Promise<AudioBuffer[]>;
+    isLoaded(): boolean;
+    /**
+     * Wire every managed sound (including ones tracked later) to the engine so
+     * they pause when hidden and stop with it. Called by the {@apilink Loader}.
+     */
+    wireEngine(engine: Engine): void;
+    /**
+     * Total number of currently-playing tracks across all managed sounds
+     */
+    playingCount(): number;
+    getSounds(): readonly Sound[];
+    /**
+     * Get a {@apilink SoundChannel}, creating it on first use
+     */
+    getChannel(name: Channel): SoundChannel;
+    getChannels(): readonly SoundChannel[];
+    getSoundsForChannel(channel: Channel | AnyString): readonly Sound[];
+    /**
+     * Route a tracked sound through a channel, or `null` for straight to the master output
+     */
+    setChannel(name: SoundName, channel: Channel | null): void;
+    setChannel(sound: Sound, channel: Channel | null): void;
+    /**
+     * Whether a sound is silenced by its own mute, its channel's mute, or the master mute
+     */
+    isMuted(name: SoundName): boolean;
+    isMuted(sound: Sound): boolean;
+    /**
+     * Resolve a registered name or a bare {@apilink Sound} to the sound. A bare
+     * Sound resolves by identity (not by its own name) so aliases registered via
+     * `track('gold', coin)` work, and an untracked Sound resolves to itself.
+     */
+    private _resolve;
+    /**
+     * Play a sound with optional one-off {@apilink PlayOptions}. Resolves to false if the sound
+     * is unknown or dropped by a concurrency cap. Muted sounds still play (silently) so they are
+     * audible mid-clip when unmuted.
+     */
+    play(name: SoundName, options?: number | PlayOptions): Promise<boolean>;
+    play(sound: Sound, options?: number | PlayOptions): Promise<boolean>;
+    /**
+     * Like {@apilink SoundManager.play} but returns the {@apilink SoundTrack} synchronously, or
+     * `null` if the play was dropped.
+     */
+    start(name: SoundName, options?: PlayOptions): SoundTrack | null;
+    start(sound: Sound, options?: PlayOptions): SoundTrack | null;
+    /**
+     * Returns whether a new track fits under `max`, stopping the oldest playing track among
+     * `sounds` first when voiceStealing is on
+     */
+    private _makeRoom;
+    getSound(name: SoundName | AnyString): Sound | null;
+    getSound(sound: Sound): Sound;
+    /**
+     * Set the mix volume [0-1] of a tracked sound (or {@apilink Sound.volume} for an untracked one)
+     */
+    setVolume(name: SoundName, volume?: number): void;
+    setVolume(sound: Sound, volume?: number): void;
+    /**
+     * Get the mix volume of a tracked sound (or {@apilink Sound.volume} for an untracked one)
+     */
+    getVolume(name: SoundName): number;
+    getVolume(sound: Sound): number;
+    private _applyMix;
+    /**
+     * Start managing a sound, registered under `name`, the config's `name`, or the sound's own name.
+     * Its output is re-routed through the manager's mixer graph.
+     */
+    track(sound: Sound | SoundConfig): void;
+    track(name: SoundName | AnyString, soundOrConfig: Sound | SoundConfig): void;
+    /**
+     * Stop managing a sound, restoring its output straight to the speakers
+     */
+    untrack(name: SoundName): void;
+    untrack(sound: Sound): void;
+    stop(name?: SoundName): void;
+    stop(sound: Sound): void;
+    /**
+     * Mute a tracked sound, or the master output when no sound is given. Playback continues silently.
+     */
+    mute(name?: SoundName): void;
+    mute(sound: Sound): void;
+    unmute(name?: SoundName): void;
+    unmute(sound: Sound): void;
+    toggle(name?: SoundName): void;
+    toggle(sound: Sound): void;
+    private _setMuted;
+}