lavva.exalushome/build/js/Services/Devices/DevicesService.d.ts

Library implementing communication and abstraction layers for ExalusHome system

import { IDIService } from '../../IDIService';
import { ITypedEvent } from '../../TypedEvent';
import { IDevice, DeviceTasksInfo, ManuallyPairedDevice } from './IDevice';
import { DeviceTaskPairExecutionResult, IDevicesService } from './IDevicesService';
import { IDeviceState, IDeviceStateData, StateReliability } from './IDeviceState';
import { IDeviceChannel } from './IDeviceChannel';
import { Status } from '../../DataFrame';
import { IDeviceTask } from './IDeviceTask';
import { DeviceTaskExecutionResult } from './TaskExecutionResult';
import { ISequenceInfo } from '../Scenes/Scenes';
/**
 * @type Class
 */
export declare class DevicesService implements IDIService, IDevicesService {
    private _devices;
    static readonly ServiceName: string;
    private _onDevicesTasksChangedEvent;
    private _onDeviceFoundEvent;
    private _onDeviceRegisteredEvent;
    private _onDeviceRemovedEvent;
    private _onDeviceFirmwareVersionChangedEvent;
    private _onDeviceStateChangedEvent;
    private _onDeviceStateRefreshedOrChangedEvent;
    private _connection;
    private _session;
    private _controllerConfiguration;
    private _synchronized;
    private _synchronizedDevicesStates;
    private _devicesChannelsStates;
    private _synchronizationTaskCompletionSource;
    private _deviceStatesSynchronizationTaskCompletionSource;
    constructor();
    ProtocolGuidToProtocolName(guid: string): string | null;
    CanDisplaySceneDevices(): boolean;
    CheckIfControllerSoftwareVersionIsEnough(requiredContainerMajor: number, requiredContainerMinor: number): boolean;
    CheckIfDeviceUsedInScenesAsync(deviceGuid: string): Promise<Status | DeviceUsedInScenes>;
    CheckIfDeviceUsedInScenesAsync(device: IDevice): Promise<Status | DeviceUsedInScenes>;
    CanEditDevicesInfo(): boolean;
    CanAddAndRemoveAndConfigureDevices(): boolean;
    GetDeviceChannelByChannelId(channelId: string): IDeviceChannel | null;
    EnableFastStatesSyncAsync(): Promise<Status>;
    DisableFastStatesSyncAsync(): Promise<Status>;
    IsFastStatesSyncEnabledAsync(): Promise<boolean | Status>;
    GetDevicesForManualPairingAsync(protocolExtensionGuids?: string[] | undefined): Promise<ManuallyPairedDevice[]>;
    GetDevicesForManualPairingAsync(protocolExtensionGuid?: string | undefined): Promise<ManuallyPairedDevice[]>;
    AddManuallyPairedDevice(device: ManuallyPairedDevice): Promise<DeviceTaskExecutionResult>;
    GetDeviceChannelStates(device: IDevice, channel: number): DeviceChannelStates[];
    GetDeviceStates(device: IDevice): DeviceChannelStates[];
    private PutDeviceStateOnList;
    WaitForSynchronizationAsync(): Promise<void>;
    WaitForDevicesStatesSynchronizationAsync(): Promise<void>;
    GetCurrentlyRunningTaksAsync(): Promise<void>;
    ParseDeviceTaskInfo(tasks: string[]): void;
    MapApiDeviceStateToDeviceState(device: IDevice, state: DeviceStateChangedObject): IDeviceState<IDeviceStateData> | null;
    GetServiceName(): string;
    SyncDevicesStatesAsync(forceSlow?: boolean): Promise<boolean>;
    OnDevicesTasksExecutionChangeEvent(): ITypedEvent<DeviceTasksInfo[]>;
    OnDeviceStateChangedEvent(): ITypedEvent<{
        Device: IDevice;
        State: IDeviceState<IDeviceStateData>;
    }>;
    OnDeviceStateRefreshedOrChangedEvent(): ITypedEvent<{
        Device: IDevice;
        State: IDeviceState<IDeviceStateData>;
    }>;
    OnDeviceRegisteredEvent(): ITypedEvent<IDevice>;
    OnDeviceRemovedEvent(): ITypedEvent<IDevice>;
    OnDeviceFoundEvent(): ITypedEvent<IDevice>;
    private MapApiDevices;
    private GetPairedDevicesAsync;
    GetDevicesAsync(withScenes?: boolean): Promise<IDevice[]>;
    GetFoundDevicesAsync(): Promise<IDevice[]>;
    GetDevice(guid: string): IDevice | undefined;
    FindDevicesAsync(): Promise<void>;
    StopSearchingForDevices(): Promise<void>;
    RegisterDeviceAsync(device: IDevice): Promise<DeviceTaskExecutionResult>;
    RemoveDeviceAsync(device: IDevice, force?: boolean): Promise<DeviceTaskExecutionResult>;
    private MapDeviceTaskToDeviceTaskInfo;
    ExecuteDeviceTaskAsync(device: IDevice, task: IDeviceTask): Promise<DeviceTaskExecutionResult>;
    ExecuteDevicesTasksAsync(tasks: [Device: IDevice, Task: IDeviceTask][]): Promise<DeviceTaskPairExecutionResult[]>;
}
declare class DeviceChannelStates {
    Channel: number;
    States: IDeviceState<IDeviceStateData>[];
}
/**
 * @type Class
 */
export declare class DeviceStateChangedObject {
    DeviceGuid: string;
    state: DeviceStateObject;
    Type: number;
    DataType: string;
}
/**
 * @type Class
 */
export declare class DeviceStateObject {
    Channel: number;
    StateReliability: StateReliability;
}
/**
 * @type Class
 */
export declare class DeviceUsedInScenes {
    DeviceGuid: string;
    ConditionsAsCondition: ISequenceInfo[];
    ConditionsAsTask: ISequenceInfo[];
}
export {};