matterbridge-roborock-vacuum-plugin/dist/services/roborockService.d.ts

Matterbridge Roborock Vacuum Plugin

import { AnsiLogger } from 'matterbridge/logger';
import { ServiceArea } from 'matterbridge/matter/clusters';
import { LocalStorage } from 'node-persist';
import { CleanModeSetting } from '../behaviors/roborock.vacuum/core/CleanModeSetting.js';
import { MapInfo, RoomIndexMap } from '../core/application/models/index.js';
import { AuthenticationResponse } from '../model/AuthenticationResponse.js';
import { PlatformConfigManager } from '../platform/platformConfigManager.js';
import { RoborockAuthenticateApi } from '../roborockCommunication/api/authClient.js';
import { RoborockIoTApi } from '../roborockCommunication/api/iotClient.js';
import { RawRoomMappingData, RoomDto } from '../roborockCommunication/models/home/index.js';
import { Device, Home, Scene, UserData } from '../roborockCommunication/models/index.js';
import { ServiceContainer } from '../services/index.js';
import { DeviceNotifyCallback, Factory } from '../types/index.js';
import { WssSendSnackbarMessage } from '../types/WssSendSnackbarMessage.js';
export interface RoborockServiceConfig {
    authenticateApiFactory?: (logger: AnsiLogger, baseUrl: string) => RoborockAuthenticateApi;
    iotApiFactory?: Factory<UserData, RoborockIoTApi>;
    refreshInterval: number;
    baseUrl: string;
    persist: LocalStorage;
    configManager: PlatformConfigManager;
    container?: ServiceContainer;
    toastMessage: WssSendSnackbarMessage;
}
/** Facade coordinating Auth, Device, Area, and Message services via ServiceContainer. */
export declare class RoborockService {
    private logger;
    private configManager;
    private readonly container;
    private readonly authCoordinator;
    private readonly deviceService;
    private readonly areaService;
    private readonly messageRoutingService;
    private readonly pollingService;
    private readonly connectionService;
    private readonly toastMessage;
    deviceNotify: DeviceNotifyCallback | undefined;
    constructor(params: RoborockServiceConfig, logger: AnsiLogger, configManager: PlatformConfigManager);
    authenticate(): Promise<AuthenticationResponse>;
    /** List all devices for the user's account. */
    listDevices(): Promise<Device[]>;
    getSerialNumber(duid: string): Promise<string>;
    /** Get home data for periodic updates. */
    getHomeDataForUpdating(homeid: number): Promise<Home | undefined>;
    /** Initialize MQTT client for cloud communication. */
    initializeMessageClient(device: Device, userdata: UserData): Promise<void>;
    /** Initialize local network connection for a device. */
    initializeMessageClientForLocal(device: Device): Promise<boolean>;
    /** Send a test email to verify email notification settings. */
    sendTestEmailNotification(): Promise<void>;
    /** Set callback for device status notifications. */
    setDeviceNotify(callback: DeviceNotifyCallback): void;
    /** Start polling device status via local network. */
    activateDeviceNotify(device: Device): void;
    /** Trigger a one-shot local/MQTT status request for a device. */
    requestDeviceStatusOnce(duid: string): Promise<void>;
    /** Stop service and clean up resources. */
    stopService(): void;
    /** Set selected cleaning areas for a device. */
    setSelectedAreas(duid: string, selectedAreas: number[]): void;
    /** Get selected cleaning areas for a device. */
    getSelectedAreas(duid: string): number[];
    /** Set progress for cleaning areas for a device. */
    setProgress(duid: string, progress: ServiceArea.Progress[]): void;
    /** Get progress for cleaning areas for a device. */
    getProgress(duid: string): ServiceArea.Progress[];
    /** Set the stored "was actively cleaning" state for a device. */
    setLastActivelyCleaningState(duid: string, isActivelyCleaning: boolean): void;
    /** Get the stored "was actively cleaning" state for a device. */
    getLastActivelyCleaningState(duid: string): boolean;
    /** Register a callback invoked whenever supported areas are updated for a device. */
    registerAreasListener(duid: string, callback: (areas: ServiceArea.Area[], maps: ServiceArea.Map[]) => void): void;
    /** Set supported maps for a device. */
    setSupportedMaps(duid: string, maps: ServiceArea.Map[]): void;
    /** Get supported maps for a device. */
    getSupportedMaps(duid: string): ServiceArea.Map[];
    /** Start periodic area refresh (getMapInfo) on a timer. */
    startPeriodicAreaRefresh(duid: string, intervalMs?: number): void;
    /** Set supported cleaning areas (rooms) for a device. */
    setSupportedAreas(duid: string, supportedAreas: ServiceArea.Area[]): void;
    /** Set area-to-room index mapping for a device. */
    setSupportedAreaIndexMap(duid: string, indexMap: RoomIndexMap): void;
    /** Set supported cleaning routines/scenes for a device. */
    setSupportedRoutines(duid: string, routineAsRooms: ServiceArea.Area[]): void;
    getSupportedRoutines(duid: string): ServiceArea.Area[] | undefined;
    /** Get supported cleaning areas for a device. */
    getSupportedAreas(duid: string): ServiceArea.Area[];
    /** Get area index map for a device. */
    getSupportedAreasIndexMap(duid: string): RoomIndexMap | undefined;
    /** Get map information for a device. */
    getMapInfo(duid: string): Promise<MapInfo | undefined>;
    /** Store device room list for explicit room mapping. */
    setDeviceRooms(duid: string, rooms: RoomDto[]): void;
    /** Get room mapping for a device. */
    getRoomMap(duid: string, activeMap: number): Promise<RawRoomMappingData | undefined>;
    /** Resolve initial areas (rooms and maps) before device registration. */
    resolveInitialAreas(duid: string): Promise<{
        supportedAreas: ServiceArea.Area[];
        supportedMaps: ServiceArea.Map[];
    }>;
    /** Lazy-fetch room areas for a map when missing from cache. */
    ensureAreasForMap(duid: string, mapId: number, options?: {
        switchFirst?: boolean;
    }): Promise<boolean>;
    /** Switch to a different map on the device. */
    switchMap(duid: string, mapId: number): Promise<void>;
    /** Get V1 resolved segment ID from cache if available and not stale. */
    getV1ResolvedSegment(duid: string): number | undefined;
    /** Request V1 map push (fire-and-forget). */
    requestV1MapRefresh(duid: string): Promise<void>;
    /** Get all scenes for a home. */
    getScenes(homeId: number): Promise<Scene[] | undefined>;
    /** Start a cleaning scene/routine. */
    startScene(sceneId: number): Promise<unknown>;
    /** Get current cleaning mode settings. */
    getCleanModeData(duid: string): Promise<CleanModeSetting>;
    /** Change cleaning mode settings. */
    changeCleanMode(duid: string, settings: CleanModeSetting): Promise<void>;
    /** Start cleaning with selected areas. */
    startClean(duid: string): Promise<void>;
    /** Pause cleaning. */
    pauseClean(duid: string): Promise<void>;
    /** Stop cleaning and return to dock. */
    stopAndGoHome(duid: string): Promise<void>;
    /** Resume paused cleaning. */
    resumeClean(duid: string): Promise<void>;
    /** Skip the current room/segment during cleaning. */
    skipRoomCleaning(duid: string): Promise<void>;
    stopClean(duid: string): Promise<void>;
    /** Play sound to locate vacuum. */
    playSoundToLocate(duid: string): Promise<void>;
    private buildCleanCommand;
}
//# sourceMappingURL=roborockService.d.ts.map