@newgameplusinc/odyssey-audio-video-sdk-dev 1.0.258 → 1.0.260

package/dist/channels/spatial/SpatialAudioTypes.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * Spatial Audio Types
+ *
+ * Type definitions for spatial audio processing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DENOISER_OPTIONS = exports.DEFAULT_SPATIAL_CONFIG = void 0;
+/**
+ * Default spatial distance configuration
+ */
+exports.DEFAULT_SPATIAL_CONFIG = {
+    refDistance: 1.2,
+    maxDistance: 15,
+    rolloffFactor: 1.35,
+    unit: 'auto',
+};
+/**
+ * Default denoiser configuration
+ */
+exports.DEFAULT_DENOISER_OPTIONS = {
+    enabled: false,
+    threshold: 0.002,
+    noiseFloor: 0.0005,
+    release: 0.4,
+    attack: 0.1,
+    holdMs: 200,
+    maxReduction: 0.15,
+    hissCut: 0.15,
+    expansionRatio: 1.05,
+    learnRate: 0.03,
+    voiceBoost: 0.35,
+    voiceSensitivity: 0.1,
+    voiceEnhancement: false,
+    silenceFloor: 0.0002,
+    silenceHoldMs: 400,
+    silenceReleaseMs: 200,
+    speechBoost: 0.25,
+    highBandGate: 0.15,
+    highBandAttack: 0.08,
+    highBandRelease: 0.03,
+};

package/dist/channels/spatial/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Spatial module - Re-exports spatial audio channel functionality
+ */
+export * from './SpatialAudioTypes';
+export * from './SpatialAudioChannel';

package/dist/channels/spatial/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Spatial module - Re-exports spatial audio channel functionality
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./SpatialAudioTypes"), exports);
+__exportStar(require("./SpatialAudioChannel"), exports);

package/dist/{EventManager.d.ts → core/EventManager.d.ts}

@@ -1,10 +1,12 @@
-import { EventEmitter } from "events";
-import { OdysseyEvent } from "./types";
 /**
+ * Event Manager
+ *
  * A clean, standalone event bus for the SDK, completely decoupled from the socket.
  * This ensures that only processed, structured SDK events are emitted to the application.
  * It extends the Node.js EventEmitter to provide a standard and reliable event API.
  */
+import { EventEmitter } from 'events';
+import { OdysseyEvent } from '../types/events';
 export declare class EventManager extends EventEmitter {
     constructor();
     on(event: OdysseyEvent, listener: (...args: any[]) => void): this;

package/dist/{EventManager.js → core/EventManager.js}

@@ -1,12 +1,14 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventManager = void 0;
-const events_1 = require("events");
 /**
+ * Event Manager
+ *
  * A clean, standalone event bus for the SDK, completely decoupled from the socket.
  * This ensures that only processed, structured SDK events are emitted to the application.
  * It extends the Node.js EventEmitter to provide a standard and reliable event API.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventManager = void 0;
+const events_1 = require("events");
 class EventManager extends events_1.EventEmitter {
     constructor() {
         super();

package/dist/{MediasoupManager.d.ts → core/MediasoupManager.d.ts}

@@ -1,6 +1,12 @@
-import * as mediasoupClient from "mediasoup-client";
-import { types } from "mediasoup-client";
-import { Socket } from "socket.io-client";
+/**
+ * Mediasoup Manager
+ *
+ * Handles WebRTC transport, producer, and consumer management
+ * using the mediasoup-client library
+ */
+import * as mediasoupClient from 'mediasoup-client';
+import { types } from 'mediasoup-client';
+import { Socket } from 'socket.io-client';
 export declare class MediasoupManager {
     private device;
     private socket;
@@ -20,7 +26,7 @@ export declare class MediasoupManager {
     consume(data: {
         consumerId: string;
         producerId: string;
-        kind: "audio" | "video";
+        kind: 'audio' | 'video';
         rtpParameters: any;
         participantId: string;
     }): Promise<{

package/dist/{MediasoupManager.js → core/MediasoupManager.js}

@@ -1,4 +1,10 @@
 "use strict";
+/**
+ * Mediasoup Manager
+ *
+ * Handles WebRTC transport, producer, and consumer management
+ * using the mediasoup-client library
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -53,32 +59,32 @@ class MediasoupManager {
     }
     sendDeviceRtpCapabilities(participantId) {
         this.participantId = participantId;
-        this.socket.emit("device-rtp-capabilities", {
+        this.socket.emit('device-rtp-capabilities', {
             participantId,
             rtpCapabilities: this.device.rtpCapabilities,
         });
     }
     async createSendTransport(participantId) {
-        const params = await this.createWebRtcTransport("send", participantId);
+        const params = await this.createWebRtcTransport('send', participantId);
         this.sendTransport = this.device.createSendTransport(params);
         this.connectSendTransport();
     }
     async createRecvTransport(participantId) {
-        const params = await this.createWebRtcTransport("recv", participantId);
+        const params = await this.createWebRtcTransport('recv', participantId);
         this.recvTransport = this.device.createRecvTransport(params);
         this.connectRecvTransport();
     }
     connectSendTransport() {
-        this.sendTransport?.on("connect", async ({ dtlsParameters }, callback, errback) => {
-            this.socket.emit("connect-transport", { transportId: this.sendTransport.id, dtlsParameters }, (response) => {
+        this.sendTransport?.on('connect', async ({ dtlsParameters }, callback, errback) => {
+            this.socket.emit('connect-transport', { transportId: this.sendTransport.id, dtlsParameters }, (response) => {
                 if (response.error)
                     errback(new Error(response.error));
                 else
                     callback();
             });
         });
-        this.sendTransport?.on("produce", async ({ kind, rtpParameters, appData, }, callback, errback) => {
-            this.socket.emit("produce", {
+        this.sendTransport?.on('produce', async ({ kind, rtpParameters, appData, }, callback, errback) => {
+            this.socket.emit('produce', {
                 transportId: this.sendTransport.id,
                 kind,
                 rtpParameters,
@@ -90,59 +96,56 @@ class MediasoupManager {
                     callback({ id: response.producerId });
             });
         });
-        // Handle transport connection state changes
-        this.sendTransport?.on("connectionstatechange", (state) => {
-            if (state === "failed" || state === "closed") {
-                // Clear all producers since transport is dead
+        this.sendTransport?.on('connectionstatechange', (state) => {
+            if (state === 'failed' || state === 'closed') {
                 this.producers.clear();
-                // Emit event so parent SDK can recreate producers
-                this.socket.emit("transport-failed", {
+                this.socket.emit('transport-failed', {
                     participantId: this.participantId,
-                    direction: "send"
+                    direction: 'send',
                 });
             }
         });
     }
     connectRecvTransport() {
-        this.recvTransport?.on("connect", async ({ dtlsParameters }, callback, errback) => {
-            this.socket.emit("connect-transport", { transportId: this.recvTransport.id, dtlsParameters }, (response) => {
-                if (response.error)
+        this.recvTransport?.on('connect', async ({ dtlsParameters }, callback, errback) => {
+            console.log(`🎧 [MediasoupManager] Recv transport connecting, DTLS params:`, {
+                transportId: this.recvTransport.id.substring(0, 8),
+            });
+            this.socket.emit('connect-transport', { transportId: this.recvTransport.id, dtlsParameters }, (response) => {
+                if (response.error) {
+                    console.error(`🎧 [MediasoupManager] ❌ Recv transport connect failed:`, response.error);
                     errback(new Error(response.error));
-                else
+                }
+                else {
+                    console.log(`🎧 [MediasoupManager] ✅ Recv transport connected`);
                     callback();
+                }
             });
         });
-        // Handle transport connection state changes
-        this.recvTransport?.on("connectionstatechange", (state) => {
-            if (state === "failed" || state === "closed") {
-                // Consumers will be closed by server, SDK will handle via consumer.on('transportclose')
+        this.recvTransport?.on('connectionstatechange', (state) => {
+            console.log(`🎧 [MediasoupManager] Recv transport connection state changed: ${state}`);
+            if (state === 'failed' || state === 'closed') {
+                console.error(`🎧 [MediasoupManager] ❌ Recv transport ${state}`);
             }
         });
     }
     async produce(track, appData) {
         if (!this.sendTransport)
-            throw new Error("Send transport not initialized");
-        // Configure simulcast for video tracks for adaptive bitrate
+            throw new Error('Send transport not initialized');
         const produceOptions = { track, appData };
         if (track.kind === 'video') {
             produceOptions.encodings = [
-                // Low quality layer - 100 kbps, good for poor connections
                 { rid: 'r0', active: true, maxBitrate: 100000, scaleResolutionDownBy: 4 },
-                // Medium quality layer - 300 kbps, balanced
                 { rid: 'r1', active: true, maxBitrate: 300000, scaleResolutionDownBy: 2 },
-                // High quality layer - 900 kbps, full resolution
-                { rid: 'r2', active: true, maxBitrate: 900000, scaleResolutionDownBy: 1 }
+                { rid: 'r2', active: true, maxBitrate: 900000, scaleResolutionDownBy: 1 },
             ];
-            // VP8 codec for simulcast support
             produceOptions.codecOptions = {
-                videoGoogleStartBitrate: 1000
+                videoGoogleStartBitrate: 1000,
             };
         }
         const producer = await this.sendTransport.produce(produceOptions);
-        // Handle producer events
         producer.on('transportclose', () => {
             this.producers.delete(producer.id);
-            // The main SDK (index.ts) should handle recreation
         });
         producer.on('trackended', () => {
             producer.close();
@@ -153,17 +156,30 @@ class MediasoupManager {
     }
     async consume(data) {
         if (!this.recvTransport)
-            throw new Error("Receive transport not set up");
+            throw new Error('Receive transport not set up');
+        console.log(`🎧 [MediasoupManager] Creating consumer for ${data.participantId.substring(0, 8)}`, {
+            consumerId: data.consumerId.substring(0, 8),
+            producerId: data.producerId.substring(0, 8),
+            kind: data.kind,
+            recvTransportId: this.recvTransport.id.substring(0, 8),
+            recvTransportConnectionState: this.recvTransport.connectionState,
+        });
         const consumer = await this.recvTransport.consume({
             id: data.consumerId,
             producerId: data.producerId,
             kind: data.kind,
             rtpParameters: data.rtpParameters,
         });
-        // Handle consumer events
+        console.log(`🎧 [MediasoupManager] Consumer created for ${data.participantId.substring(0, 8)}`, {
+            consumerId: consumer.id.substring(0, 8),
+            trackKind: consumer.track.kind,
+            trackEnabled: consumer.track.enabled,
+            trackMuted: consumer.track.muted,
+            trackReadyState: consumer.track.readyState,
+            consumerPaused: consumer.paused,
+        });
         consumer.on('transportclose', () => {
             this.consumers.delete(consumer.id);
-            // The main SDK (index.ts) should handle recreation
         });
         consumer.on('trackended', () => {
             consumer.close();
@@ -174,7 +190,7 @@ class MediasoupManager {
     }
     async resumeConsumer(consumerId) {
         return new Promise((resolve, reject) => {
-            this.socket.emit("resume-consumer", { consumerId, participantId: this.participantId }, (response) => {
+            this.socket.emit('resume-consumer', { consumerId, participantId: this.participantId }, (response) => {
                 if (response.error) {
                     reject(new Error(response.error));
                 }
@@ -186,23 +202,19 @@ class MediasoupManager {
     }
     async createWebRtcTransport(direction, participantId) {
         return new Promise((resolve, reject) => {
-            // Set up listener for transport-created event
             const handleTransportCreated = (data) => {
                 if (data.type === direction) {
-                    // Remove listener to prevent memory leaks
-                    this.socket.off("transport-created", handleTransportCreated);
+                    this.socket.off('transport-created', handleTransportCreated);
                     if (data.error) {
                         return reject(new Error(data.error));
                     }
                     resolve(data.params);
                 }
             };
-            this.socket.on("transport-created", handleTransportCreated);
-            // Emit the request
-            this.socket.emit("create-transport", { direction, participantId });
-            // Add timeout to prevent hanging forever
+            this.socket.on('transport-created', handleTransportCreated);
+            this.socket.emit('create-transport', { direction, participantId });
             setTimeout(() => {
-                this.socket.off("transport-created", handleTransportCreated);
+                this.socket.off('transport-created', handleTransportCreated);
                 reject(new Error(`Timeout waiting for ${direction} transport`));
             }, 10000);
         });

package/dist/core/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Core module - Re-exports core SDK components
+ */
+export * from './EventManager';
+export * from './MediasoupManager';

package/dist/core/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Core module - Re-exports core SDK components
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./EventManager"), exports);
+__exportStar(require("./MediasoupManager"), exports);

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { EventManager } from "./EventManager";
-import { SpatialAudioOptions } from "./SpatialAudioManager";
+import { EventManager } from "./core/EventManager";
+import { SpatialAudioOptions } from "./channels/spatial/SpatialAudioChannel";
 import { Direction, MediaState, OdysseyEvent, Participant, Position, RoomJoinedData } from "./types";
 export declare class OdysseySpatialComms extends EventManager {
     private socket;

package/dist/index.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OdysseySpatialComms = void 0;
 const socket_io_client_1 = require("socket.io-client");
-const EventManager_1 = require("./EventManager");
-const MediasoupManager_1 = require("./MediasoupManager");
-const SpatialAudioManager_1 = require("./SpatialAudioManager");
+const EventManager_1 = require("./core/EventManager");
+const MediasoupManager_1 = require("./core/MediasoupManager");
+const SpatialAudioChannel_1 = require("./channels/spatial/SpatialAudioChannel");
 class OdysseySpatialComms extends EventManager_1.EventManager {
     constructor(serverUrl, spatialOptions) {
         super(); // Initialize the EventEmitter base class
@@ -14,7 +14,7 @@ class OdysseySpatialComms extends EventManager_1.EventManager {
             transports: ["websocket"],
         });
         this.mediasoupManager = new MediasoupManager_1.MediasoupManager(this.socket);
-        this.spatialAudioManager = new SpatialAudioManager_1.SpatialAudioManager(spatialOptions);
+        this.spatialAudioManager = new SpatialAudioChannel_1.SpatialAudioManager(spatialOptions);
         // Set max listeners to prevent warning
         this.setMaxListeners(50);
         this.listenForEvents();
@@ -211,6 +211,15 @@ class OdysseySpatialComms extends EventManager_1.EventManager {
                 pan: spatialData?.pan,
                 dxLocal: spatialData?.dxLocal,
             };
+            // ========== DEBUG: SDK SENDING TO SERVER ==========
+            console.log("📤 [SDK->Server] updatePosition:", {
+                participantId: updateData.participantId,
+                position: updateData.position,
+                direction: updateData.direction,
+                rot: updateData.rot,
+                pan: updateData.pan,
+                dxLocal: updateData.dxLocal,
+            });
             this.socket.emit("update-position", updateData);
         }
     }
@@ -229,6 +238,13 @@ class OdysseySpatialComms extends EventManager_1.EventManager {
         this.spatialAudioManager.setListenerPosition(position, orientation);
     }
     setListenerFromLSD(listenerPos, cameraPos, lookAtPos, rot) {
+        // ========== DEBUG: LISTENER POSITION UPDATE ==========
+        console.log("🎧 [SDK] setListenerFromLSD:", {
+            listenerPos,
+            cameraPos,
+            lookAtPos,
+            rot,
+        });
         this.spatialAudioManager.setListenerFromLSD(listenerPos, cameraPos, lookAtPos, rot);
     }
     listenForEvents() {
@@ -383,11 +399,19 @@ class OdysseySpatialComms extends EventManager_1.EventManager {
                 participant.consumers.set(consumer.id, consumer);
                 if (track.kind === "audio") {
                     participant.audioTrack = track;
+                    console.log(`🎧 [SDK] Received audio consumer for ${participant.participantId.substring(0, 8)}`, {
+                        consumerId: consumer.id.substring(0, 8),
+                        trackEnabled: track.enabled,
+                        trackMuted: track.muted,
+                        trackReadyState: track.readyState,
+                        consumerPaused: consumer.paused,
+                    });
                     // CRITICAL: Do NOT setup spatial audio for local participant (yourself)
                     // This prevents hearing your own microphone (loopback)
                     const isLocalParticipant = participant.participantId ===
                         this.localParticipant?.participantId;
                     if (isLocalParticipant) {
+                        console.log(`🎧 [SDK] Skipping audio setup for local participant (prevent loopback)`);
                         // Do NOT connect this audio to Web Audio API
                         return; // Exit early to prevent any audio processing
                     }
@@ -395,18 +419,20 @@ class OdysseySpatialComms extends EventManager_1.EventManager {
                         // Check if participant is in a huddle (non-spatial channel)
                         const participantChannel = participant.currentChannel || "spatial";
                         const isInHuddle = participantChannel !== "spatial";
+                        console.log(`🎧 [SDK] Setting up spatial audio for ${participant.participantId.substring(0, 8)}, huddle: ${isInHuddle}`);
                         // Setup spatial audio - bypass 3D positioning for huddle members
                         await this.spatialAudioManager.setupSpatialAudioForParticipant(participant.participantId, track, isInHuddle // Bypass spatialization if in huddle
                         );
                     }
                     // NOW resume the consumer after audio pipeline is ready
+                    console.log(`🎧 [SDK] Resuming consumer ${consumer.id.substring(0, 8)}...`);
                     this.mediasoupManager
                         .resumeConsumer(consumer.id)
                         .then(() => {
-                        // Consumer resumed successfully
+                        console.log(`🎧 [SDK] ✅ Consumer ${consumer.id.substring(0, 8)} resumed successfully`);
                     })
-                        .catch(() => {
-                        // Failed to resume consumer - will be handled by transport recovery
+                        .catch((err) => {
+                        console.error(`🎧 [SDK] ❌ Failed to resume consumer ${consumer.id.substring(0, 8)}:`, err);
                     });
                 }
                 else if (track.kind === "video") {
@@ -436,8 +462,16 @@ class OdysseySpatialComms extends EventManager_1.EventManager {
             }
         });
         this.socket.on("participant-position-updated", (data) => {
-            // DEBUG: Log position update received from socket
-            console.log(`[SDK-SOCKET] id=${data.participantId.substring(0, 8)} pos=(${data.position.x.toFixed(1)},${data.position.y.toFixed(1)},${data.position.z.toFixed(1)}) rot=(${data.rot?.x?.toFixed(1)},${data.rot?.y?.toFixed(1)},${data.rot?.z?.toFixed(1)})`);
+            // ========== DEBUG: SDK RECEIVED FROM SERVER ==========
+            console.log("📥 [SDK<-Server] participant-position-updated:", {
+                participantId: data.participantId,
+                position: data.position,
+                direction: data.direction,
+                rot: data.rot,
+                pan: data.pan,
+                dxLocal: data.dxLocal,
+                currentChannel: data.currentChannel,
+            });
             const participant = this.room?.participants.get(data.participantId);
             if (participant) {
                 participant.position = data.position;

package/dist/sdk/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Odyssey Mediasoup SDK - Main Entry Point
+ *
+ * A comprehensive WebRTC SDK for real-time audio/video communication
+ * with spatial audio and ML-powered noise suppression.
+ *
+ * @module @odyssey/mediasoup-sdk
+ */
+export type { Position, Direction, Rotation, ListenerRight, UnrealPosition, StandardPosition, } from '../types/position';
+export type { Participant, MediaState, ParticipantSnapshot, } from '../types/participant';
+export type { RoomJoinedEvent, ConsumerCreatedEvent, ConsumerClosedEvent, ConsumerPausedEvent, ConsumerResumedEvent, ParticipantJoinedEvent, ParticipantLeftEvent, ParticipantPositionEvent, MuteStateChangedEvent, HuddleInviteReceivedEvent, HuddleResponseEvent, OdysseyEvent, OdysseyEventMap, } from '../types/events';
+export type { Room, RoomJoinedData, JoinRoomData, ConsumerCreatedData, TransportOptions, ProducerOptions, } from '../types/room';
+export { getDistanceBetween, getHorizontalDistance, isWithinRange, } from '../utils/spatial/distance-calc';
+export { calculateLogarithmicGain, DEFAULT_GAIN_CONFIG, type GainConfig, } from '../utils/spatial/gain-calc';
+export { calculateListenerRight, calculatePanFromPositions, panValueToPanning, type Panning, } from '../utils/spatial/pan-calc';
+export { computeHeadPosition, parseBodyHeight, getVectorFromListener, } from '../utils/spatial/head-position';
+export { getListenerRightFromRotation, calculateListenerOrientation, type ListenerOrientation, } from '../utils/spatial/listener-calc';
+export { computeAzimuthFromPositions, calculateAngleToSource, } from '../utils/spatial/angle-calc';
+export { normalizePositionUnits, metersToCentimeters, centimetersToMeters, isLikelyCentimeters, } from '../utils/position/normalize';
+export { PositionSnapCache, snapPositionSimple, SNAP_CONFIG, type SnapConfig, } from '../utils/position/snap';
+export { unrealToStandard, standardToUnreal, autoConvertToStandard, } from '../utils/position/coordinates';
+export { PanSmoother, DEFAULT_PAN_SMOOTHER_OPTIONS, type PanSmootherOptions, } from '../utils/smoothing/pan-smoothing';
+export { applyGainSmooth, applyStereoPanSmooth, GainTracker, } from '../utils/smoothing/gain-smoothing';
+export { calculateClarityScore, calculateProximityWeight, normalizeVector, } from '../utils/audio/clarity-score';
+export { calculateAdaptiveHighpass, createVoiceFilterChain, } from '../utils/audio/voice-filter';
+export { HuddleChannel, type HuddleChannelConfig, } from '../channels/huddle/HuddleChannel';
+export { SPATIAL_CHANNEL_ID, isHuddleChannel, type HuddleInvite, type HuddleResponse, type HuddleAcceptResponse, type HuddleRejectResponse, } from '../channels/huddle/HuddleTypes';
+export { SpatialAudioChannel, type SpatialAudioConfig, } from '../channels/spatial/SpatialAudioChannel';
+export { DEFAULT_SPATIAL_CONFIG, DEFAULT_DENOISER_OPTIONS, type SpatialDistanceConfig, type DenoiserOptions, type ParticipantAudioNodes, type ListenerState, } from '../channels/spatial/SpatialAudioTypes';
+export { createMasterChain, createFilterChain, connectFilterChain, createLimiter, createMonoDownmixChain, connectMonoDownmixChain, DEFAULT_PIPELINE_CONFIG, type AudioPipelineConfig, type MasterAudioChain, type ParticipantFilterChain, type MonoDownmixChain, } from '../audio/AudioPipeline';
+export { createPanner, createStereoPanner, createGain, createAnalyser, createHighpassFilter, createLowpassFilter, createPeakingFilter, createCompressor, createMediaStreamSource, DEFAULT_PANNER_CONFIG, type PannerConfig, type HighpassConfig, type LowpassConfig, type PeakingConfig, type CompressorConfig, } from '../audio/AudioNodeFactory';
+export { MLNoiseSuppressor } from '../audio/MLNoiseSuppressor';
+export { EventManager } from '../core/EventManager';
+export { MediasoupManager } from '../core/MediasoupManager';
+export declare const SDK_VERSION = "2.0.0";
+export declare const SDK_NAME = "Odyssey Mediasoup SDK";