homebridge-denon-heos-audio/dist/denonClient.d.ts

Control your Denon speakers via AVR Control and/or HeosCLI

interface IDenonClientConnectionParams {
    readonly host: string;
    readonly port: number;
    readonly connect_timeout: number;
    readonly response_timeout: number;
    readonly command_prefix: string | undefined;
    readonly command_separator: string;
    readonly response_separator: string;
    readonly all_responses_to_generic: boolean;
}
export interface IDenonClient {
    readonly serialNumber: string;
    isConnected(): boolean;
    getPower(raceStatus?: RaceStatus): Promise<boolean>;
    setPower(power: boolean): Promise<boolean>;
    getPlaying(raceStatus?: RaceStatus): Promise<Playing>;
    setPlaying(playing: Playing): Promise<Playing>;
    setPlayNext(): Promise<void>;
    setPlayPrevious(): Promise<void>;
    getMute(raceStatus?: RaceStatus): Promise<boolean>;
    setMute(mute: boolean): Promise<boolean>;
    getVolume(raceStatus?: RaceStatus): Promise<number>;
    setVolume(volume: number): Promise<number>;
    setVolumeUp(volumeIncrement: number): Promise<void>;
    setVolumeDown(volumeDecrement: number): Promise<void>;
}
export declare abstract class DenonClient implements IDenonClient {
    readonly serialNumber: string;
    readonly params: IDenonClientConnectionParams;
    private socket;
    private sendMutex;
    private dataEventMutex;
    private pendingData;
    protected responseCallback: ResponseCallback | undefined;
    protected debugLogCallback: ((message: string, ...parameters: any[]) => void) | undefined;
    protected powerUpdateCallback: ((power: boolean) => void) | undefined;
    protected muteUpdateCallback: ((mute: boolean) => void) | undefined;
    protected volumeUpdateCallback: ((volume: number) => void) | undefined;
    constructor(serialNumber: string, params: IDenonClientConnectionParams, debugLogCallback?: (message: string, ...parameters: any[]) => void, powerUpdateCallback?: (power: boolean) => void, muteUpdateCallback?: (mute: boolean) => void, volumeUpdateCallback?: (volume: number) => void);
    protected connect(): Promise<void>;
    protected connectUnchecked(): Promise<void>;
    protected abstract subscribeToChangeEvents(): Promise<void>;
    protected sendCommand(command: any, commandMode: CommandMode, { pid, value, passPayload }: {
        value?: string;
        pid?: number;
        passPayload?: boolean;
    }): Promise<string>;
    protected send(command: string, rawCommand?: string, expectedResponse?: RegExp, passPayload?: boolean): Promise<string>;
    protected sendUnchecked(command: string, rawCommand?: string, expectedResponse?: RegExp, passPayload?: boolean): Promise<string>;
    private dataHandler;
    protected abstract responseRouter(response: string): void;
    protected debugLog(message: string, ...parameters: any[]): void;
    isConnected(): boolean;
    abstract getPower(raceStatus?: RaceStatus): Promise<boolean>;
    abstract setPower(power: boolean): Promise<boolean>;
    abstract getPlaying(raceStatus?: RaceStatus): Promise<Playing>;
    abstract setPlaying(playing: Playing): Promise<Playing>;
    abstract setPlayNext(): Promise<void>;
    abstract setPlayPrevious(): Promise<void>;
    abstract getMute(raceStatus?: RaceStatus): Promise<boolean>;
    abstract setMute(mute: boolean): Promise<boolean>;
    abstract getVolume(raceStatus?: RaceStatus): Promise<number>;
    abstract setVolume(volume: number): Promise<number>;
    abstract setVolumeUp(volumeIncrement: number): Promise<void>;
    abstract setVolumeDown(volumeDecrement: number): Promise<void>;
}
export declare enum CommandMode {
    GET = 0,
    SET = 1
}
declare class ResponseCallback {
    readonly callback: (response: string) => void;
    readonly command: string;
    readonly expectedResponse: RegExp;
    readonly passPayload: boolean;
    constructor(callback: (response: string) => void, command: string, expectedResponse: RegExp, passPayload?: boolean);
}
export declare class RaceStatus {
    private static readonly ID_CHARS;
    private running;
    readonly raceId: string;
    isRunning(): boolean;
    setRaceOver(): void;
}
export declare enum Playing {
    PLAY = 0,
    PAUSE = 1,
    STOP = 2,
    UNSUPPORTED = 3
}
export declare const isPlaying: Record<Playing, boolean>;
export declare function findMapByValue(values: any, mapValue: any): any;
export declare function findValueByMap(values: any, mapValue: any): any;
export declare class ConnectionTimeoutException extends Error {
    constructor(params: IDenonClientConnectionParams);
}
export declare class ResponseTimeoutException extends Error {
    constructor(command: string, timeout: number);
}
export declare class CommandFailedException extends Error {
    constructor(command: string);
}
export declare class InvalidResponseException extends Error {
    expectedResponses?: string[];
    actualResponse?: string;
    constructor(message: string, expectedResponses?: string[], actualResponse?: string);
    private static buildFullMessage;
}
export {};