matterbridge-roborock-vacuum-plugin/dist/roborockCommunication/routing/abstractClient.d.ts

Matterbridge Roborock Vacuum Plugin

import { AnsiLogger } from 'matterbridge/logger';
import { MessageContext } from '../models/messageContext.js';
import { RequestMessage } from '../models/requestMessage.js';
import { ResponseMessage } from '../models/responseMessage.js';
import { MessageDeserializer } from '../protocol/deserializers/messageDeserializer.js';
import { MessageSerializer } from '../protocol/serializers/messageSerializer.js';
import { Client } from './client.js';
import { AbstractConnectionListener } from './listeners/abstractConnectionListener.js';
import { AbstractMessageListener } from './listeners/abstractMessageListener.js';
import { ConnectionBroadcaster } from './listeners/connectionBroadcaster.js';
import { ConnectionStateListener } from './listeners/implementation/connectionStateListener.js';
import { ResponseBroadcaster } from './listeners/responseBroadcaster.js';
export declare abstract class AbstractClient implements Client {
    protected readonly logger: AnsiLogger;
    protected readonly context: MessageContext;
    protected readonly responseBroadcaster: ResponseBroadcaster;
    isInDisconnectingStep: boolean;
    retryCount: number;
    protected readonly connectionBroadcaster: ConnectionBroadcaster;
    protected readonly serializer: MessageSerializer;
    protected readonly deserializer: MessageDeserializer;
    protected connectionStateListener: ConnectionStateListener | undefined;
    protected abstract clientName: string;
    protected constructor(logger: AnsiLogger, context: MessageContext, responseBroadcaster: ResponseBroadcaster);
    abstract isConnected(): boolean;
    isReady(): boolean;
    protected initializeConnectionStateListener(client: AbstractClient): void;
    registerMessageListener(listener: AbstractMessageListener): void;
    send(duid: string, request: RequestMessage): Promise<void>;
    protected abstract sendInternal(duid: string, request: RequestMessage): void;
    connect(): void;
    disconnect(): Promise<void>;
    query<T>(duid: string, request: RequestMessage, parseFn: (msg: ResponseMessage) => T | undefined, timeoutMs?: number): Promise<T | undefined>;
    registerDevice(duid: string, localKey: string, pv: string, nonce: number | undefined): void;
    registerConnectionListener(listener: AbstractConnectionListener): void;
}
//# sourceMappingURL=abstractClient.d.ts.map