/// <reference types="node" />
/// <reference types="node" />
import { EdgeImpulseApi } from '../sdk/studio/api';
import * as models from '../sdk/studio/sdk/model/models';
export interface RunnerConfig {
    projectId: number | undefined;
    blockId: number | undefined;
    storageIndex: number | undefined;
    storagePath: string;
    storageMaxSizeMb: number | undefined;
    deploymentVersion: number | undefined;
    monitorSummaryIntervalMs: number | undefined;
    impulseIdsForProjectId: {
        [k: string]: {
            impulseId: number;
        };
    } | undefined;
    modelVariantsForProjectId: {
        [k: string]: {
            variant: models.KerasModelVariantEnum;
        };
    } | undefined;
}
export interface SerialConfig {
    host: string;
    jwtToken: string;
    uploaderProjectId: number | undefined;
    lastVersionCheck: number;
    apiKey: string | undefined;
    dataForwarderDevices: {
        [deviceId: string]: {
            apiKey: string;
            hmacKey: string;
            projectId: number;
            samplingFreq: number;
            sensors: string[];
        };
    };
    daemonDevices: {
        [deviceId: string]: {
            projectId: number;
        };
    };
    linuxProjectId: number | undefined;
    camera: string | undefined;
    audio: string | undefined;
    runner: RunnerConfig;
    apiKeysForProject: {
        [projectId: string]: string;
    } | undefined;
}
export interface EdgeImpulseEndpoints {
    internal: {
        ws: string;
        api: string;
        apiWs: string;
        ingestion: string;
    };
    device: {
        ws: string;
        api: string;
        ingestion: string;
    };
}
export interface EdgeImpulseConfig {
    api: EdgeImpulseApi;
    endpoints: EdgeImpulseEndpoints;
    setDeviceUpload: boolean;
    host: string;
}
export declare class Config {
    /**
     * Whether a file exists (Node.js API cannot be converted using promisify)
     * @param path
     */
    static exists(path: string): Promise<boolean>;
    /**
     * Unlinks a file, but does not throw if unlinking fails.
     */
    static safeUnlinkFile(path: string): Promise<void>;
    /**
     * Atomic write (first write to temp file, then rename)
     */
    static writeFileAtomic(path: string, content: string | Buffer): Promise<void>;
    private _filename;
    private _api;
    private _endpoints;
    private _configured;
    constructor();
    /**
     * Clean the configuration
     */
    clean(): Promise<void>;
    removeProjectReferences(): Promise<void>;
    getUploaderProjectId(): Promise<number | undefined>;
    setUploaderProjectId(projectId: number): Promise<void>;
    getLinuxProjectId(): Promise<number | undefined>;
    setLinuxProjectId(projectId: number): Promise<void>;
    getApiKeyForProject(projectId: number): Promise<string | undefined>;
    setApiKeyForProject(projectId: number, apiKey: string): Promise<void>;
    getLastVersionCheck(): Promise<number>;
    setLastVersionCheck(): Promise<void>;
    /**
     * Verify that a user has configured the host and was logged in
     */
    verifyLogin(devMode: boolean, apiKey?: string, verifyType?: 'org' | 'project'): Promise<EdgeImpulseConfig>;
    getDataForwarderDevice(deviceId: string): Promise<{
        apiKey: string;
        hmacKey: string;
        projectId: number;
        samplingFreq: number;
        sensors: string[];
    }>;
    storeDataForwarderDevice(deviceId: string, data: {
        apiKey: string;
        hmacKey: string;
        projectId: number;
        samplingFreq: number;
        sensors: string[];
    }): Promise<void>;
    deleteDataForwarderDevice(deviceId: string): Promise<void>;
    getDaemonDevice(deviceId: string): Promise<{
        projectId: number;
    }>;
    storeDaemonDevice(deviceId: string, data: {
        projectId: number;
    }): Promise<void>;
    deleteDaemonDevice(deviceId: string): Promise<void>;
    getCamera(): Promise<string | undefined>;
    storeCamera(camera: string): Promise<void>;
    getAudio(): Promise<string | undefined>;
    storeAudio(audio: string): Promise<void>;
    getRunner(): Promise<RunnerConfig>;
    storeStoragePath(path: string): Promise<void>;
    getStoragePath(): Promise<string>;
    getStorageIndex(): Promise<number>;
    storeStorageIndex(index: number): Promise<void>;
    getStorageMaxSizeMb(): Promise<number | undefined>;
    setStorageMaxSizeMb(maxSizeMb: number): Promise<void>;
    storeProjectId(projectId: number): Promise<void>;
    storeBlockId(blockId: number): Promise<void>;
    setRunnerImpulseIdForProjectId(projectId: number, impulseId: number): Promise<void>;
    getRunnerImpulseIdForProjectId(projectId: number): Promise<number | null>;
    setRunnerModelVariantForProjectId(projectId: number, variant: models.KerasModelVariantEnum): Promise<void>;
    getRunnerModelVariantForProjectId(projectId: number): Promise<models.KerasModelVariantEnum | null>;
    getDeploymentVersion(): Promise<number | undefined>;
    setDeploymentVersion(deploymentVersion: number): Promise<void>;
    getStudioUrl(whitelabelId: number | null): Promise<string | undefined>;
    getDefaultModelsPath(): string;
    getDefaultStoragePath(): string;
    private getDefaultRunnerPath;
    private load;
    /**
     * This'll throw when access failed
     * @param config
     * @param verifyType
     */
    private verifyAccess;
    private getJWTToken;
    private store;
    getMonitorSummaryIntervalMs(): Promise<number | undefined>;
    setMonitorSummaryIntervalMs(ms: number): Promise<void>;
}