@4players/odin-common/plugin/api.d.ts

A collection of commonly used type definitions and utility functions across ODIN web projects

export declare const MinDBFS = -758.596;
export declare namespace Backend {
    type UID = string;
    type OnStatusChanged = (status: 'started' | 'stopped') => void;
    type OnEvent = (method: string, properties: unknown) => void;
    type Version = '8';
    type Transport = 'H3' | 'WebRTC';
    interface Plugin {
        readonly version: Version;
        readonly playbackVolume: PlaybackVolume;
        readonly supportedTransports: Transport[];
        joinRoom(parameters: JoinRoomParameters): Room;
        createAudioPlayback(parameters: CreateAudioPlaybackParameters): Promise<AudioPlayback>;
        createAudioCapture(parameters: CreateAudioCaptureParameters): Promise<AudioCapture>;
        createVideoCapture(ms: MediaStream, options?: VideoInputOptions): Promise<VideoCapture>;
        createVideoPlayback(parameters: CreateVideoPlaybackParameters): Promise<VideoPlayback>;
        enumerateDevices(): Promise<Array<Device>>;
        setOutputVolume(volume: PlaybackVolume): void;
        setOutputDevice(device: DeviceParameters): Promise<void>;
        close(): void;
    }
    interface Device {
        readonly type: 'AudioPlayback' | 'AudioCapture';
        readonly name: string;
        readonly id: string;
        readonly isDefault: boolean;
    }
    interface DeviceParameters {
        readonly device?: Device;
        onStatusChanged?: OnStatusChanged;
    }
    interface Activity {
        isSilent: boolean;
        rmsDBFS: number;
    }
    interface JitterStats {
        packetsBuffered: number;
        packetsSeen: number;
        packetsProcessed: number;
        packetsTooEarly: number;
        packetsTooLate: number;
        packetsDropped: number;
        packetsInvalid: number;
        packetsRepeated: number;
        packetsLost: number;
    }
    interface ConnectionStats {
        bytesSent: number;
        bytesReceived: number;
        packetsSent: number;
        packetsReceived: number;
        rtt: number;
        packetLoss: number;
    }
    interface JoinRoomParameters {
        readonly url: string | 'loopback';
        readonly token: string;
        readonly roomId?: string;
        readonly userData?: Uint8Array;
        readonly position?: [number, number, number];
        readonly cipher?: SetupCipherSettings;
        readonly onEvent: OnEvent;
        readonly transport?: Transport;
    }
    interface Room {
        readonly token: string;
        readonly cipher: Cipher | undefined;
        connectionStats: ConnectionStats;
        request(method: string, properties: unknown): Promise<unknown>;
        link(media: Media): Promise<void>;
        unlink(media: Media): void;
        close(): void;
    }
    interface Media {
        readonly customType?: string;
        close(): void;
    }
    interface AudioMedia extends Media {
        readonly activity: Activity;
    }
    interface CreateAudioPlaybackParameters {
        readonly uid: UID;
        readonly volume?: PlaybackVolume;
        readonly customType?: string;
    }
    interface CreateVideoPlaybackParameters {
        id: string;
        readonly uid: UID;
        readonly customType?: string;
    }
    interface AudioPlayback extends AudioMedia {
        readonly volume: PlaybackVolume;
        readonly uid: UID;
        jitterStats: JitterStats;
        setVolume(value: PlaybackVolume): void;
    }
    interface CreateAudioCaptureParameters extends Partial<DeviceParameters> {
        readonly volume?: CaptureVolume;
        readonly vad?: VadConfig;
        readonly apm?: ApmConfig;
        readonly customType?: string;
    }
    interface AudioCapture extends AudioMedia {
        readonly volume: CaptureVolume;
        readonly vad?: VadConfig;
        readonly apm?: ApmConfig;
        startLoopback(): Promise<void>;
        stopLoopback(): Promise<void>;
        setVad(config: VadConfig): void;
        setApm(config: ApmConfig): Promise<void>;
        setDevice(device: DeviceParameters): Promise<void>;
        setVolume(value: CaptureVolume): Promise<void>;
    }
    interface VideoCapture extends Media {
        mediaStream?: MediaStream;
        setDevice(ms: MediaStream): Promise<void>;
        volume: CaptureVolume;
        setVolume(volume: CaptureVolume): Promise<void>;
        vad: VadConfig;
        setVad(vad: VadConfig): void;
        audioCapture?: AudioCapture;
    }
    interface VideoPlayback extends Media {
        readonly id: string;
        readonly uid: UID;
        readonly mediaStream?: MediaStream;
    }
    type PlaybackVolume = [number, number];
    type CaptureVolume = 'muted' | number;
    interface VadConfig {
        voiceActivity?: SensitivityRange;
        volumeGate?: SensitivityRange;
    }
    interface SensitivityRange {
        attackThreshold: number;
        releaseThreshold: number;
    }
    interface ApmConfig {
        echoCanceller: boolean;
        highPassFilter: boolean;
        noiseSuppression: 'None' | 'Low' | 'Moderate' | 'High' | 'VeryHigh';
        transientSuppressor: boolean;
        gainController: boolean;
    }
    type SetupCipherSettings = {
        type: 'OdinCrypto';
    } & OdinCryptoSettings;
    type CipherSettings = OdinCryptoSettings;
    interface OdinCryptoSettings {
        password: string | null;
    }
    enum PeerCipherStatus {
        InvalidPassword = -1,
        Unknown = 0,
        Unencrypted = 1,
        Encrypted = 2
    }
    interface Cipher {
        configure(settings: CipherSettings): void;
        getPeerStatus(peerId: number): PeerCipherStatus;
    }
    type VideoInputOptions = {
        codec?: 'H264' | 'VP8' | 'VP9';
        customType?: string;
        vad?: VadConfig;
        volume?: CaptureVolume;
    };
}
export declare const CONNECTION_STATS_INITIAL: Backend.ConnectionStats;
export declare const JITTER_STATS_INITIAL: Backend.JitterStats;
/**
 * The voiceActivity unit is %.
 * The volumeGate unit is in dbfs.
 */
export declare const VAD_DEFAULTS: Backend.VadConfig;
export declare const APM_DEFAULTS: Backend.ApmConfig;