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 { 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';
import { PendingResponseTracker } from './services/pendingResponseTracker.js';
export declare abstract class AbstractClient implements Client {
    protected readonly logger: AnsiLogger;
    protected readonly context: MessageContext;
    protected readonly responseBroadcaster: ResponseBroadcaster;
    private readonly responseTracker;
    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, responseTracker: PendingResponseTracker);
    abstract isConnected(): boolean;
    /** Returns true when client is ready to send requests. Override for custom handshake logic. */
    isReady(): boolean;
    protected initializeConnectionStateListener(client: AbstractClient): void;
    registerMessageListener(listener: AbstractMessageListener): void;
    /**
     * Sends a request without waiting for a response (fire-and-forget).
     * Use get() if you need to wait for a response.
     */
    send(duid: string, request: RequestMessage): Promise<void>;
    /**
     * Internal send logic to be implemented by subclasses (e.g., actual network send).
     */
    protected abstract sendInternal(duid: string, request: RequestMessage): void;
    connect(): void;
    disconnect(): Promise<void>;
    get<T>(duid: string, request: RequestMessage): Promise<T | undefined>;
    registerDevice(duid: string, localKey: string, pv: string, nonce: number | undefined): void;
    registerConnectionListener(listener: AbstractConnectionListener): void;
}
//# sourceMappingURL=abstractClient.d.ts.map