@dtelecom/server-sdk-node 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,871 @@
+import { MediaStreamTrack, RTCRtpTransceiver, RTCPeerConnection, RTCDataChannel } from 'werift';
+import * as _m0 from 'protobufjs/minimal';
+
+declare class TypedEmitter<T extends {
+    [key: string]: (...args: any[]) => void;
+}> {
+    private emitter;
+    constructor();
+    on<K extends keyof T & string>(event: K, listener: T[K]): this;
+    once<K extends keyof T & string>(event: K, listener: T[K]): this;
+    off<K extends keyof T & string>(event: K, listener: T[K]): this;
+    emit<K extends keyof T & string>(event: K, ...args: Parameters<T[K]>): boolean;
+    removeAllListeners<K extends keyof T & string>(event?: K): this;
+    listenerCount<K extends keyof T & string>(event: K): number;
+}
+
+/**
+ * Core protocol model types for dTelecom.
+ * Manually defined to match github.com/dtelecom/protocol (dtelecom-db branch).
+ * These mirror the types in livekit_models.proto.
+ */
+
+declare enum TrackType {
+    AUDIO = 0,
+    VIDEO = 1,
+    DATA = 2
+}
+declare enum TrackSource {
+    UNKNOWN = 0,
+    CAMERA = 1,
+    MICROPHONE = 2,
+    SCREEN_SHARE = 3,
+    SCREEN_SHARE_AUDIO = 4
+}
+declare enum VideoQuality {
+    LOW = 0,
+    MEDIUM = 1,
+    HIGH = 2,
+    OFF = 3
+}
+declare enum ParticipantInfo_State {
+    JOINING = 0,
+    JOINED = 1,
+    ACTIVE = 2,
+    DISCONNECTED = 3
+}
+declare enum DataPacket_Kind {
+    RELIABLE = 0,
+    LOSSY = 1
+}
+declare enum ConnectionQuality {
+    POOR = 0,
+    GOOD = 1,
+    EXCELLENT = 2
+}
+declare enum DisconnectReason {
+    UNKNOWN_REASON = 0,
+    CLIENT_INITIATED = 1,
+    DUPLICATE_IDENTITY = 2,
+    SERVER_SHUTDOWN = 3,
+    PARTICIPANT_REMOVED = 4,
+    ROOM_DELETED = 5,
+    STATE_MISMATCH = 6,
+    JOIN_FAILURE = 7
+}
+interface Room$1 {
+    sid: string;
+    name: string;
+    emptyTimeout: number;
+    maxParticipants: number;
+    creationTime: number;
+    turnPassword: string;
+    enabledCodecs: Codec[];
+    metadata: string;
+    numParticipants: number;
+    activeRecording: boolean;
+}
+interface Codec {
+    mime: string;
+    fmtpLine: string;
+}
+interface ParticipantPermission {
+    canSubscribe: boolean;
+    canPublish: boolean;
+    canPublishData: boolean;
+    hidden: boolean;
+    recorder: boolean;
+}
+interface ParticipantInfo {
+    sid: string;
+    identity: string;
+    state: ParticipantInfo_State;
+    tracks: TrackInfo[];
+    metadata: string;
+    joinedAt: number;
+    name: string;
+    version: number;
+    permission?: ParticipantPermission;
+    region: string;
+    isPublisher: boolean;
+}
+interface TrackInfo {
+    sid: string;
+    type: TrackType;
+    name: string;
+    muted: boolean;
+    width: number;
+    height: number;
+    simulcast: boolean;
+    disableDtx: boolean;
+    source: TrackSource;
+    layers: VideoLayer[];
+    mimeType: string;
+    mid: string;
+}
+interface VideoLayer {
+    quality: VideoQuality;
+    width: number;
+    height: number;
+    bitrate: number;
+    ssrc: number;
+}
+interface ICEServer {
+    urls: string[];
+    username: string;
+    credential: string;
+}
+interface DataPacket {
+    kind: DataPacket_Kind;
+    user?: UserPacket;
+    speaker?: ActiveSpeakerUpdate;
+}
+declare const DataPacket: {
+    encode(message: DataPacket, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): DataPacket;
+};
+interface UserPacket {
+    participantSid: string;
+    payload: Uint8Array;
+    destinationSids: string[];
+    topic?: string;
+}
+declare const UserPacket: {
+    encode(message: UserPacket, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): UserPacket;
+};
+interface ActiveSpeakerUpdate {
+    speakers: SpeakerInfo[];
+}
+declare const ActiveSpeakerUpdate: {
+    encode(message: ActiveSpeakerUpdate, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ActiveSpeakerUpdate;
+};
+interface SpeakerInfo {
+    sid: string;
+    level: number;
+    active: boolean;
+}
+declare const SpeakerInfo: {
+    encode(message: SpeakerInfo, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SpeakerInfo;
+};
+
+/**
+ * Signaling protocol types for dTelecom RTC.
+ * Matches livekit_rtc.proto from github.com/dtelecom/protocol.
+ *
+ * These types define the WebSocket signaling messages between
+ * client and SFU (Selective Forwarding Unit).
+ */
+
+declare enum SignalTarget {
+    PUBLISHER = 0,
+    SUBSCRIBER = 1
+}
+declare enum StreamState {
+    ACTIVE = 0,
+    PAUSED = 1
+}
+interface SimulcastCodec {
+    codec: string;
+    cid: string;
+    enableSimulcastLayers: boolean;
+}
+interface ParticipantTrackInfo {
+    participantSid: string;
+    trackSids: string[];
+}
+interface ClientConfiguration {
+    video?: VideoConfiguration;
+    screen?: VideoConfiguration;
+    resumeConnection: number;
+    disabledCodecs?: DisabledCodecs;
+    forceRelay: number;
+}
+interface VideoConfiguration {
+    hardwareEncoder: number;
+}
+interface DisabledCodecs {
+    codecs: CodecInfo[];
+}
+interface CodecInfo {
+    mime: string;
+    fmtpLine: string;
+}
+interface ConnectionQualityInfo {
+    participantSid: string;
+    quality: number;
+    score: number;
+}
+interface StreamStateInfo {
+    participantSid: string;
+    trackSid: string;
+    state: StreamState;
+}
+interface SessionDescription {
+    /** SDP offer/answer string */
+    type: string;
+    sdp: string;
+}
+declare const SessionDescription: {
+    encode(message: SessionDescription, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SessionDescription;
+};
+interface TrickleRequest {
+    candidateInit: string;
+    target: SignalTarget;
+}
+declare const TrickleRequest: {
+    encode(message: TrickleRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): TrickleRequest;
+};
+interface AddTrackRequest {
+    cid: string;
+    name: string;
+    type: TrackType;
+    width: number;
+    height: number;
+    muted: boolean;
+    disableDtx: boolean;
+    source: TrackSource;
+    layers: SimulcastCodec[];
+    sid: string;
+}
+declare const AddTrackRequest: {
+    encode(message: AddTrackRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): AddTrackRequest;
+};
+interface LeaveRequest {
+    canReconnect: boolean;
+    reason: DisconnectReason;
+}
+declare const LeaveRequest: {
+    encode(message: LeaveRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): LeaveRequest;
+};
+interface UpdateSubscription {
+    trackSids: string[];
+    subscribe: boolean;
+    participantTracks: ParticipantTrackInfo[];
+}
+declare const UpdateSubscription: {
+    encode(message: UpdateSubscription, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): UpdateSubscription;
+};
+interface JoinResponse {
+    room?: Room$1;
+    participant?: ParticipantInfo;
+    otherParticipants: ParticipantInfo[];
+    serverVersion: string;
+    iceServers: ICEServer[];
+    subscriberPrimary: boolean;
+    alternativeUrl: string;
+    clientConfiguration?: ClientConfiguration;
+    serverRegion: string;
+    pingTimeout: number;
+    pingInterval: number;
+}
+declare const JoinResponse: {
+    decode(input: _m0.Reader | Uint8Array, length?: number): JoinResponse;
+};
+interface TrackPublishedResponse {
+    cid: string;
+    track?: TrackInfo;
+}
+declare const TrackPublishedResponse: {
+    decode(input: _m0.Reader | Uint8Array, length?: number): TrackPublishedResponse;
+};
+interface ParticipantUpdate {
+    participants: ParticipantInfo[];
+}
+declare const ParticipantUpdate: {
+    decode(input: _m0.Reader | Uint8Array, length?: number): ParticipantUpdate;
+};
+interface SpeakersChanged {
+    speakers: SpeakerInfo[];
+}
+declare const SpeakersChanged: {
+    decode(input: _m0.Reader | Uint8Array, length?: number): SpeakersChanged;
+};
+interface RoomUpdate {
+    room?: Room$1;
+}
+declare const RoomUpdate: {
+    decode(input: _m0.Reader | Uint8Array, length?: number): RoomUpdate;
+};
+interface TrackUnpublishedResponse {
+    trackSid: string;
+}
+declare const TrackUnpublishedResponse: {
+    decode(input: _m0.Reader | Uint8Array, length?: number): TrackUnpublishedResponse;
+};
+interface ConnectionQualityUpdate {
+    updates: ConnectionQualityInfo[];
+}
+declare const ConnectionQualityUpdate: {
+    decode(input: _m0.Reader | Uint8Array, length?: number): ConnectionQualityUpdate;
+};
+interface StreamStateUpdate {
+    streamStates: StreamStateInfo[];
+}
+declare const StreamStateUpdate: {
+    decode(input: _m0.Reader | Uint8Array, length?: number): StreamStateUpdate;
+};
+
+/**
+ * SignalClient — WebSocket connection to dTelecom SFU.
+ *
+ * Handles binary protobuf signaling: SignalRequest (client→server)
+ * and SignalResponse (server→client).
+ */
+
+interface SignalOptions {
+    /** Auto-subscribe to all tracks (default: true) */
+    autoSubscribe?: boolean;
+    /** WebSocket connection timeout in ms (default: 10000) */
+    connectTimeout?: number;
+}
+interface SignalEvents {
+    [key: string]: (...args: any[]) => void;
+    join: (response: JoinResponse) => void;
+    offer: (sd: SessionDescription) => void;
+    answer: (sd: SessionDescription) => void;
+    trickle: (request: TrickleRequest) => void;
+    participantUpdate: (update: ParticipantUpdate) => void;
+    trackPublished: (response: TrackPublishedResponse) => void;
+    trackUnpublished: (response: TrackUnpublishedResponse) => void;
+    speakersChanged: (update: SpeakersChanged) => void;
+    roomUpdate: (update: RoomUpdate) => void;
+    connectionQuality: (update: ConnectionQualityUpdate) => void;
+    streamStateUpdate: (update: StreamStateUpdate) => void;
+    leave: (request: LeaveRequest) => void;
+    tokenRefresh: (token: string) => void;
+    close: (reason: string) => void;
+    error: (error: Error) => void;
+}
+declare class SignalClient extends TypedEmitter<SignalEvents> {
+    private ws;
+    private pingInterval;
+    private _isConnected;
+    private joinResponse;
+    get isConnected(): boolean;
+    /**
+     * Connect to the dTelecom SFU signaling server.
+     * Returns JoinResponse on successful connection.
+     */
+    connect(url: string, token: string, options?: SignalOptions): Promise<JoinResponse>;
+    /** Send an SDP offer (publisher → server) */
+    sendOffer(sd: SessionDescription): void;
+    /** Send an SDP answer (subscriber → server) */
+    sendAnswer(sd: SessionDescription): void;
+    /** Send an ICE candidate */
+    sendIceCandidate(candidate: string, target: SignalTarget): void;
+    /** Request to add (publish) a track */
+    sendAddTrack(request: AddTrackRequest): void;
+    /** Mute/unmute a track */
+    sendMuteTrack(trackSid: string, muted: boolean): void;
+    /** Update track subscription */
+    sendSubscription(update: UpdateSubscription): void;
+    /** Send leave request */
+    sendLeave(): void;
+    /** Close the WebSocket connection */
+    close(): void;
+    private buildUrl;
+    private sendRequest;
+    private handleResponse;
+    private startPing;
+    private stopPing;
+}
+
+/**
+ * RTCEngine — manages dual PeerConnections (publisher + subscriber)
+ * for communication with the dTelecom SFU.
+ *
+ * Publisher PC: sends local audio + data channels
+ * Subscriber PC: receives remote audio + data channels
+ */
+
+interface EngineEvents {
+    [key: string]: (...args: any[]) => void;
+    connected: () => void;
+    disconnected: (reason?: string) => void;
+    remoteTrack: (track: MediaStreamTrack, transceiver: RTCRtpTransceiver) => void;
+    dataMessage: (data: Uint8Array, kind: 'reliable' | 'lossy') => void;
+    dataChannelReady: () => void;
+    trackPublished: (response: TrackPublishedResponse) => void;
+    subscriberOffer: (sd: SessionDescription) => void;
+}
+interface EngineOptions {
+    connectTimeout?: number;
+    autoSubscribe?: boolean;
+}
+declare class RTCEngine extends TypedEmitter<EngineEvents> {
+    readonly signal: SignalClient;
+    private publisher;
+    private subscriber;
+    private reliableChannel;
+    private lossyChannel;
+    private subscriberReliableChannel;
+    private subscriberLossyChannel;
+    private subscriberPrimary;
+    private _isConnected;
+    private pendingCandidates;
+    private joinResponse;
+    private publishWaiters;
+    get isConnected(): boolean;
+    get publisherPC(): RTCPeerConnection | null;
+    get subscriberPC(): RTCPeerConnection | null;
+    get reliableDataChannel(): RTCDataChannel | null;
+    get lossyDataChannel(): RTCDataChannel | null;
+    constructor();
+    connect(url: string, token: string, options?: EngineOptions): Promise<JoinResponse>;
+    addTransceiver(track: MediaStreamTrack): Promise<RTCRtpTransceiver>;
+    requestPublishTrack(cid: string, name: string, type: TrackType, source: TrackSource, options?: {
+        disableDtx?: boolean;
+        muted?: boolean;
+    }): Promise<TrackPublishedResponse>;
+    negotiate(): Promise<void>;
+    sendData(data: Uint8Array, kind: 'reliable' | 'lossy'): void;
+    disconnect(): Promise<void>;
+    private buildIceServers;
+    private createPublisher;
+    private createSubscriber;
+    private createDataChannels;
+    private setupSubscriberDataChannel;
+    private setupSignalHandlers;
+    private flushPendingCandidates;
+}
+
+/**
+ * AudioFrame — PCM16 audio container.
+ *
+ * This is the primary audio type exposed to users.
+ * All audio flowing in/out of the SDK uses this format.
+ */
+declare class AudioFrame {
+    /** PCM16 samples (interleaved if stereo) */
+    readonly data: Int16Array;
+    /** Sample rate in Hz (e.g. 16000, 48000) */
+    readonly sampleRate: number;
+    /** Number of channels (1 = mono, 2 = stereo) */
+    readonly channels: number;
+    /** Number of samples per channel */
+    readonly samplesPerChannel: number;
+    constructor(data: Int16Array, sampleRate: number, channels: number, samplesPerChannel: number);
+    /** Create an empty (silent) AudioFrame */
+    static create(sampleRate: number, channels: number, samplesPerChannel: number): AudioFrame;
+    /** Duration of this frame in seconds */
+    get duration(): number;
+    /** Duration of this frame in milliseconds */
+    get durationMs(): number;
+    /** Total number of samples (channels * samplesPerChannel) */
+    get totalSamples(): number;
+    /** Convert to Buffer (for Opus encoder or file I/O) */
+    toBuffer(): Buffer;
+    /** Create AudioFrame from a Buffer of PCM16 data */
+    static fromBuffer(buffer: Buffer, sampleRate: number, channels: number): AudioFrame;
+    /** Clone this AudioFrame */
+    clone(): AudioFrame;
+}
+
+/**
+ * AudioSource — feeds PCM16 audio into a local audio track.
+ *
+ * Handles:
+ * - Resampling from user's sample rate (e.g. 16kHz) to Opus rate (48kHz)
+ * - Opus encoding
+ * - Frame buffering to ensure exact 20ms frame boundaries
+ * - RTP packetization
+ */
+
+declare class AudioSource {
+    readonly sampleRate: number;
+    readonly channels: number;
+    private encoder;
+    private track;
+    private sampleBuffer;
+    private bufferOffset;
+    private readonly frameSizeAt48k;
+    private _onEncodedFrame;
+    /**
+     * @param sampleRate Input sample rate (e.g. 16000 for STT/TTS)
+     * @param channels Number of channels (1 = mono)
+     */
+    constructor(sampleRate: number, channels?: number);
+    /** Set the callback for encoded Opus frames. Used internally by LocalAudioTrack. */
+    set onEncodedFrame(cb: ((opusData: Buffer) => void) | null);
+    /** Associate this source with a werift MediaStreamTrack */
+    setTrack(track: MediaStreamTrack): void;
+    /**
+     * Feed a PCM16 audio frame into the source.
+     *
+     * The frame is resampled to 48kHz, buffered to 20ms boundaries,
+     * Opus-encoded, and sent to the track for RTP transmission.
+     */
+    captureFrame(frame: AudioFrame): Promise<void>;
+    /** Clear any buffered samples */
+    flush(): void;
+    /** Release encoder resources */
+    destroy(): void;
+    private encodeAndSend;
+}
+
+/**
+ * AudioStream — async iterable stream of decoded audio frames
+ * from a remote participant's audio track.
+ *
+ * Handles:
+ * - RTP depacketization
+ * - Opus decoding → PCM16 @ 48kHz
+ * - Resampling to desired output rate (e.g. 16kHz for STT)
+ * - Packet loss concealment
+ */
+
+declare class AudioStream implements AsyncIterable<AudioFrame> {
+    private decoder;
+    private depacketizer;
+    private queue;
+    private readonly outputSampleRate;
+    private readonly outputChannels;
+    private track;
+    private _closed;
+    /**
+     * @param track The remote audio track to stream from
+     * @param sampleRate Desired output sample rate (default: 16000 for STT)
+     * @param channels Desired output channels (default: 1 = mono)
+     */
+    constructor(track: MediaStreamTrack, sampleRate?: number, channels?: number);
+    get closed(): boolean;
+    /** Close the stream and release resources */
+    close(): void;
+    [Symbol.asyncIterator](): AsyncIterator<AudioFrame>;
+    private start;
+    private processRtpPacket;
+    private emitFrame;
+}
+
+/**
+ * Track classes — LocalAudioTrack, RemoteAudioTrack, TrackPublication.
+ *
+ * Tracks represent individual media streams within a room.
+ */
+
+interface TrackPublicationEvents {
+    [key: string]: (...args: any[]) => void;
+    muted: () => void;
+    unmuted: () => void;
+}
+declare class TrackPublication extends TypedEmitter<TrackPublicationEvents> {
+    sid: string;
+    name: string;
+    kind: TrackType;
+    source: TrackSource;
+    mimeType: string;
+    muted: boolean;
+    constructor(info: TrackInfo);
+    updateInfo(info: TrackInfo): void;
+}
+declare class LocalTrackPublication extends TrackPublication {
+    track: LocalAudioTrack;
+    constructor(info: TrackInfo, track: LocalAudioTrack);
+}
+declare class RemoteTrackPublication extends TrackPublication {
+    track: RemoteAudioTrack | null;
+    setTrack(track: RemoteAudioTrack | null): void;
+}
+interface TrackPublishOptions {
+    /** Track name (default: auto-generated) */
+    name?: string;
+    /** Audio source type (default: MICROPHONE) */
+    source?: TrackSource;
+    /** Disable DTX (Discontinuous Transmission) */
+    disableDtx?: boolean;
+}
+declare class LocalAudioTrack {
+    readonly name: string;
+    readonly source: AudioSource;
+    /** werift MediaStreamTrack used by the PeerConnection sender */
+    readonly mediaTrack: MediaStreamTrack;
+    private transceiver;
+    private packetizer;
+    private _cid;
+    private _sid;
+    private constructor();
+    /** Create a local audio track from an AudioSource */
+    static createAudioTrack(name: string, source: AudioSource): LocalAudioTrack;
+    /** Client-generated track ID (used before server assigns SID) */
+    get cid(): string;
+    /** Server-assigned track SID */
+    get sid(): string;
+    set sid(value: string);
+    /**
+     * Set the RTP transceiver for sending audio.
+     * Called internally by LocalParticipant after negotiation.
+     */
+    setTransceiver(transceiver: RTCRtpTransceiver): void;
+    /** Stop the track and release resources */
+    stop(): void;
+}
+interface RemoteAudioTrackEvents {
+    [key: string]: (...args: any[]) => void;
+    audioFrame: () => void;
+    ended: () => void;
+}
+declare class RemoteAudioTrack extends TypedEmitter<RemoteAudioTrackEvents> {
+    readonly sid: string;
+    readonly name: string;
+    readonly mediaTrack: MediaStreamTrack;
+    private _streams;
+    constructor(sid: string, name: string, mediaTrack: MediaStreamTrack);
+    /**
+     * Create an AudioStream to consume decoded PCM16 frames from this track.
+     * @param sampleRate Desired output sample rate (default: 16000 for STT)
+     * @param channels Desired channels (default: 1)
+     */
+    createStream(sampleRate?: number, channels?: number): AudioStream;
+    /** Close all streams and release resources */
+    stop(): void;
+}
+
+/**
+ * Participant classes — LocalParticipant and RemoteParticipant.
+ *
+ * Manages participant state, track publications, and data messaging.
+ */
+
+interface ParticipantEvents {
+    [key: string]: (...args: any[]) => void;
+    trackPublished: (publication: TrackPublication) => void;
+    trackUnpublished: (publication: TrackPublication) => void;
+    metadataChanged: (metadata: string) => void;
+}
+declare abstract class Participant extends TypedEmitter<ParticipantEvents> {
+    sid: string;
+    identity: string;
+    name: string;
+    metadata: string;
+    state: ParticipantInfo_State;
+    protected _trackPublications: Map<string, TrackPublication>;
+    constructor(sid: string, identity: string, name?: string, metadata?: string);
+    get trackPublications(): Map<string, TrackPublication>;
+    /** Update participant info from server */
+    updateInfo(info: ParticipantInfo): void;
+}
+interface DataPublishOptions {
+    /** Data packet kind (default: RELIABLE) */
+    kind?: DataPacket_Kind;
+    /** Destination participant SIDs (empty = broadcast to all) */
+    destinationSids?: string[];
+    /** Topic for the data message */
+    topic?: string;
+}
+declare class LocalParticipant extends Participant {
+    private engine;
+    private publishedTracks;
+    constructor(engine: RTCEngine, sid: string, identity: string, name?: string, metadata?: string);
+    /**
+     * Publish an audio track to the room.
+     *
+     * Flow:
+     * 1. Send AddTrackRequest to server
+     * 2. Wait for TrackPublishedResponse (server assigns SID)
+     * 3. Add transceiver to publisher PeerConnection
+     * 4. Negotiate SDP
+     */
+    publishTrack(track: LocalAudioTrack, options?: TrackPublishOptions): Promise<LocalTrackPublication>;
+    /**
+     * Unpublish an audio track from the room.
+     */
+    unpublishTrack(track: LocalAudioTrack): Promise<void>;
+    /**
+     * Publish data to the room.
+     *
+     * @param data The data payload
+     * @param options Delivery options (kind, destinations, topic)
+     */
+    publishData(data: Uint8Array, options?: DataPublishOptions): Promise<void>;
+}
+interface RemoteParticipantEvents {
+    [key: string]: (...args: any[]) => void;
+    trackPublished: (publication: TrackPublication) => void;
+    trackUnpublished: (publication: TrackPublication) => void;
+    metadataChanged: (metadata: string) => void;
+    trackSubscribed: (track: RemoteAudioTrack, publication: RemoteTrackPublication) => void;
+    trackUnsubscribed: (track: RemoteAudioTrack, publication: RemoteTrackPublication) => void;
+}
+declare class RemoteParticipant extends TypedEmitter<RemoteParticipantEvents> {
+    sid: string;
+    identity: string;
+    name: string;
+    metadata: string;
+    state: ParticipantInfo_State;
+    private _trackPublications;
+    private _audioTracks;
+    constructor(info: ParticipantInfo);
+    get trackPublications(): Map<string, RemoteTrackPublication>;
+    get audioTracks(): Map<string, RemoteAudioTrack>;
+    /** Update participant info from server */
+    updateInfo(info: ParticipantInfo): void;
+    /**
+     * Called when a remote media track is received on the subscriber PC.
+     * Associates the media track with the correct publication.
+     */
+    addSubscribedTrack(mediaTrack: MediaStreamTrack, trackSid: string, trackName: string): RemoteAudioTrack | null;
+    /** Remove a subscribed track */
+    removeTrack(trackSid: string): RemoteAudioTrack | null;
+    /** Clean up all tracks */
+    destroy(): void;
+}
+
+/**
+ * Room — the main entry point for connecting to a dTelecom room.
+ *
+ * Manages:
+ * - Connection lifecycle (connect, disconnect, reconnect)
+ * - Participant management (join, leave, track subscribe)
+ * - Event dispatch
+ */
+
+interface RoomOptions {
+    /** Auto-subscribe to all published tracks (default: true) */
+    autoSubscribe?: boolean;
+    /** Connection timeout in ms (default: 10000) */
+    connectTimeout?: number;
+}
+interface RoomEvents {
+    [key: string]: (...args: any[]) => void;
+    participantConnected: (participant: RemoteParticipant) => void;
+    participantDisconnected: (participant: RemoteParticipant) => void;
+    trackSubscribed: (track: RemoteAudioTrack, publication: RemoteTrackPublication, participant: RemoteParticipant) => void;
+    trackUnsubscribed: (track: RemoteAudioTrack, publication: RemoteTrackPublication, participant: RemoteParticipant) => void;
+    trackPublished: (publication: RemoteTrackPublication, participant: RemoteParticipant) => void;
+    trackUnpublished: (publication: RemoteTrackPublication, participant: RemoteParticipant) => void;
+    activeSpeakersChanged: (speakers: Array<LocalParticipant | RemoteParticipant>) => void;
+    dataReceived: (data: Uint8Array, participant: RemoteParticipant | undefined, kind: DataPacket_Kind, topic?: string) => void;
+    disconnected: (reason?: string) => void;
+    reconnecting: () => void;
+    reconnected: () => void;
+    roomMetadataChanged: (metadata: string) => void;
+}
+declare class Room extends TypedEmitter<RoomEvents> {
+    /** Local participant (this bot) */
+    localParticipant: LocalParticipant;
+    /** Remote participants indexed by SID */
+    readonly remoteParticipants: Map<string, RemoteParticipant>;
+    /** Room name */
+    name: string;
+    /** Room SID */
+    sid: string;
+    /** Room metadata */
+    metadata: string;
+    private engine;
+    private _isConnected;
+    private activeSpeakers;
+    private roomInfo;
+    constructor();
+    get isConnected(): boolean;
+    /**
+     * Connect to a dTelecom room.
+     *
+     * @param url WebSocket URL of the dTelecom server (e.g. "wss://my.dtelecom.org")
+     * @param token JWT access token (from AccessToken in @dtelecom/server-sdk-js)
+     * @param options Room connection options
+     */
+    connect(url: string, token: string, options?: RoomOptions): Promise<void>;
+    /**
+     * Disconnect from the room.
+     */
+    disconnect(): Promise<void>;
+    /** Get a remote participant by SID */
+    getParticipant(sid: string): RemoteParticipant | undefined;
+    /** Get a remote participant by identity */
+    getParticipantByIdentity(identity: string): RemoteParticipant | undefined;
+    private handleJoinResponse;
+    private setupEngineHandlers;
+    private setupSignalHandlers;
+    private handleParticipantUpdate;
+    private handleRemoteTrack;
+    private handleDataMessage;
+    private handleSpeakersChanged;
+    private getOrCreateParticipant;
+}
+
+/**
+ * Audio resampler for converting between sample rates.
+ *
+ * Supports integer-ratio resampling (e.g. 48kHz ↔ 16kHz = 3:1).
+ * Uses linear interpolation for downsampling and zero-fill + interpolation
+ * for upsampling. Adequate quality for speech audio.
+ */
+/**
+ * Downsample PCM16 from a higher sample rate to a lower sample rate.
+ * Supports integer-ratio downsampling (e.g. 48000 → 16000 = 3:1).
+ *
+ * Uses simple averaging of N samples → 1 output sample (anti-alias filter).
+ */
+declare function downsample(input: Int16Array, fromRate: number, toRate: number, channels?: number): Int16Array;
+/**
+ * Upsample PCM16 from a lower sample rate to a higher sample rate.
+ * Supports integer-ratio upsampling (e.g. 16000 → 48000 = 1:3).
+ *
+ * Uses linear interpolation between samples.
+ */
+declare function upsample(input: Int16Array, fromRate: number, toRate: number, channels?: number): Int16Array;
+/**
+ * Resample to any target rate (auto-detects up/downsample).
+ */
+declare function resample(input: Int16Array, fromRate: number, toRate: number, channels?: number): Int16Array;
+
+/**
+ * Data channel utilities for sending/receiving protobuf-encoded
+ * DataPacket messages over WebRTC data channels.
+ */
+
+/**
+ * Encode a user data message into a DataPacket for transmission.
+ */
+declare function encodeDataPacket(participantSid: string, payload: Uint8Array, kind?: DataPacket_Kind, options?: {
+    destinationSids?: string[];
+    topic?: string;
+}): Uint8Array;
+/**
+ * Decode a DataPacket received from a data channel.
+ */
+declare function decodeDataPacket(data: Uint8Array): DataPacket;
+/**
+ * Helper to create a text message DataPacket.
+ */
+declare function createTextMessage(participantSid: string, text: string, options?: {
+    destinationSids?: string[];
+    topic?: string;
+}): Uint8Array;
+
+declare enum LogLevel {
+    TRACE = 0,
+    DEBUG = 1,
+    INFO = 2,
+    WARN = 3,
+    ERROR = 4,
+    SILENT = 5
+}
+declare function setLogLevel(level: LogLevel): void;
+interface Logger {
+    trace(msg: string, ...args: unknown[]): void;
+    debug(msg: string, ...args: unknown[]): void;
+    info(msg: string, ...args: unknown[]): void;
+    warn(msg: string, ...args: unknown[]): void;
+    error(msg: string, ...args: unknown[]): void;
+}
+
+export { AudioFrame, AudioSource, AudioStream, ConnectionQuality, DataPacket, DataPacket_Kind, type DataPublishOptions, DisconnectReason, type ICEServer, LocalAudioTrack, LocalParticipant, LocalTrackPublication, LogLevel, type Logger, Participant, type ParticipantEvents, type ParticipantInfo, ParticipantInfo_State, RemoteAudioTrack, RemoteParticipant, type RemoteParticipantEvents, RemoteTrackPublication, Room, type RoomEvents, type Room$1 as RoomInfo, type RoomOptions, SpeakerInfo, type TrackInfo, TrackPublication, type TrackPublishOptions, TrackSource, TrackType, UserPacket, createTextMessage, decodeDataPacket, downsample, encodeDataPacket, resample, setLogLevel, upsample };