/// <reference types="node" />
/// <reference types="node" />
import TypedEmitter from "typed-emitter";
import { MgmtInterfaceSampleRequestSample, MgmtInterfaceInferenceInfo, ClientConnectionType } from "../shared/MgmtInterfaceTypes";
import { IWebsocket } from "../shared/daemon/iwebsocket";
import { ImpulseRecord, ImpulseRecordError, InferenceMetrics, ModelMonitor } from './model-monitor';
import { ModelInformation } from "../library/classifier/linux-impulse-runner-types";
export type RemoteMgmtDeviceSampleEmitter = TypedEmitter<{
    started: () => void;
    uploading: () => void;
    reading: (progressPercentage: number) => void;
    processing: () => void;
}>;
export interface RemoteMgmtDevice extends TypedEmitter<{
    snapshot: (buffer: Buffer, filename: string) => void;
}> {
    connected: () => boolean;
    getDeviceId: () => Promise<string>;
    getDeviceType: () => Promise<string>;
    getSensors: () => {
        name: string;
        maxSampleLengthS: number;
        frequencies: number[];
    }[];
    getConnectionType: () => ClientConnectionType;
    sampleRequest: (data: MgmtInterfaceSampleRequestSample, ee: RemoteMgmtDeviceSampleEmitter) => Promise<void>;
    supportsSnapshotStreaming: () => boolean;
    supportsSnapshotStreamingWhileCapturing: () => boolean;
    startSnapshotStreaming: (resolution: 'high' | 'low') => Promise<void>;
    stopSnapshotStreaming: () => Promise<void>;
    beforeConnect: () => Promise<void>;
}
export interface RemoteMgmtConfig {
    command: 'edge-impulse-linux' | 'edge-impulse-daemon';
    endpoints: {
        internal: {
            ws: string;
            api: string;
            ingestion: string;
        };
    };
    api: {
        projects: {
            getProjectInfo(projectId: number, queryParams: {
                impulseId?: number;
            }): Promise<{
                success: boolean;
                error?: string;
                project: {
                    name: string;
                    whitelabelId: number | null;
                };
            }>;
        };
        devices: {
            renameDevice(projectId: number, deviceId: string, opts: {
                name: string;
            }): Promise<{
                success: boolean;
                error?: string;
            }>;
            createDevice(projectId: number, opts: {
                deviceId: string;
                deviceType: string;
                ifNotExists: boolean;
            }): Promise<{
                success: boolean;
                error?: string;
            }>;
            getDevice(projectId: number, deviceId: string): Promise<{
                success: boolean;
                error?: string;
                device?: {
                    name: string;
                };
            }>;
        };
        whitelabels: {
            getWhitelabelDomain(whitelabelId: number | null): Promise<{
                success: boolean;
                domain?: string;
            }>;
        };
    };
}
declare const RemoteMgmt_base: new () => TypedEmitter<{
    authenticationFailed: () => void;
    newModelAvailable: () => void;
}>;
export declare class RemoteMgmt extends RemoteMgmt_base {
    private _ws;
    private _projectId;
    private _devKeys;
    private _eiConfig;
    private _device;
    private _state;
    private _snapshotStreamResolution;
    private _createWebsocket;
    private _checkNameCb;
    private _monitor;
    private _isConnected;
    private _inferenceInfo;
    constructor(projectId: number, devKeys: {
        apiKey: string;
        hmacKey: string;
    }, eiConfig: RemoteMgmtConfig, device: RemoteMgmtDevice, monitor: ModelMonitor | undefined, createWebsocket: (url: string) => IWebsocket, checkNameCb: (currName: string) => Promise<string>);
    get isConnected(): boolean;
    connect(reconnectOnFailure?: boolean, inferenceInfo?: MgmtInterfaceInferenceInfo | undefined): Promise<void>;
    disconnect(): void;
    inferenceSummaryListener(ev: InferenceMetrics): void;
    impulseRecordListener(ev: ImpulseRecord): void;
    impulseRecordsResponseListener(ev: ImpulseRecord | ImpulseRecordError): void;
    private registerPingPong;
    private attachWsHandlers;
    sendModelUpdateStatus(model: ModelInformation, success: boolean, error?: string): Promise<void>;
    private sendHello;
    private checkName;
    private getProjectInfo;
    private waitForSnapshotStartedOrIdle;
    private waitForInferenceStreamStartedOrIdle;
    private sleep;
}
export {};