/**************************************************************************************************
 * hoobs-sdk                                                                                      *
 * Copyright (C) 2020 HOOBS                                                                       *
 *                                                                                                *
 * This program is free software: you can redistribute it and/or modify                           *
 * it under the terms of the GNU General Public License as published by                           *
 * the Free Software Foundation, either version 3 of the License, or                              *
 * (at your option) any later version.                                                            *
 *                                                                                                *
 * This program is distributed in the hope that it will be useful,                                *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of                                 *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                  *
 * GNU General Public License for more details.                                                   *
 *                                                                                                *
 * You should have received a copy of the GNU General Public License                              *
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.                          *
 **************************************************************************************************/
import Accessories from "./accessories";
import Accessory from "./accessory";
import Bridge from "./bridge";
import Location from "./location";
import Networks from "./networks";
import Plugin from "./plugin";
import Plugins from "./plugins";
import Room from "./room";
import Socket from "./socket";
import Status from "./status";
import System from "./system";
import User from "./user";
import { Log } from "./log";
import { Version, Latest } from "./version";
declare const _default: {
    sdk: {
        accessories: typeof Accessories;
        accessory: typeof Accessory;
        auth: {
            status(): Promise<string>;
            validate(): Promise<boolean>;
            disable(): Promise<string>;
            login(username: string, password: string, remember?: boolean | undefined): Promise<boolean>;
            logout(): Promise<boolean>;
            readonly terminal: {
                reset(): Promise<void>;
                chpasswd(username: string, password: string): Promise<void>;
            };
        };
        backup: {
            execute(): Promise<string>;
            catalog(count?: number | undefined): Promise<{
                [key: string]: any;
            }[]>;
        };
        blueZ: {
            status: () => Promise<import("./blue-z").BlueZStatusRecord>;
            start: () => Promise<void>;
            stop: () => Promise<void>;
            restart: () => Promise<void>;
        };
        bridge: typeof Bridge;
        bridges: {
            count(): Promise<number>;
            list(): Promise<import("./bridges").BridgeRecord[]>;
            add(name: string, port: number, pin?: string | undefined, username?: string | undefined, advertiser?: string | undefined, plugin?: string | undefined, protocol?: string | undefined): Promise<boolean>;
            import(file: Blob, name: string, port: number, pin?: string | undefined, username?: string | undefined, advertiser?: string | undefined, protocol?: string | undefined): Promise<Record<string, any>>;
        };
        config: {
            token: {
                authorization: string;
                get(callback: () => string): void;
                set(callback: (token: string) => void): void;
            };
            zigbeeToMqttToken: string | undefined;
            host: {
                get(folder?: string | undefined): string;
                domain(): string;
                set(host: string, port?: number | undefined): void;
            };
            setup(): void;
            get: () => Promise<{
                [key: string]: any;
            }>;
            update: (data: {
                [key: string]: any;
            }) => Promise<Record<string, any>>;
        };
        dates: {
            display(value: string): string;
            ordinal(value: number): string;
            month(value: number): string;
            age(value: string): string;
        };
        hostname: {
            get: () => Promise<{
                [key: string]: any;
            }>;
            update: (hostname: string) => Promise<Record<string, any>>;
        };
        io: typeof Socket;
        latest: typeof Latest;
        location: typeof Location;
        log: typeof Log;
        network: {
            status(): Promise<{
                [key: string]: any;
            }[]>;
            interfaces(): Promise<{
                [key: string]: any;
            }[]>;
            up(iface: string): Promise<void>;
            down(iface: string): Promise<void>;
        };
        networks: typeof Networks;
        plugin: typeof Plugin;
        plugins: typeof Plugins;
        repository: {
            featured(): Promise<{
                [key: string]: any;
            }[]>;
            popular(): Promise<{
                [key: string]: any;
            }[]>;
            search(query: string, skip: number, limit: number): Promise<{
                [key: string]: any;
            }>;
            details(identifier: string): Promise<{
                [key: string]: any;
            }>;
            readme(identifier: string): Promise<string>;
            description(identifier: string): Promise<string>;
            dependencies(identifier: string): Promise<{
                [key: string]: any;
            }>;
            reviews(identifier: string, skip: number, limit: number): Promise<{
                [key: string]: any;
            }>;
            title(value: string): string;
        };
        restore: {
            file(file: string): Promise<Record<string, any>>;
            upload(file: Blob): Promise<Record<string, any>>;
        };
        room: typeof Room;
        rooms: {
            count(): Promise<number>;
            list(): Promise<import("./rooms").RoomRecord[]>;
            add(name: string, sequence?: number | undefined): Promise<boolean>;
        };
        status: typeof Status;
        system: typeof System;
        theme: {
            get(name: string): Promise<import("./theme").Theme>;
            save(name: string, theme: import("./theme").Theme): Promise<Record<string, any>>;
            backdrop(image: Blob): Promise<string>;
        };
        thread: {
            status: () => Promise<import("./thread").ThreadStatusRecord>;
            start: () => Promise<Record<string, any>>;
            stop: () => Promise<Record<string, any>>;
            restart: () => Promise<Record<string, any>>;
        };
        user: typeof User;
        userPreferences: {
            get(userId: number, key: string): Promise<{
                preference?: any;
                error?: string | undefined;
            }>;
            set(userId: number, key: string, value: {
                preference: any;
            }): Promise<void>;
        };
        users: {
            list(): Promise<import("./users").UserRecord[]>;
            add(username: string, password: string, name?: string | undefined, permissions?: {
                [key: string]: boolean;
            } | undefined): Promise<import("./users").UserRecord[]>;
        };
        version: typeof Version;
        weather: {
            current(): Promise<{
                [key: string]: any;
            }>;
            forecast(): Promise<{
                [key: string]: any;
            }[]>;
        };
        wireless: {
            enable(): Promise<void>;
            disable(): Promise<void>;
            connect(iface: string, ssid: string, password: string): Promise<void>;
            disconnect(iface: string, ssid: string): Promise<void>;
        };
        zigbee: {
            start: (pairingTime?: number) => Promise<void>;
            stop: () => Promise<void>;
            subscribeToDevices: (deviceObserver: import("./zigbee2mqtt/ws-client").DeviceObserver) => void;
            unsubscribeFromDevices: (deviceObserver: import("./zigbee2mqtt/ws-client").DeviceObserver) => void;
            subscribeToDeviceStates: (deviceStateObserver: import("./zigbee2mqtt/ws-client").DeviceStateObserver) => void;
            unsubscribeFromDeviceStates: (deviceStateObserver: import("./zigbee2mqtt/ws-client").DeviceStateObserver) => void;
            subscribeToBridgeInfo: (bridgeInfoObserver: import("./zigbee2mqtt/ws-client").BridgeInfoObserver) => void;
            unsubscribeFromBridgeInfo: (bridgeInfoObserver: import("./zigbee2mqtt/ws-client").BridgeInfoObserver) => void;
            removeDevice: (dev: string, force: boolean, block: boolean) => Promise<void>;
            otaUpdate: (deviceId: string) => Promise<void>;
            otaCheckDevice: (deviceName: string) => Promise<void>;
            touchlinkScan: () => Promise<import("./zigbee2mqtt/types").TouchLinkDevice[]>;
            touchlinkIdentify: (device: import("./zigbee2mqtt/types").TouchLinkDevice) => Promise<void>;
            touchlinkReset: (device: import("./zigbee2mqtt/types").TouchLinkDevice) => Promise<void>;
            requestNetworkMap: () => Promise<import("./zigbee2mqtt/types").GraphI>;
            setZigbeeChannel: (channel: number) => Promise<void>;
            setZigbeeTransmitPower: (transmitPower: number) => Promise<void>;
            updateBridgeConfig: (options: unknown) => Promise<any>;
            status: () => Promise<import("./zigbee").ZigbeeStatusRecord>;
        };
    };
    install(Vue: any): void;
};
export default _default;
//# sourceMappingURL=index.d.ts.map