@darrellvs/node-wave-link-sdk/dist/index.d.ts

An unofficial SDK for Elgato's Wave Link

import simple_jsonrpc from 'simple-jsonrpc-js';

type EmitterEvents = {
    [key: string]: (...args: any[]) => void;
};

declare class TypedEventEmitter<T extends EmitterEvents> {
    private eventEmitter;
    constructor();
    emit(event: keyof T, ...args: Parameters<T[keyof T]>): void;
    on(event: keyof T, listener: T[keyof T]): void;
    off(event: keyof T, listener: T[keyof T]): void;
    removeAllListeners(event: keyof T): void;
    setMaxListeners(n: number): void;
}

declare class BaseController<T extends EmitterEvents | null> extends TypedEventEmitter<T extends null ? {} : T> {
    constructor();
}

type MixerType = 'com.elgato.mix.stream' | 'com.elgato.mix.local' | 'com.elgato.mix.microphoneFX';
type GetOutputsResponse = {
    outputs: {
        identifier: string;
        name: string;
    }[];
    selectedOutput: string;
};
type GetOutputConfigResponse = {
    localMixer: [boolean, number];
    streamMixer: [boolean, number];
};
type GetInputConfigFilter = {
    filterID: string;
    isActive: boolean;
    name: string;
    pluginID: string;
};
type GetInputConfig = {
    bgColor: string;
    filters?: GetInputConfigFilter[];
    iconData: string;
    identifier: string;
    inputType: number;
    isAvailable: boolean;
    localMixer: [boolean, number, boolean];
    name: string;
    streamMixer: [boolean, number, boolean];
};
type GetInputConfigsResponse = GetInputConfig[];
type WaveLinkEvents = {
    websocketOpen: () => void;
    websocketClose: () => void;
    initialiseChannels: (dto: {
        inputs: GetInputConfigsResponse;
        outputs: GetOutputConfigResponse;
        selectedOutput: GetOutputsResponse['selectedOutput'];
    }) => void;
    outputMuteChanged: (dto: {
        mixerID: MixerType;
        value: boolean;
    }) => void;
    outputVolumeChanged: (dto: {
        mixerID: MixerType;
        value: number;
    }) => void;
    selectedOutputChanged: (value: string) => void;
    inputNameChanged: (dto: {
        identifier: string;
        value: string;
    }) => void;
    inputMuteChanged: (dto: {
        identifier: string;
        mixerID: MixerType;
        value: boolean;
    }) => void;
    inputVolumeChanged: (dto: {
        identifier: string;
        mixerID: MixerType;
        value: number;
    }) => void;
    filterBypassStateChanged: (dto: {
        identifier: string;
        mixerID: MixerType;
        value: boolean;
    }) => void;
    filterAdded: (dto: {
        identifier: string;
        filter: GetInputConfigFilter;
    }) => void;
    filterRemoved: (dto: {
        filterID: string;
        identifier: string;
    }) => void;
    filterChanged: (dto: {
        filterID: string;
        identifier: string;
        value: boolean;
    }) => void;
    inputsChanged: (inputs: GetInputConfigsResponse) => void;
};
type VolumeAndMuteChangedEvent = {
    localVolume: number;
    streamVolume: number;
    localMute: boolean;
    streamMute: boolean;
};
type WaveLinkOutputChannelEvents = {
    localVolumeChanged: (volume: number) => void;
    streamVolumeChanged: (volume: number) => void;
    volumeChanged: (dto: VolumeAndMuteChangedEvent) => void;
    localMuteChanged: (isMuted: boolean) => void;
    streamMuteChanged: (isMuted: boolean) => void;
    muteChanged: (dto: VolumeAndMuteChangedEvent) => void;
    selectedOutputChanged: (identifier: string) => void;
};
type WaveLinkInputChannelEvents = {
    localVolumeChanged: (volume: number) => void;
    streamVolumeChanged: (volume: number) => void;
    volumeChanged: (dto: VolumeAndMuteChangedEvent) => void;
    localMuteChanged: (isMuted: boolean) => void;
    streamMuteChanged: (isMuted: boolean) => void;
    muteChanged: (dto: VolumeAndMuteChangedEvent) => void;
    streamFiltersMuteChanged: (isMuted: boolean) => void;
    localFiltersMuteChanged: (isMuted: boolean) => void;
    nameChanged: (name: string) => void;
};
type WaveLinkFilterEvents = {
    muteChanged: (muted: boolean) => void;
    mute: () => void;
    unmute: () => void;
};

declare class BaseWaveLinkController extends BaseController<WaveLinkEvents> {
    private readonly rpc;
    private readonly host;
    private websocket;
    private minPort;
    private currentPort;
    private isConnecting;
    private lastId;
    private emittedIdsMap;
    private selectedOutput;
    constructor(rpc: simple_jsonrpc, host: string);
    connect(isAutoTry?: boolean): Promise<unknown>;
    getWaveLinkEmmiter(): this;
    private tryToConnect;
    private initRPC;
    private sendRPC;
    private sendRPCProxy;
}

declare class WaveLinkFilterController extends BaseController<WaveLinkFilterEvents> {
    #private;
    private readonly rpc;
    constructor(rpc: simple_jsonrpc, waveLinkEmitter: BaseWaveLinkController, filter: GetInputConfigFilter, channelIdentifier: string);
    get id(): string;
    get name(): string;
    get muted(): boolean;
    get pluginID(): string;
    set muted(shouldMute: boolean);
    mute(): void;
    unmute(): void;
}

declare class WaveLinkInputController extends BaseController<WaveLinkInputChannelEvents> {
    #private;
    constructor(rpc: simple_jsonrpc, waveLinkEmitter: BaseWaveLinkController, input: GetInputConfig);
    getFilter({ name, filterID }: {
        name?: string;
        filterID?: string;
    }): WaveLinkFilterController;
    get identifier(): string;
    get filters(): WaveLinkFilterController[];
    get bgColor(): string;
    get iconData(): string;
    get inputType(): number;
    get isAvailable(): boolean;
    get name(): string;
    get localFiltersMute(): boolean;
    get streamFiltersMute(): boolean;
    get localVolume(): number;
    get streamVolume(): number;
    get localMute(): boolean;
    get streamMute(): boolean;
    set localVolume(volume: number);
    set streamVolume(volume: number);
    set localMute(isMuted: boolean);
    set streamMute(isMuted: boolean);
    set localFiltersMute(isMuted: boolean);
    set streamFiltersMute(isMuted: boolean);
    muteLocal(): void;
    unmuteLocal(): void;
    muteStream(): void;
    unmuteStream(): void;
}

declare class WaveLinkOutputController extends BaseController<WaveLinkOutputChannelEvents> {
    #private;
    constructor(rpc: simple_jsonrpc, waveLinkEmitter: BaseWaveLinkController, identifier: string, localMixer: [boolean, number, boolean], streamMixer: [boolean, number, boolean]);
    get identifier(): string;
    get localVolume(): number;
    get streamVolume(): number;
    get localMute(): boolean;
    get streamMute(): boolean;
    set localVolume(volume: number);
    set streamVolume(volume: number);
    set localMute(isMuted: boolean);
    set streamMute(isMuted: boolean);
    muteLocal(): void;
    unmuteLocal(): void;
    muteStream(): void;
    unmuteStream(): void;
}

declare class WaveLinkController extends BaseController<{
    websocketOpen: () => void;
    websocketClose: () => void;
    ready: () => void;
}> {
    private waveLinkController;
    private INPUTS;
    private OUTPUT;
    private rpc;
    constructor(host?: string);
    private initialiseInputs;
    private initialiseOutputs;
    private attachCloseListener;
    connect(): Promise<void>;
    getOutput(): WaveLinkOutputController;
    getInputs(): WaveLinkInputController[];
    getInput({ name, identifier, }: {
        name?: string;
        identifier?: string;
    }): WaveLinkInputController;
}

export { WaveLinkController, WaveLinkInputController, WaveLinkOutputController };