@utsp/core 0.4.0-nightly.20251201222332.2d9d7a5 → 0.4.0-nightly.20251203172602.bbfc50f

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import { Vector2, AxisSource, ButtonSource, InputBindingLoadPacket, AxisBinding, ButtonBinding, UserRenderState } from '@utsp/types';
+import * as _utsp_types from '@utsp/types';
+import { Vector2, AxisSource, ButtonSource, InputBindingLoadPacket, AxisBinding, ButtonBinding, SoundInstanceId, AudioConfigCommand, PlaySoundCommand, StopSoundCommand, FadeOutSoundCommand, PauseSoundCommand, ResumeSoundCommand, IAudioProcessor, SoundFormat, SoundLoadType, SoundLoadPacket, SoundExternalLoadPacket, UserRenderState } from '@utsp/types';
 export { AxisBinding, AxisSource, ButtonBinding, ButtonSource, InputBindingLoadPacket, RenderState, RenderedCell, UserRenderState, Vector2 } from '@utsp/types';
 
 /**
@@ -1572,6 +1573,13 @@ declare class User<TData = Record<string, any>> {
     private activeTouchId;
     private inputBindings;
     private stats;
+    private soundCommands;
+    private nextSoundInstanceId;
+    private audioConfigCommands;
+    private lastListenerX;
+    private lastListenerY;
+    private pendingSendSounds;
+    private audioProcessor?;
     /**
      * Application-specific data storage
      * Use this to store game state, player data, or any custom information
@@ -2209,6 +2217,312 @@ declare class User<TData = Record<string, any>> {
      * ```
      */
     decodeAndApplyCompressedInput(buffer: Uint8Array): void;
+    /**
+     * Play a sound for this user
+     *
+     * The sound command is queued and will be sent to the client
+     * at the end of the current tick by the runtime.
+     *
+     * @param sound - Sound name (e.g., 'coin') or ID (0-255)
+     * @param options - Playback options (volume, pitch, loop, fadeIn, position)
+     * @returns Instance ID that can be used to stop this specific sound later
+     *
+     * @example
+     * ```typescript
+     * // In updateUser()
+     * if (playerCollectedCoin) {
+     *   user.playSound('coin');
+     * }
+     *
+     * // With options
+     * user.playSound('explosion', { volume: 0.8, pitch: 0.9 });
+     *
+     * // Loop background music with fade in
+     * const musicId = user.playSound('music', { loop: true, volume: 0.5, fadeIn: 2 });
+     * // Later: user.fadeOutSound(musicId, 2);
+     *
+     * // Spatial audio (x/y position 0-65535)
+     * user.playSound('explosion', { x: 10000, y: 32768 });
+     * ```
+     */
+    playSound(sound: string | number, options?: {
+        volume?: number;
+        pitch?: number;
+        loop?: boolean;
+        fadeIn?: number;
+        x?: number;
+        y?: number;
+    }): SoundInstanceId;
+    /**
+     * Stop a sound immediately by instance ID or name
+     *
+     * @param target - Instance ID (number) to stop specific instance,
+     *                 or sound name (string) to stop all instances of that sound
+     *
+     * @example
+     * ```typescript
+     * // Stop specific instance by ID
+     * const musicId = user.playSound('music', { loop: true });
+     * user.stopSound(musicId);
+     *
+     * // Stop all instances of a sound by name
+     * user.stopSound('explosion');
+     * ```
+     */
+    stopSound(target: SoundInstanceId | string): void;
+    /**
+     * Fade out and stop a sound
+     *
+     * @param target - Instance ID (number) to fade specific instance,
+     *                 or sound name (string) to fade all instances of that sound
+     * @param duration - Fade duration in seconds
+     *
+     * @example
+     * ```typescript
+     * // Fade out specific instance over 2 seconds
+     * const musicId = user.playSound('music', { loop: true, fadeIn: 1 });
+     * // Later, when changing scene:
+     * user.fadeOutSound(musicId, 2);
+     *
+     * // Fade out all ambient sounds
+     * user.fadeOutSound('ambient', 1.5);
+     * ```
+     */
+    fadeOutSound(target: SoundInstanceId | string, duration: number): void;
+    /**
+     * Fade out and stop all sounds for this user
+     *
+     * @param duration - Fade duration in seconds
+     *
+     * @example
+     * ```typescript
+     * // When entering a cutscene, fade out all game audio
+     * user.fadeOutAllSounds(1);
+     * ```
+     */
+    fadeOutAllSounds(duration: number): void;
+    /**
+     * Stop all sounds immediately for this user
+     *
+     * @example
+     * ```typescript
+     * // When player dies or game pauses
+     * user.stopAllSounds();
+     * ```
+     */
+    stopAllSounds(): void;
+    /**
+     * Pause a sound by instance ID or name
+     *
+     * @param target - Instance ID (number) to pause specific instance,
+     *                 or sound name (string) to pause all instances of that sound
+     *
+     * @example
+     * ```typescript
+     * // Pause specific instance
+     * const musicId = user.playSound('music', { loop: true });
+     * user.pauseSound(musicId);
+     * // Later: user.resumeSound(musicId);
+     *
+     * // Pause all ambient sounds
+     * user.pauseSound('ambient');
+     * ```
+     */
+    pauseSound(target: SoundInstanceId | string): void;
+    /**
+     * Pause all sounds for this user
+     *
+     * @example
+     * ```typescript
+     * // When opening pause menu
+     * user.pauseAllSounds();
+     * ```
+     */
+    pauseAllSounds(): void;
+    /**
+     * Resume a paused sound by instance ID or name
+     *
+     * @param target - Instance ID (number) to resume specific instance,
+     *                 or sound name (string) to resume all instances of that sound
+     *
+     * @example
+     * ```typescript
+     * // Resume specific instance
+     * user.resumeSound(musicId);
+     *
+     * // Resume all ambient sounds
+     * user.resumeSound('ambient');
+     * ```
+     */
+    resumeSound(target: SoundInstanceId | string): void;
+    /**
+     * Resume all paused sounds for this user
+     *
+     * @example
+     * ```typescript
+     * // When closing pause menu
+     * user.resumeAllSounds();
+     * ```
+     */
+    resumeAllSounds(): void;
+    /**
+     * Set the listener position for spatial audio
+     *
+     * The listener is the "ear" of the player. Sounds with positions
+     * will be panned and attenuated based on their distance to the listener.
+     *
+     * @param x - X position (0-65535, typically matches player position)
+     * @param y - Y position (0-65535, typically matches player position)
+     *
+     * @example
+     * ```typescript
+     * // In updateUser(), follow the player
+     * user.setListenerPosition(player.x, player.y);
+     *
+     * // Play spatial sound (will be panned/attenuated based on distance)
+     * user.playSound('explosion', { x: 100, y: 50 });
+     * ```
+     */
+    setListenerPosition(x: number, y: number): void;
+    /**
+     * Configure spatial audio parameters
+     *
+     * @param options - Spatial audio configuration options
+     *
+     * @example
+     * ```typescript
+     * // Configure for a smaller game world
+     * user.configureSpatialAudio({
+     *   maxDistance: 100,      // Sounds beyond 100 units are silent
+     *   referenceDistance: 10, // Full volume within 10 units
+     *   rolloffFactor: 1,      // Linear attenuation
+     *   panSpread: 0.8         // Strong stereo panning
+     * });
+     * ```
+     */
+    configureSpatialAudio(options: {
+        maxDistance?: number;
+        referenceDistance?: number;
+        rolloffFactor?: number;
+        panSpread?: number;
+    }): void;
+    /**
+     * Get pending audio config commands and clear the queue
+     *
+     * Called by the runtime at the end of each tick to send commands to client.
+     *
+     * @returns Array of audio config commands to send
+     * @internal
+     */
+    flushAudioConfigCommands(): AudioConfigCommand[];
+    /**
+     * Check if there are pending audio config commands
+     *
+     * @returns true if there are commands to send
+     * @internal
+     */
+    hasAudioConfigCommands(): boolean;
+    /**
+     * Get pending sound commands and clear the queue
+     *
+     * Called by the runtime at the end of each tick to send commands to client.
+     *
+     * @returns Array of sound commands to send
+     * @internal
+     */
+    flushSoundCommands(): Array<PlaySoundCommand | StopSoundCommand | FadeOutSoundCommand | PauseSoundCommand | ResumeSoundCommand>;
+    /**
+     * Check if there are pending sound commands
+     *
+     * @returns true if there are commands to send
+     * @internal
+     */
+    hasSoundCommands(): boolean;
+    /**
+     * Request to send all registered sounds to this user
+     *
+     * Call this when you want to transfer audio assets to the client.
+     * Useful for showing a loading screen before sending large audio files.
+     *
+     * The sounds will be sent at the end of the current tick.
+     *
+     * @example
+     * ```typescript
+     * initUser(core: Core, user: User): void {
+     *   // Show loading screen
+     *   this.showLoadingScreen(user);
+     *
+     *   // Request sounds to be sent
+     *   user.sendSounds();
+     * }
+     *
+     * updateUser(core: Core, user: User, deltaTime: number): void {
+     *   // Check if sounds are loaded (via client ACK or timeout)
+     *   if (user.data.soundsLoaded) {
+     *     this.hideLoadingScreen(user);
+     *   }
+     * }
+     * ```
+     */
+    sendSounds(): void;
+    /**
+     * Check if sounds need to be sent to this user
+     *
+     * @returns true if sendSounds() was called
+     * @internal
+     */
+    needsSendSounds(): boolean;
+    /**
+     * Clear the pending send sounds flag
+     *
+     * Called by the runtime after sending sounds.
+     *
+     * @internal
+     */
+    clearSendSounds(): void;
+    /**
+     * Set the audio processor for this user
+     *
+     * Called by ClientRuntime to inject the AudioManager.
+     * This enables unified audio handling in both standalone and connected modes.
+     *
+     * @param processor - The audio processor (typically AudioManager)
+     * @internal
+     */
+    setAudioProcessor(processor: IAudioProcessor): void;
+    /**
+     * Get the audio processor
+     *
+     * @returns The audio processor, or undefined if not set
+     * @internal
+     */
+    getAudioProcessor(): IAudioProcessor | undefined;
+    /**
+     * Apply audio commands (play/stop/fadeOut/pause/resume sounds)
+     *
+     * This is the unified entry point for audio playback, used by both:
+     * - ClientRuntime (standalone mode): applies commands from local queue
+     * - NetworkSync (connected mode): applies commands received from server
+     *
+     * In server mode, this method does nothing (audio is played on client only).
+     *
+     * @param commands - Array of sound commands
+     * @internal
+     */
+    applyAudioCommands(commands: Array<PlaySoundCommand | StopSoundCommand | FadeOutSoundCommand | PauseSoundCommand | ResumeSoundCommand>): void;
+    /**
+     * Apply audio configuration commands (listener position, spatial config)
+     *
+     * This is the unified entry point for audio configuration, used by both:
+     * - ClientRuntime (standalone mode): applies commands from local queue
+     * - NetworkSync (connected mode): applies commands received from server
+     *
+     * In server mode, this method does nothing (audio is configured on client only).
+     *
+     * @param commands - Array of audio configuration commands
+     * @internal
+     */
+    applyAudioConfigCommands(commands: AudioConfigCommand[]): void;
 }
 
 /**
@@ -2459,6 +2773,156 @@ declare class BitmapFontRegistry {
     getFontCount(): number;
 }
 
+/**
+ * SoundRegistry - Server-side registry for audio assets
+ *
+ * Stores sound definitions that will be sent to clients.
+ * Supports both File (embedded data) and External (URL reference) modes.
+ *
+ * @example
+ * ```typescript
+ * const registry = new SoundRegistry();
+ *
+ * // Register a sound with embedded data (File mode)
+ * const coinData = fs.readFileSync('./assets/coin.mp3');
+ * registry.registerFile('coin', 'mp3', coinData);
+ *
+ * // Register an external sound (FileExternal mode)
+ * registry.registerExternal('music', 'mp3', 'https://cdn.example.com/music.mp3', 1500000);
+ *
+ * // Generate load packets for client
+ * const packets = registry.toLoadPackets();
+ * ```
+ */
+
+/**
+ * Internal representation of a registered sound
+ */
+interface SoundEntry {
+    /** Unique sound identifier (0-255) */
+    soundId: number;
+    /** Human-readable name */
+    name: string;
+    /** Loading mode: 'file' (embedded) or 'external' (URL) */
+    loadType: SoundLoadType;
+    /** Audio format */
+    format: SoundFormat;
+    /** Raw audio data (only for 'file' mode) */
+    data?: Uint8Array;
+    /** URL to fetch from (only for 'external' mode) */
+    url?: string;
+    /** Expected file size in bytes */
+    size?: number;
+    /** Checksum for validation */
+    checksum?: string;
+}
+/**
+ * SoundRegistry - Manages sound definitions on the server
+ */
+declare class SoundRegistry {
+    private sounds;
+    private nameToId;
+    private nextId;
+    /**
+     * Register a sound with embedded data (File mode)
+     * The audio data will be sent directly to clients via UTSP
+     *
+     * @param name - Human-readable name for the sound
+     * @param format - Audio format (mp3, wav, ogg, etc.)
+     * @param data - Raw audio file data
+     * @returns The assigned sound ID
+     */
+    registerFile(name: string, format: SoundFormat, data: Uint8Array): number;
+    /**
+     * Register a sound with embedded data using a specific ID
+     *
+     * @param soundId - Specific ID to use (0-255)
+     * @param name - Human-readable name for the sound
+     * @param format - Audio format
+     * @param data - Raw audio file data
+     */
+    registerFileWithId(soundId: number, name: string, format: SoundFormat, data: Uint8Array): void;
+    /**
+     * Register an external sound (FileExternal mode)
+     * Only the URL is sent to clients, they download from the external source
+     *
+     * @param name - Human-readable name for the sound
+     * @param format - Audio format
+     * @param url - URL where the audio file can be downloaded
+     * @param size - Optional file size in bytes (for progress tracking)
+     * @param checksum - Optional checksum for validation
+     * @returns The assigned sound ID
+     */
+    registerExternal(name: string, format: SoundFormat, url: string, size?: number, checksum?: string): number;
+    /**
+     * Register an external sound using a specific ID
+     */
+    registerExternalWithId(soundId: number, name: string, format: SoundFormat, url: string, size?: number, checksum?: string): void;
+    /**
+     * Get a sound entry by ID or name
+     */
+    get(idOrName: number | string): SoundEntry | undefined;
+    /**
+     * Check if a sound exists
+     */
+    has(idOrName: number | string): boolean;
+    /**
+     * Get all sound entries
+     */
+    getAll(): SoundEntry[];
+    /**
+     * Get all file-mode sounds
+     */
+    getFileSounds(): SoundEntry[];
+    /**
+     * Get all external-mode sounds
+     */
+    getExternalSounds(): SoundEntry[];
+    /**
+     * Get all sound names
+     */
+    getNames(): string[];
+    /**
+     * Get sound ID by name
+     */
+    getId(name: string): number | undefined;
+    /**
+     * Generate load packets for all registered sounds
+     * Separates File and External sounds into different packets
+     *
+     * @returns Array of load packets ready to send to clients
+     */
+    toLoadPackets(): Array<SoundLoadPacket | SoundExternalLoadPacket>;
+    /**
+     * Generate a load packet for a specific sound
+     */
+    toLoadPacket(idOrName: number | string): SoundLoadPacket | SoundExternalLoadPacket | null;
+    /**
+     * Unregister a sound
+     */
+    unregister(idOrName: number | string): boolean;
+    /**
+     * Clear all registered sounds
+     */
+    clear(): void;
+    /**
+     * Get the number of registered sounds
+     */
+    get size(): number;
+    /**
+     * Get registry statistics
+     */
+    getStats(): {
+        total: number;
+        file: number;
+        external: number;
+        totalFileSize: number;
+    };
+    private allocateId;
+    private validateId;
+    private checkIdAvailable;
+}
+
 /**
  * Engine execution context type
  */
@@ -2533,6 +2997,7 @@ declare class Core {
     private spriteRegistry;
     private webFontRegistry;
     private bitmapFontRegistry;
+    private soundRegistry;
     private activeWebFontId;
     private _renderCallCount;
     private onPaletteChangedCallback?;
@@ -3516,6 +3981,141 @@ declare class Core {
      * @internal
      */
     getSpriteRegistry(): SpriteRegistry;
+    /**
+     * Gets the sound registry
+     *
+     * Use this to access the full SoundRegistry API for advanced operations.
+     *
+     * @returns The SoundRegistry instance
+     *
+     * @example
+     * ```typescript
+     * const registry = core.getSoundRegistry();
+     * console.log(`${registry.size} sounds registered`);
+     * ```
+     */
+    getSoundRegistry(): SoundRegistry;
+    /**
+     * Loads and registers a sound from a file path
+     *
+     * Works in both Node.js and browser environments:
+     * - Node.js: loads synchronously with fs.readFileSync
+     * - Browser: loads asynchronously with fetch
+     *
+     * Format is auto-detected from file extension.
+     *
+     * @param name - Human-readable name (e.g., 'coin', 'explosion')
+     * @param path - Path to the audio file (relative or absolute)
+     * @returns Promise resolving to the assigned sound ID (0-255)
+     *
+     * @example
+     * ```typescript
+     * // In init() - same code works on server and client
+     * async init(core: Core): Promise<void> {
+     *   await core.loadSound('coin', './sounds/coin.mp3');
+     *   await core.loadSound('jump', './sounds/jump.wav');
+     * }
+     * ```
+     */
+    loadSound(name: string, path: string): Promise<number>;
+    /**
+     * Loads multiple sounds at once
+     *
+     * @param sounds - Object mapping sound names to file paths
+     * @returns Promise resolving to object mapping names to IDs
+     *
+     * @example
+     * ```typescript
+     * async init(core: Core): Promise<void> {
+     *   await core.loadSounds({
+     *     coin: './sounds/coin.mp3',
+     *     jump: './sounds/jump.wav',
+     *     hit: './sounds/hit.ogg',
+     *   });
+     * }
+     * ```
+     */
+    loadSounds(sounds: Record<string, string>): Promise<Record<string, number>>;
+    /**
+     * Detects audio format from file extension
+     */
+    private detectSoundFormat;
+    /**
+     * Loads sound data from path (isomorphic: Node.js or browser)
+     */
+    private loadSoundData;
+    /**
+     * Registers a sound with embedded data (File mode) - Low-level API
+     *
+     * The audio data will be sent to clients via UTSP protocol.
+     * Use this for small sounds that should be guaranteed to arrive.
+     *
+     * @param name - Human-readable name (e.g., 'coin', 'explosion')
+     * @param format - Audio format ('mp3', 'wav', 'ogg', etc.)
+     * @param data - Raw audio file data as Uint8Array or Buffer
+     * @returns The assigned sound ID (0-255)
+     *
+     * @example
+     * ```typescript
+     * // If you already have the data
+     * core.registerSound('coin', 'mp3', myAudioData);
+     * ```
+     */
+    registerSound(name: string, format: SoundFormat, data: Uint8Array): number;
+    /**
+     * Registers an external sound (FileExternal mode)
+     *
+     * Only the URL is sent to clients, who download from the external source.
+     * Use this for large sounds (music) to reduce UTSP bandwidth.
+     *
+     * @param name - Human-readable name (e.g., 'background-music')
+     * @param format - Audio format ('mp3', 'wav', 'ogg', etc.)
+     * @param url - URL where clients can download the audio
+     * @param size - Optional file size in bytes (for progress tracking)
+     * @returns The assigned sound ID (0-255)
+     *
+     * @example
+     * ```typescript
+     * const soundId = core.registerExternalSound(
+     *   'background-music',
+     *   'mp3',
+     *   'https://cdn.example.com/music/theme.mp3',
+     *   1_500_000  // 1.5 MB
+     * );
+     * ```
+     */
+    registerExternalSound(name: string, format: SoundFormat, url: string, size?: number): number;
+    /**
+     * Checks if a sound is registered
+     *
+     * @param nameOrId - Sound name (string) or ID (number)
+     * @returns true if sound exists
+     *
+     * @example
+     * ```typescript
+     * if (core.hasSound('coin')) {
+     *   console.log('Coin sound is ready');
+     * }
+     * ```
+     */
+    hasSound(nameOrId: string | number): boolean;
+    /**
+     * Generates LoadPackets for all registered sounds
+     *
+     * Returns separate packets for File and External sounds.
+     * Send these to clients during initial connection.
+     *
+     * @returns Array of sound load packets
+     *
+     * @example
+     * ```typescript
+     * const soundPackets = core.generateSoundLoadPackets();
+     * soundPackets.forEach(packet => {
+     *   socket.emit('sound-load', packet);
+     * });
+     * ```
+     */
+    generateSoundLoadPackets(): Array<_utsp_types.SoundLoadPacket | _utsp_types.SoundExternalLoadPacket>;
     /**
      * Loads the default web font (Courier New, 16px, monospace)
      *
@@ -4829,5 +5429,5 @@ declare class UpdatePacketDecoder {
     private checkSize;
 }
 
-export { ASCII_8X8_FONT, BITMASK16_ORDER_MIN_SIZE, BITMASK4_ORDER_MIN_SIZE, BITMASK_ORDER_MIN_SIZE, BitmapFont, BitmapFontRegistry, CHAR_ORDER_SIZE, CIRCLE_SHAPE_SIZE, CLEAR_ORDER_SIZE, COLORMAP_ORDER_MIN_SIZE, COLOR_SKIP, CellBuffer, CharCodeBuffer, Core, CoreStats, DISPLAY_HEADER_SIZE, DOTCLOUD_MULTICOLOR_ORDER_MIN_SIZE, DOTCLOUD_ORDER_MIN_SIZE, Display, ELLIPSE_SHAPE_SIZE, FILLCHAR_ORDER_MIN_SIZE, FILLSPRITE_MULTICOLOR_ORDER_SIZE, FILLSPRITE_ORDER_SIZE, FULLFRAME_MULTICOLOR_ORDER_MIN_SIZE, FULLFRAME_ORDER_MIN_SIZE, FontType, InputBindingRegistry, LAYER_CELL_COUNT, LAYER_HEADER_SIZE, LAYER_SIZE, LINE_SHAPE_SIZE, Layer, LoadType, OrderBuilder, OrderType, RECTANGLE_SHAPE_SIZE, SHAPE_ORDER_MIN_SIZE, SPRITECLOUD_MULTICOLOR_ORDER_MIN_SIZE, SPRITECLOUD_ORDER_MIN_SIZE, SPRITECLOUD_VARIED_MULTICOLOR_ORDER_MIN_SIZE, SPRITECLOUD_VARIED_ORDER_MIN_SIZE, SPRITE_MULTICOLOR_ORDER_SIZE, SPRITE_ORDER_SIZE, SUBFRAME_MULTICOLOR_ORDER_MIN_SIZE, SUBFRAME_ORDER_MIN_SIZE, ShapeType, SpriteRegistry, TEXT_MULTILINE_ORDER_MIN_SIZE, TEXT_ORDER_MIN_SIZE, TRIANGLE_SHAPE_SIZE, TRIGGERGLOBALSOUND_ORDER_SIZE, TRIGGERSOUND_ORDER_SIZE, UPDATE_PACKET_HEADER_SIZE, UpdateFlags, UpdateFlagsHelper, UpdatePacketDecoder, User, UserStats, WebFont, WebFontRegistry, createASCII8x8FontLoad, createEmptyCompressedInputPacket, decodeCompressedInput, decodeInt8ToAxis, encodeAxisToInt8, encodeCompressedInput, getASCII8x8FontConfig, getAllCharCodes, getButtonByteCount, getCharBitmap, getCompressedPacketSize, getOrderTypeName, hasChar, isValidOrderType };
-export type { AnyLoad, BitmapFontConfig, BitmapFontLoad, Bitmask16Order, Bitmask16Variant, Bitmask4Order, Bitmask4Variant, BitmaskOrder, Cell, CircleShape, Color, ColorPaletteLoad, CompressedInputPacket, CoreMode, CoreOptions, EllipseShape, LineShape, MulticolorCell, MulticolorSprite, MulticolorSpriteLoad, NetworkDisplay, NetworkLayer, RectangleShape, ShapeData, SoundLoad, SpriteLoad, TickStats, TriangleShape, UnicolorSprite, UpdatePacket, UserTickStats, WebFontConfig, WebFontLoad };
+export { ASCII_8X8_FONT, BITMASK16_ORDER_MIN_SIZE, BITMASK4_ORDER_MIN_SIZE, BITMASK_ORDER_MIN_SIZE, BitmapFont, BitmapFontRegistry, CHAR_ORDER_SIZE, CIRCLE_SHAPE_SIZE, CLEAR_ORDER_SIZE, COLORMAP_ORDER_MIN_SIZE, COLOR_SKIP, CellBuffer, CharCodeBuffer, Core, CoreStats, DISPLAY_HEADER_SIZE, DOTCLOUD_MULTICOLOR_ORDER_MIN_SIZE, DOTCLOUD_ORDER_MIN_SIZE, Display, ELLIPSE_SHAPE_SIZE, FILLCHAR_ORDER_MIN_SIZE, FILLSPRITE_MULTICOLOR_ORDER_SIZE, FILLSPRITE_ORDER_SIZE, FULLFRAME_MULTICOLOR_ORDER_MIN_SIZE, FULLFRAME_ORDER_MIN_SIZE, FontType, InputBindingRegistry, LAYER_CELL_COUNT, LAYER_HEADER_SIZE, LAYER_SIZE, LINE_SHAPE_SIZE, Layer, LoadType, OrderBuilder, OrderType, RECTANGLE_SHAPE_SIZE, SHAPE_ORDER_MIN_SIZE, SPRITECLOUD_MULTICOLOR_ORDER_MIN_SIZE, SPRITECLOUD_ORDER_MIN_SIZE, SPRITECLOUD_VARIED_MULTICOLOR_ORDER_MIN_SIZE, SPRITECLOUD_VARIED_ORDER_MIN_SIZE, SPRITE_MULTICOLOR_ORDER_SIZE, SPRITE_ORDER_SIZE, SUBFRAME_MULTICOLOR_ORDER_MIN_SIZE, SUBFRAME_ORDER_MIN_SIZE, ShapeType, SoundRegistry, SpriteRegistry, TEXT_MULTILINE_ORDER_MIN_SIZE, TEXT_ORDER_MIN_SIZE, TRIANGLE_SHAPE_SIZE, TRIGGERGLOBALSOUND_ORDER_SIZE, TRIGGERSOUND_ORDER_SIZE, UPDATE_PACKET_HEADER_SIZE, UpdateFlags, UpdateFlagsHelper, UpdatePacketDecoder, User, UserStats, WebFont, WebFontRegistry, createASCII8x8FontLoad, createEmptyCompressedInputPacket, decodeCompressedInput, decodeInt8ToAxis, encodeAxisToInt8, encodeCompressedInput, getASCII8x8FontConfig, getAllCharCodes, getButtonByteCount, getCharBitmap, getCompressedPacketSize, getOrderTypeName, hasChar, isValidOrderType };
+export type { AnyLoad, BitmapFontConfig, BitmapFontLoad, Bitmask16Order, Bitmask16Variant, Bitmask4Order, Bitmask4Variant, BitmaskOrder, Cell, CircleShape, Color, ColorPaletteLoad, CompressedInputPacket, CoreMode, CoreOptions, EllipseShape, LineShape, MulticolorCell, MulticolorSprite, MulticolorSpriteLoad, NetworkDisplay, NetworkLayer, RectangleShape, ShapeData, SoundEntry, SoundLoad, SpriteLoad, TickStats, TriangleShape, UnicolorSprite, UpdatePacket, UserTickStats, WebFontConfig, WebFontLoad };