@iobroker/types 5.0.0-alpha.0-20221217-d87d529d

package/build/types.d.ts

@@ -0,0 +1,1239 @@
+/// <reference types="@iobroker/types" />
+/// <reference types="node" />
+
+import type { ChangeFileFunction } from '@iobroker/db-objects-redis';
+import { EventEmitter } from 'events';
+
+/**
+ * Polyfill to allow calling without `new`
+ * @type {AdapterClass}
+ */
+export declare const Adapter: typeof AdapterClass;
+
+/**
+ * Here we define dynamically created methods
+ */
+export declare interface AdapterClass {
+    /** Extend an object and create it if it might not exist */
+    extendObjectAsync(id: string, objPart: ioBroker.PartialObject, options?: ioBroker.ExtendObjectOptions): ioBroker.SetObjectPromise;
+    /** Set capabilities of the given executable. Only works on Linux systems. */
+    setExecutableCapabilities(execPath: string, capabilities: string[], modeEffective?: boolean, modePermitted?: boolean, modeInherited?: boolean): Promise<void>;
+    /** Extend an object (which might not belong to this adapter) and create it if it might not exist */
+    extendForeignObjectAsync<T extends string>(id: T, objPart: ioBroker.PartialObject<ioBroker.ObjectIdToObjectType<T, 'write'>>, options?: ioBroker.ExtendObjectOptions): ioBroker.SetObjectPromise;
+    /** Reads an object from the object db */
+    getObjectAsync(id: string, options?: unknown): ioBroker.GetObjectPromise;
+    /**
+     * Query a predefined object view (similar to SQL stored procedures) and return the results
+     * For a detailed description refer to https://github.com/ioBroker/ioBroker/wiki/Adapter-Development-Documentation#object-fields
+     * or http://guide.couchdb.org/editions/1/en/views.html
+     */
+    getObjectViewAsync<Design extends string = string, Search extends string = string>(design: Design, search: Search, params: ioBroker.GetObjectViewParams | null | undefined, options?: unknown): ioBroker.GetObjectViewPromise<ioBroker.InferGetObjectViewItemType<Design, Search>>;
+    /** Returns a list of objects with id between params.startkey and params.endkey */
+    getObjectListAsync(params: ioBroker.GetObjectListParams | null, options?: {
+        sorted?: boolean;
+    } | Record<string, any>): ioBroker.GetObjectListPromise;
+    /** Returns the enum tree, filtered by the optional enum name */
+    getEnumAsync(name: string, options?: unknown): Promise<{
+        result: Record<string, any>;
+        requestEnum: string;
+    }>;
+    /** Returns the enum tree, filtered by the optional enum name */
+    getEnumsAsync(enumList: ioBroker.EnumList, options?: unknown): ioBroker.GetEnumsPromise;
+    /** Deletes an object from the object db */
+    delObjectAsync(id: string, options?: ioBroker.DelObjectOptions): Promise<void>;
+    /** Deletes an object (which might not belong to this adapter) from the object db */
+    delForeignObjectAsync(id: string, options?: ioBroker.DelObjectOptions): Promise<void>;
+    /** Subscribe to changes of objects in this instance */
+    subscribeObjectsAsync(pattern: string, options?: unknown): Promise<void>;
+    /** Unsubscribe from changes of objects in this instance */
+    unsubscribeObjectsAsync(pattern: string, options?: unknown): Promise<void>;
+    /** Read a value from the states DB. */
+    getStateAsync(id: string, options?: unknown): ioBroker.GetStatePromise;
+    /** Subscribe to changes of objects (which might not belong to this adapter) */
+    subscribeForeignObjectsAsync(pattern: string, options?: unknown): Promise<void>;
+    /** Unsubscribe from changes of objects (which might not belong to this adapter) */
+    unsubscribeForeignObjectsAsync(pattern: string, options?: unknown): Promise<void>;
+    /** Creates an object in the object db. Existing objects are not overwritten. */
+    setObjectNotExistsAsync(id: string, obj: ioBroker.SettableObject, options?: unknown): ioBroker.SetObjectPromise;
+    /** Creates an object (which might not belong to this adapter) in the object db. Existing objects are not overwritten. */
+    setForeignObjectNotExistsAsync<T extends string>(id: T, obj: ioBroker.SettableObject<ioBroker.ObjectIdToObjectType<T, 'write'>>, options?: unknown): ioBroker.SetObjectPromise;
+    /** deletes a device, its channels and states */
+    deleteDeviceAsync(deviceName: string, options?: unknown): Promise<void>;
+    addChannelToEnumAsync(enumName: string, addTo: string, parentDevice: string, channelName: string, options?: unknown): Promise<void>;
+    deleteChannelFromEnumAsync(enumName: string, parentDevice: string, channelName: string, options?: unknown): Promise<void>;
+    /** Returns a list of all devices in this adapter instance */
+    getDevicesAsync(options?: unknown): Promise<ioBroker.DeviceObject[]>;
+    addStateToEnumAsync(enumName: string, addTo: string, parentDevice: string, parentChannel: string, stateName: string, options?: unknown): Promise<void>;
+    deleteStateFromEnumAsync(enumName: string, parentDevice: string, parentChannel: string, stateName: string, options?: unknown): Promise<void>;
+    /** Changes access rights of all files in the adapter directory */
+    chmodFileAsync(adapter: string | null, path: string, options: {
+        mode: number | string;
+    } | Record<string, any>): Promise<{
+        entries: ioBroker.ChownFileResult[];
+        id: string;
+    }>;
+    chownFileAsync(...args: any[]): Promise<any>;
+    /** reads the content of directory from DB for given adapter and path */
+    readDirAsync(adapterName: string | null, path: string, options?: unknown): ioBroker.ReadDirPromise;
+    /** Deletes a given file */
+    unlinkAsync(adapterName: string | null, path: string, options?: unknown): Promise<void>;
+    /** Deletes a given file */
+    delFileAsync(adapterName: string | null, path: string, options?: unknown): Promise<void>;
+    renameAsync(adapterName: string | null, oldName: string, newName: string, options?: unknown): Promise<void>;
+    mkdirAsync(adapterName: string | null, path: string, options?: unknown): Promise<void>;
+    /** reads the content of directory from DB for given adapter and path */
+    readFileAsync(adapterName: string | null, path: string, options?: unknown): ioBroker.ReadFilePromise;
+    writeFileAsync(adapterName: string | null, path: string, data: Buffer | string, options?: unknown): Promise<void>;
+    /** Checks if a file exists in the DB */
+    fileExistsAsync(adapterName: string | null, path: string, options?: unknown): Promise<boolean>;
+    getHistoryAsync(...args: any[]): Promise<any>;
+    /** Deletes a state from the states DB, but not the associated object. Consider using deleteState instead */
+    delStateAsync(id: string, options?: unknown): Promise<void>;
+    /** Deletes a state from the states DB, but not the associated object */
+    delForeignStateAsync(id: string, options?: unknown): Promise<void>;
+    /** Read all states of this adapter which match the given pattern */
+    getStatesAsync(pattern: string, options?: unknown): ioBroker.GetStatesPromise;
+    /** Read all states (which might not belong to this adapter) which match the given pattern */
+    getForeignStatesAsync(pattern: string, options?: unknown): ioBroker.GetStatesPromise;
+    /** Subscribe to changes of states (which might not belong to this adapter) */
+    subscribeForeignStatesAsync(pattern: string, options?: unknown): Promise<void>;
+    /** Subscribe from changes of states (which might not belong to this adapter) */
+    unsubscribeForeignStatesAsync(pattern: string, options?: unknown): Promise<void>;
+    /** Subscribe to changes of states in this instance */
+    subscribeStatesAsync(pattern: string, options?: unknown): Promise<void>;
+    /** Subscribe from changes of states in this instance */
+    unsubscribeStatesAsync(pattern: string, options?: unknown): Promise<void>;
+    /** Writes a binary state into Redis. The ID will not be prefixed with the adapter namespace. */
+    setForeignBinaryStateAsync(id: string, binary: Buffer, options?: unknown): ioBroker.SetStatePromise;
+    /**
+     * Despite the naming convention, this method doesn't prepend the adapter namespace. Use setForeignBinaryStateAsync instead.
+     * Writes a binary state into Redis
+     */
+    setBinaryStateAsync(id: string, binary: Buffer, options?: unknown): ioBroker.SetStatePromise;
+    getForeignBinaryStateAsync(id: string, options?: unknown): ioBroker.GetBinaryStatePromise;
+    /**
+     * Despite the naming convention, this method doesn't prepend the adapter namespace. Use getForeignBinaryStateAsync instead.
+     * Reads a binary state from Redis
+     */
+    getBinaryStateAsync(id: string, options?: unknown): ioBroker.GetBinaryStatePromise;
+    /** Deletes a binary state from the states DB. The ID will not be prefixed with the adapter namespace. */
+    delForeignBinaryStateAsync(id: string, options?: unknown): Promise<void>;
+    /**
+     * Despite the naming convention, this method doesn't prepend the adapter namespace. Use delForeignBinaryStateAsync instead.
+     * Deletes a binary state from the states DB
+     */
+    delBinaryStateAsync(id: string, options?: unknown): Promise<void>;
+    /**
+     * Helper function that looks for first free TCP port starting with the given one.
+     */
+    getPortAsync(port: number): Promise<number>;
+    /** Read a value (which might not belong to this adapter) from the states DB. */
+    getForeignStateAsync(id: string, options?: unknown): ioBroker.GetStatePromise;
+    /** Validates username and password */
+    checkPasswordAsync(user: string, password: string, options?: unknown): Promise<boolean>;
+    /** Sets a new password for the given user */
+    setPasswordAsync(user: string, password: string, options?: unknown): Promise<void>;
+    /** <INTERNAL> Checks if a user exists and is in the given group. */
+    checkGroupAsync(user: string, group: string, options?: unknown): Promise<boolean>;
+    /** <INTERNAL> Determines the users permissions */
+    calculatePermissionsAsync(user: string, commandsPermissions: CommandsPermissions, options?: unknown): Promise<ioBroker.PermissionSet>;
+    /** Creates or overwrites an object in the object db */
+    setObjectAsync(id: string, obj: ioBroker.SettableObject, options?: unknown): ioBroker.SetObjectPromise;
+    /** Creates or overwrites an object (which might not belong to this adapter) in the object db */
+    setForeignObjectAsync<T extends string>(id: T, obj: ioBroker.SettableObject<ioBroker.ObjectIdToObjectType<T, 'write'>>, options?: unknown): ioBroker.SetObjectPromise;
+    getCertificatesAsync(...args: any[]): Promise<any>;
+    /** Get all states, channels, devices and folders of this adapter */
+    getAdapterObjectsAsync(): Promise<Record<string, ioBroker.AdapterScopedObject>>;
+    /** Reads an object (which might not belong to this adapter) from the object db*/
+    getForeignObjectAsync<T extends string>(id: T, options?: unknown): ioBroker.GetObjectPromise<T>;
+    /**
+     * Writes a value (which might not belong to this adapter) into the states DB only if it has changed.
+     */
+    setForeignStateChangedAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack?: boolean): ioBroker.SetStateChangedPromise;
+    setForeignStateChangedAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, options?: unknown): ioBroker.SetStateChangedPromise;
+    setForeignStateChangedAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, options: unknown): ioBroker.SetStateChangedPromise;
+    /**
+     * Writes a value into the states DB only if it has changed.
+     */
+    setStateChangedAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack?: boolean): ioBroker.SetStateChangedPromise;
+    setStateChangedAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, options?: unknown): ioBroker.SetStateChangedPromise;
+    setStateChangedAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, options: unknown): ioBroker.SetStateChangedPromise;
+    /**
+     * Sends a message to a specific host or all hosts.
+     */
+    sendToHostAsync(hostName: string, message: ioBroker.MessagePayload): Promise<ioBroker.Message | undefined>;
+    sendToHostAsync(hostName: string, command: string, message: ioBroker.MessagePayload): Promise<ioBroker.Message | undefined>;
+    /**
+     * Sends a message to a specific instance or all instances of some specific adapter.
+     */
+    sendToAsync(instanceName: string, message: ioBroker.MessagePayload): Promise<ioBroker.Message | undefined>;
+    sendToAsync(instanceName: string, command: string, message: ioBroker.MessagePayload): Promise<ioBroker.Message | undefined>;
+    /**
+     * Deletes a given file
+     */
+    delFile(adapterName: string | null, path: string, callback: ioBroker.ErrnoCallback): void;
+    delFile(adapterName: string | null, path: string, options: unknown, callback: ioBroker.ErrnoCallback): void;
+    /**
+     * Writes a value into the states DB.
+     */
+    setStateAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack?: boolean): ioBroker.SetStatePromise;
+    setStateAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, options?: unknown): ioBroker.SetStatePromise;
+    setStateAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, options: unknown): ioBroker.SetStatePromise;
+    /**
+     * Writes a value (which might not belong to this adapter) into the states DB.
+     */
+    setForeignStateAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack?: boolean): ioBroker.SetStatePromise;
+    setForeignStateAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, options?: unknown): ioBroker.SetStatePromise;
+    setForeignStateAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, options: unknown): ioBroker.SetStatePromise;
+    /**
+     * Get foreign objects by pattern, by specific type and resolve their enums.
+     */
+    getForeignObjectsAsync<T extends ioBroker.ObjectType>(pattern: string, type: T, enums?: ioBroker.EnumList | null, options?: unknown): ioBroker.GetObjectsPromiseTyped<T>;
+    getForeignObjectsAsync<T extends ioBroker.ObjectType>(pattern: string, type: T, options?: unknown): ioBroker.GetObjectsPromiseTyped<T>;
+    getForeignObjectsAsync(pattern: string, options?: unknown): ioBroker.GetObjectsPromise;
+    /**
+     * creates an object with type device
+     */
+    createDeviceAsync(deviceName: string, common?: Partial<ioBroker.DeviceCommon>): ioBroker.SetObjectPromise;
+    createDeviceAsync(deviceName: string, common: Partial<ioBroker.DeviceCommon>, native?: Record<string, any>): ioBroker.SetObjectPromise;
+    createDeviceAsync(deviceName: string, common: Partial<ioBroker.DeviceCommon>, native: Record<string, any>, options?: unknown): ioBroker.SetObjectPromise;
+    /**
+     * Finds an object by its ID or name
+     */
+    findForeignObjectAsync(idOrName: string, type: string): Promise<{
+        id: string;
+        name: string;
+    }>;
+    /**
+     * Creates an object with type channel. It must be located under a device
+     */
+    createChannelAsync(parentDevice: string, channelName: string, roleOrCommon?: string | Partial<ioBroker.ChannelCommon>): ioBroker.SetObjectPromise;
+    createChannelAsync(parentDevice: string, channelName: string, roleOrCommon: string | Partial<ioBroker.ChannelCommon>, native?: Record<string, any>): ioBroker.SetObjectPromise;
+    createChannelAsync(parentDevice: string, channelName: string, roleOrCommon: string | Partial<ioBroker.ChannelCommon>, native: Record<string, any>, options?: unknown): ioBroker.SetObjectPromise;
+    /**
+     * Creates a state and the corresponding object. It must be located in a channel under a device
+     */
+    createStateAsync(parentDevice: string, parentChannel: string, stateName: string, roleOrCommon?: string | Partial<ioBroker.StateCommon>): ioBroker.SetObjectPromise;
+    createStateAsync(parentDevice: string, parentChannel: string, stateName: string, roleOrCommon: string | Partial<ioBroker.StateCommon>, native?: Record<string, any>): ioBroker.SetObjectPromise;
+    createStateAsync(parentDevice: string, parentChannel: string, stateName: string, roleOrCommon: string | Partial<ioBroker.StateCommon>, native: Record<string, any>, options?: unknown): ioBroker.SetObjectPromise;
+    /**
+     * Deletes a channel and its states. It must have been created with createChannel
+     */
+    deleteChannelAsync(channelName: string, options?: unknown): Promise<void>;
+    deleteChannelAsync(parentDevice: string, channelName: string, options?: unknown): Promise<void>;
+    /**
+     * Deletes a state. It must have been created with createState
+     */
+    deleteStateAsync(stateName: string, options?: unknown): Promise<void>;
+    deleteStateAsync(parentChannel: string, stateName: string, options?: unknown): Promise<void>;
+    deleteStateAsync(parentDevice: string, parentChannel: string, stateName: string, options?: unknown): Promise<void>;
+    /**
+     * Returns a list of all channels in this adapter instance @param parentDevice (optional) Name
+     * of the parent device to filter the channels by @param options (optional) Some internal options.
+     */
+    getChannelsOfAsync(): Promise<ioBroker.ChannelObject[]>;
+    getChannelsOfAsync(parentDevice: string, options?: unknown): Promise<ioBroker.ChannelObject[]>;
+    /**
+     * Returns a list of all channels in this adapter instance
+     */
+    getChannels(callback: ioBroker.GetObjectsCallback3<ioBroker.ChannelObject>): void;
+    getChannels(parentDevice: string, callback: ioBroker.GetObjectsCallback3<ioBroker.ChannelObject>): void;
+    getChannels(parentDevice: string, options: unknown, callback: ioBroker.GetObjectsCallback3<ioBroker.ChannelObject>): void;
+    /**
+     * Returns a list of all channels in this adapter instance @param parentDevice (optional)
+     * Name of the parent device to filter the channels by @param options (optional) Some internal options.
+     */
+    getChannelsAsync(): Promise<ioBroker.ChannelObject[]>;
+    getChannelsAsync(parentDevice: string, options?: unknown): Promise<ioBroker.ChannelObject[]>;
+    /**
+     * Returns a list of all states in this adapter instance @param parentDevice (optional)
+     * Name of the parent device to filter the channels by @param parentChannel (optional)
+     * Name of the parent channel to filter the channels by @param options (optional) Some internal options.
+     */
+    getStatesOfAsync(): Promise<ioBroker.StateObject[]>;
+    getStatesOfAsync(parentDevice: string, parentChannel?: string): Promise<ioBroker.StateObject[]>;
+    getStatesOfAsync(parentDevice: string, parentChannel: string, options?: unknown): Promise<ioBroker.StateObject[]>;
+}
+
+/**
+ * Adapter class
+ *
+ * How the initialization happens:
+ *  initObjects => initStates => prepareInitAdapter => initAdapter => initLogging => createInstancesObjects => ready
+ *
+ */
+export declare class AdapterClass extends EventEmitter {
+    /** Contents of iobroker.json */
+    private readonly _config;
+    private readonly _options;
+    private readonly startedInCompactMode;
+    /** List of instances which want our logs */
+    private readonly logList;
+    private readonly aliases;
+    private readonly aliasPatterns;
+    private enums;
+    private eventLoopLags;
+    private overwriteLogLevel;
+    protected adapterReady: boolean;
+    private callbacks?;
+    /**
+     * Contains a live cache of the adapter's states.
+     * NOTE: This is only defined if the adapter was initialized with the option states: true.
+     */
+    oStates?: Record<string, ioBroker.State | undefined>;
+    /**
+     * Contains a live cache of the adapter's objects.
+     * NOTE: This is only defined if the adapter was initialized with the option objects: true.
+     */
+    oObjects?: Record<string, ioBroker.Object | undefined>;
+    private _stopInProgress;
+    private _callbackId;
+    private _firstConnection;
+    private readonly _timers;
+    private readonly _intervals;
+    private readonly _delays;
+    log?: Log;
+    performStrictObjectChecks: boolean;
+    private readonly _logger;
+    private _restartScheduleJob;
+    private _schedule;
+    private namespaceLog;
+    namespace: `${string}.${number}`;
+    protected name: string;
+    private _systemSecret?;
+    /** Whether the adapter has already terminated */
+    private terminated;
+    /** The cache of usernames */
+    private usernames;
+    /** A RegExp to test for forbidden chars in object IDs */
+    readonly FORBIDDEN_CHARS: RegExp;
+    private inputCount;
+    private outputCount;
+    /** The cache of users */
+    private users;
+    /** The cache of user groups */
+    private groups;
+    /** An array of instances, that support auto subscribe */
+    private autoSubscribe;
+    private defaultHistory;
+    private pluginHandler?;
+    private _reportInterval?;
+    private getPortRunning;
+    private readonly _namespaceRegExp;
+    protected instance?: number;
+    private _utils;
+    /** contents of io-package.json */
+    protected adapterConfig?: AdapterOptions | ioBroker.InstanceObject | null;
+    protected connected?: boolean;
+    protected adapterDir: string;
+    /** contents of package.json */
+    protected pack?: Record<string, any>;
+    /** contents of io-package.json */
+    protected ioPack: Record<string, any>;
+    private _initializeTimeout?;
+    private inited?;
+    /** contents of iobroker.json if required via AdapterOptions */
+    protected systemConfig?: Record<string, any>;
+    /** the configured date format of system.config, only available if requested via AdapterOptions `useFormatDate` */
+    protected dateFormat?: any;
+    /** if float comma instead of dot is used, only available if requested via AdapterOptions `useFormatDate` */
+    protected isFloatComma?: boolean;
+    /** configured language of system.config, only available if requested via AdapterOptions `useFormatDate` */
+    protected language?: ioBroker.Languages;
+    /** longitude configured in system.config, only available if requested via AdapterOptions `useFormatDate`*/
+    protected longitude?: number;
+    /** latitude configured in system.config, only available if requested via AdapterOptions `useFormatDate`*/
+    protected latitude?: number;
+    private _defaultObjs?;
+    private _aliasObjectsSubscribed?;
+    protected config?: Record<string, any>;
+    protected host?: string;
+    protected common?: Record<string, any>;
+    private mboxSubscribed?;
+    protected stop?: () => Promise<void>;
+    protected version?: string;
+    protected kill?: () => Promise<void>;
+    protected processLog?: (msg: any) => void;
+    protected requireLog?: (_isActive: boolean) => void;
+    private logOffTimer?;
+    private logRedirect?;
+    private logRequired?;
+    private patterns?;
+    private statesConnectedTime?;
+    constructor(options: AdapterOptions | string);
+    decrypt(secretVal: string, value?: string): string;
+    decrypt(value: string): string;
+    encrypt(secretVal: string, value?: string): string;
+    encrypt(value: string): string;
+    getSession(id: string, callback: ioBroker.GetSessionCallback): MaybePromise;
+    private _getSession;
+    setSession(id: string, ttl: number, data: Record<string, any>, callback?: ioBroker.ErrorCallback): MaybePromise;
+    private _setSession;
+    destroySession(id: string, callback?: ioBroker.ErrorCallback): MaybePromise;
+    private _destroySession;
+    private _getObjectsByArray;
+    terminate(exitCode?: number): never;
+    terminate(reason?: string, exitCode?: number): never;
+    getPort(port: number, host?: string, callback?: (port: number) => void): void;
+    getPort(port: number, callback?: (port: number) => void): void;
+    private _getPort;
+    supportsFeature(featureName: string): boolean;
+    checkPassword(user: string, pw: string, options: Record<string, any>, callback: CheckPasswordCallback): Promise<void>;
+    checkPassword(user: string, pw: string, callback: CheckPasswordCallback): Promise<void>;
+    private _checkPassword;
+    /**
+     * This method update the cached values in `this.usernames`
+     */
+    private _updateUsernameCache;
+    getUserID(username: string): Promise<string | void>;
+    private _getUserID;
+    setPassword(user: string, pw: string, options: Record<string, any>, callback?: ioBroker.ErrorCallback): Promise<void>;
+    setPassword(user: string, pw: string, callback?: ioBroker.ErrorCallback): Promise<void>;
+    private _setPassword;
+    checkGroup(user: string, group: string, options: Record<string, any>, callback?: CheckGroupCallback): Promise<void>;
+    checkGroup(user: string, group: string, callback?: CheckGroupCallback): Promise<void>;
+    private _checkGroup;
+    calculatePermissions(user: string, commandsPermissions: CommandsPermissions, options?: Record<string, any>, callback?: CalculatePermissionsCallback): Promise<void | ioBroker.PermissionSet>;
+    calculatePermissions(user: string, commandsPermissions: CommandsPermissions, callback?: CalculatePermissionsCallback): Promise<void | ioBroker.PermissionSet>;
+    private _calculatePermissions;
+    private _stop;
+    /**
+     * Reads the file certificate from given path and adds a file watcher to restart adapter on cert changes
+     * if a cert is passed it is returned as it is
+     * @param cert
+     */
+    private _readFileCertificate;
+    getCertificates(publicName?: string, privateName?: string, chainedName?: string, callback?: GetCertificatesCallback): void;
+    private _getCertificates;
+    /**
+     * Restarts an instance of the adapter.
+     *
+     */
+    restart(): void;
+    updateConfig(newConfig: Record<string, any>): ioBroker.SetObjectPromise;
+    private _updateConfig;
+    /**
+     * Disables and stops the adapter instance.
+     *
+     */
+    disable(): ioBroker.SetObjectPromise;
+    getEncryptedConfig(attribute: string, callback?: GetEncryptedConfigCallback): Promise<string | void>;
+    private _getEncryptedConfig;
+    setTimeout(cb: TimeoutCallback, timeout: number, ...args: any[]): NodeJS.Timeout | void;
+    clearTimeout(timer: NodeJS.Timeout): void;
+    delay(timeout: number): Promise<void>;
+    setInterval(cb: TimeoutCallback, timeout: number, ...args: any[]): NodeJS.Timeout | void;
+    clearInterval(interval: NodeJS.Timeout): void;
+    setObject(id: string, obj: ioBroker.SettableObject, callback?: ioBroker.SetObjectCallback): Promise<void>;
+    setObject(id: string, obj: ioBroker.SettableObject, options: unknown, callback?: ioBroker.SetObjectCallback): Promise<void>;
+    setObject(id: string, obj: ioBroker.SettableObject, callback?: ioBroker.SetObjectCallback): Promise<void>;
+    private _setObject;
+    /**
+     * Helper method for `set[Foreign]Object[NotExists]` that also sets the default value if one is configured
+     * @param id of the object
+     * @param obj The object to set
+     * @param [options]
+     * @param [callback]
+     */
+    private _setObjectWithDefaultValue;
+    getAdapterObjects(callback: (objects: Record<string, ioBroker.AdapterScopedObject>) => void): Promise<Record<string, ioBroker.AdapterScopedObject> | void>;
+    private _getAdapterObjects;
+    extendObject(id: string, objPart: ioBroker.PartialObject, callback?: ioBroker.SetObjectCallback): void;
+    extendObject(id: string, objPart: ioBroker.PartialObject, options: ioBroker.ExtendObjectOptions, callback?: ioBroker.SetObjectCallback): void;
+    private _extendObject;
+    setForeignObject<T extends string>(id: T, obj: ioBroker.SettableObject<ioBroker.ObjectIdToObjectType<T, 'write'>>, callback?: ioBroker.SetObjectCallback): void;
+    setForeignObject<T extends string>(id: T, obj: ioBroker.SettableObject<ioBroker.ObjectIdToObjectType<T, 'write'>>, options: unknown, callback?: ioBroker.SetObjectCallback): void;
+    private _setForeignObject;
+    extendForeignObject<T extends string>(id: T, objPart: ioBroker.PartialObject<ioBroker.ObjectIdToObjectType<T, 'write'>>, callback?: ioBroker.SetObjectCallback): void;
+    extendForeignObject<T extends string>(id: T, objPart: ioBroker.PartialObject<ioBroker.ObjectIdToObjectType<T, 'write'>>, options: ioBroker.ExtendObjectOptions, callback?: ioBroker.SetObjectCallback): void;
+    private _extendForeignObjectAsync;
+    objectExists(id: string, options?: Record<string, any> | null): Promise<boolean | void>;
+    foreignObjectExists(id: string, options?: Record<string, any> | null): Promise<boolean | void>;
+    getObject(id: string, callback: ioBroker.GetObjectCallback): void;
+    getObject(id: string, options: unknown, callback: ioBroker.GetObjectCallback): void;
+    getObjectView<Design extends string = string, Search extends string = string>(design: Design, search: Search, params: ioBroker.GetObjectViewParams | null | undefined, callback: ioBroker.GetObjectViewCallback<ioBroker.InferGetObjectViewItemType<Design, Search>>): void;
+    getObjectView<Design extends string = string, Search extends string = string>(design: Design, search: Search, params: ioBroker.GetObjectViewParams | null | undefined, options: unknown, callback: ioBroker.GetObjectViewCallback<ioBroker.InferGetObjectViewItemType<Design, Search>>): void;
+    private _getObjectView;
+    getObjectList(params: ioBroker.GetObjectListParams | null, callback: ioBroker.GetObjectListCallback): void;
+    getObjectList(params: ioBroker.GetObjectListParams | null, options: {
+        sorted?: boolean;
+    } | Record<string, any>, callback: ioBroker.GetObjectListCallback): void;
+    getEnum(callback: ioBroker.GetEnumCallback): void;
+    getEnum(name: string, callback: ioBroker.GetEnumCallback): void;
+    getEnum(name: string, options: unknown, callback: ioBroker.GetEnumCallback): void;
+    private _getEnum;
+    getEnums(callback: ioBroker.GetEnumsCallback): void;
+    getEnums(enumList: ioBroker.EnumList, callback: ioBroker.GetEnumsCallback): void;
+    getEnums(enumList: ioBroker.EnumList, options: unknown, callback: ioBroker.GetEnumsCallback): void;
+    private _getEnums;
+    getForeignObjects(pattern: string, callback: ioBroker.GetObjectsCallback): void;
+    getForeignObjects(pattern: string, options: unknown, callback: ioBroker.GetObjectsCallback): void;
+    getForeignObjects<T extends ioBroker.ObjectType>(pattern: string, type: T, callback: ioBroker.GetObjectsCallbackTyped<T>): void;
+    getForeignObjects<T extends ioBroker.ObjectType>(pattern: string, type: T, enums: ioBroker.EnumList, callback: ioBroker.GetObjectsCallbackTyped<T>): void;
+    getForeignObjects<T extends ioBroker.ObjectType>(pattern: string, type: T, options: unknown, callback: ioBroker.GetObjectsCallbackTyped<T>): void;
+    getForeignObjects<T extends ioBroker.ObjectType>(pattern: string, type: T, enums: ioBroker.EnumList | null, options: unknown, callback: ioBroker.GetObjectsCallbackTyped<T>): void;
+    private _getForeignObjects;
+    findForeignObject(idOrName: string, type: string, callback: ioBroker.FindObjectCallback): void;
+    findForeignObject(idOrName: string, type: string, options: unknown, callback: ioBroker.FindObjectCallback): void;
+    getForeignObject<T extends string>(id: T, callback: ioBroker.GetObjectCallback<T>): MaybePromise;
+    getForeignObject<T extends string>(id: T, options: unknown, callback: ioBroker.GetObjectCallback<T>): MaybePromise;
+    private _getForeignObject;
+    delObject(id: string, callback?: ioBroker.ErrorCallback): void;
+    delObject(id: string, options?: ioBroker.DelObjectOptions | null, callback?: ioBroker.ErrorCallback): void;
+    private _deleteObjects;
+    delForeignObject(id: string, callback?: ioBroker.ErrorCallback): void;
+    delForeignObject(id: string, options: ioBroker.DelObjectOptions, callback?: ioBroker.ErrorCallback): void;
+    private _delForeignObject;
+    subscribeObjects(pattern: string, callback?: ioBroker.ErrorCallback): void;
+    subscribeObjects(pattern: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    unsubscribeObjects(pattern: string, callback?: ioBroker.ErrorCallback): void;
+    unsubscribeObjects(pattern: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    subscribeForeignObjects(pattern: string, callback?: ioBroker.ErrorCallback): void;
+    subscribeForeignObjects(pattern: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    unsubscribeForeignObjects(pattern: string, callback?: ioBroker.ErrorCallback): void;
+    unsubscribeForeignObjects(pattern: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    subscribeForeignFiles(pattern: string, callback?: ioBroker.ErrorCallback): void;
+    subscribeForeignFiles(pattern: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    unsubscribeForeignFiles(pattern: string, callback?: ioBroker.ErrorCallback): void;
+    unsubscribeForeignFiles(pattern: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    setObjectNotExists(id: string, obj: ioBroker.SettableObject, callback?: ioBroker.SetObjectCallback): Promise<void | ioBroker.CallbackReturnTypeOf<ioBroker.SetObjectCallback>> | void;
+    setObjectNotExists(id: string, obj: ioBroker.SettableObject, options: unknown, callback?: ioBroker.SetObjectCallback): Promise<void | ioBroker.CallbackReturnTypeOf<ioBroker.SetObjectCallback>> | void;
+    private _setObjectNotExists;
+    setForeignObjectNotExists<T extends string>(id: T, obj: ioBroker.SettableObject<ioBroker.ObjectIdToObjectType<T, 'write'>>, callback?: ioBroker.SetObjectCallback): void;
+    setForeignObjectNotExists<T extends string>(id: T, obj: ioBroker.SettableObject<ioBroker.ObjectIdToObjectType<T, 'write'>>, options: unknown, callback?: ioBroker.SetObjectCallback): void;
+    private _setForeignObjectNotExists;
+    private _DCS2ID;
+    createDevice(deviceName: string, callback?: ioBroker.SetObjectCallback): void;
+    createDevice(deviceName: string, common: Partial<ioBroker.DeviceCommon>, callback?: ioBroker.SetObjectCallback): void;
+    createDevice(deviceName: string, common: Partial<ioBroker.DeviceCommon>, native: Record<string, any>, callback?: ioBroker.SetObjectCallback): void;
+    createDevice(deviceName: string, common: Partial<ioBroker.DeviceCommon>, native: Record<string, any>, options: unknown, callback?: ioBroker.SetObjectCallback): void;
+    private _createDevice;
+    createChannel(parentDevice: string, channelName: string, callback?: ioBroker.SetObjectCallback): void;
+    createChannel(parentDevice: string, channelName: string, roleOrCommon: string | Partial<ioBroker.ChannelCommon>, callback?: ioBroker.SetObjectCallback): void;
+    createChannel(parentDevice: string, channelName: string, roleOrCommon: string | Partial<ioBroker.ChannelCommon>, native: Record<string, any>, callback?: ioBroker.SetObjectCallback): void;
+    createChannel(parentDevice: string, channelName: string, roleOrCommon: string | Partial<ioBroker.ChannelCommon>, native: Record<string, any>, options: unknown, callback?: ioBroker.SetObjectCallback): void;
+    createState(parentDevice: string, parentChannel: string, stateName: string, callback?: ioBroker.SetObjectCallback): void;
+    createState(parentDevice: string, parentChannel: string, stateName: string, roleOrCommon: string | Partial<ioBroker.StateCommon>, callback?: ioBroker.SetObjectCallback): void;
+    createState(parentDevice: string, parentChannel: string, stateName: string, roleOrCommon: string | Partial<ioBroker.StateCommon>, native: Record<string, any>, callback?: ioBroker.SetObjectCallback): void;
+    createState(parentDevice: string, parentChannel: string, stateName: string, roleOrCommon: string | Partial<ioBroker.StateCommon>, native: Record<string, any>, options: unknown, callback?: ioBroker.SetObjectCallback): void;
+    private _createState;
+    deleteDevice(deviceName: string, callback?: ioBroker.ErrorCallback): void;
+    deleteDevice(deviceName: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    private _deleteDevice;
+    addChannelToEnum(enumName: string, addTo: string, parentDevice: string, channelName: string, callback?: ioBroker.ErrorCallback): void;
+    addChannelToEnum(enumName: string, addTo: string, parentDevice: string, channelName: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    private _addChannelToEnum;
+    deleteChannelFromEnum(enumName: string, parentDevice: string, channelName: string, callback?: ioBroker.ErrorCallback): void;
+    deleteChannelFromEnum(enumName: string, parentDevice: string, channelName: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    private _deleteChannelFromEnum;
+    deleteChannel(channelName: string, callback?: ioBroker.ErrorCallback): void;
+    deleteChannel(channelName: string, options?: unknown, callback?: ioBroker.ErrorCallback): void;
+    deleteChannel(parentDevice: string, channelName: string, options?: unknown, callback?: ioBroker.ErrorCallback): void;
+    private _deleteChannel;
+    deleteState(stateName: string, options?: unknown, callback?: ioBroker.ErrorCallback): void;
+    deleteState(parentChannel: string, stateName: string, options?: unknown, callback?: ioBroker.ErrorCallback): void;
+    deleteState(parentDevice: string, parentChannel: string, stateName: string, options?: unknown, callback?: ioBroker.ErrorCallback): void;
+    private _deleteState;
+    getDevices(callback: ioBroker.GetObjectsCallback3<ioBroker.DeviceObject>): void;
+    getDevices(options: unknown, callback: ioBroker.GetObjectsCallback3<ioBroker.DeviceObject>): void;
+    private _getDevices;
+    getChannelsOf(callback: ioBroker.GetObjectsCallback3<ioBroker.ChannelObject>): void;
+    getChannelsOf(parentDevice: string, callback: ioBroker.GetObjectsCallback3<ioBroker.ChannelObject>): void;
+    getChannelsOf(parentDevice: string, options: unknown, callback: ioBroker.GetObjectsCallback3<ioBroker.ChannelObject>): void;
+    private _getChannelsOf;
+    getStatesOf(callback: ioBroker.GetObjectsCallback3<ioBroker.StateObject>): void;
+    getStatesOf(parentDevice: string, callback: ioBroker.GetObjectsCallback3<ioBroker.StateObject>): void;
+    getStatesOf(parentDevice: string | null | undefined, parentChannel: string | null | undefined, callback: ioBroker.GetObjectsCallback3<ioBroker.StateObject>): void;
+    getStatesOf(parentDevice: string | null | undefined, parentChannel: string | null | undefined, options: unknown, callback: ioBroker.GetObjectsCallback3<ioBroker.StateObject>): void;
+    private _getStatesOf;
+    addStateToEnum(enumName: string, addTo: string, parentDevice: string, parentChannel: string, stateName: string, callback?: ioBroker.ErrorCallback): void;
+    addStateToEnum(enumName: string, addTo: string, parentDevice: string, parentChannel: string, stateName: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    private _addStateToEnum;
+    deleteStateFromEnum(enumName: string, parentDevice: string, parentChannel: string, stateName: string, callback?: ioBroker.ErrorCallback): void;
+    deleteStateFromEnum(enumName: string, parentDevice: string, parentChannel: string, stateName: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    private _deleteStateFromEnum;
+    chmodFile(adapter: string | null, path: string, options: {
+        mode: number | string;
+    } | Record<string, any>, callback: ioBroker.ChownFileCallback): void;
+    chmodFile(adapter: string | null, path: string, callback: ioBroker.ChownFileCallback): void;
+    chownFile(_adapter: string, path: string, options: unknown, callback: (err?: Error | null, processedFiles?: any) => void): void;
+    chownFile(_adapter: string, path: string, callback: (err?: Error | null, processedFiles?: any) => void): void;
+    readDir(adapterName: string | null, path: string, callback: ioBroker.ReadDirCallback): void;
+    readDir(adapterName: string | null, path: string, options: unknown, callback: ioBroker.ReadDirCallback): void;
+    unlink(adapterName: string | null, path: string, callback: ioBroker.ErrnoCallback): void;
+    unlink(adapterName: string | null, path: string, options: unknown, callback: ioBroker.ErrnoCallback): void;
+    rename(adapterName: string | null, oldName: string, newName: string, callback: ioBroker.ErrnoCallback): void;
+    rename(adapterName: string | null, oldName: string, newName: string, options: unknown, callback: ioBroker.ErrnoCallback): void;
+    mkdir(adapterName: string | null, path: string, callback: ioBroker.ErrnoCallback): void;
+    mkdir(adapterName: string | null, path: string, options: unknown, callback: ioBroker.ErrnoCallback): void;
+    readFile(adapterName: string | null, path: string, callback: ioBroker.ReadFileCallback): void;
+    readFile(adapterName: string | null, path: string, options: unknown, callback: ioBroker.ReadFileCallback): void;
+    writeFile(adapterName: string | null, path: string, data: Buffer | string, callback: ioBroker.ErrnoCallback): void;
+    writeFile(adapterName: string | null, path: string, data: Buffer | string, options: unknown, callback: ioBroker.ErrnoCallback): void;
+    fileExists(adapterName: string | null, path: string, callback: ioBroker.GenericCallback<boolean>): void;
+    fileExists(adapterName: string | null, path: string, options: unknown, callback: ioBroker.GenericCallback<boolean>): void;
+    formatValue(value: number | string, format: any): string;
+    formatValue(value: number | string, decimals: number, format: any): string;
+    formatDate(dateObj: string | Date | number, format: string): string;
+    formatDate(dateObj: string | Date | number, isDuration: boolean | string, format: string): string;
+    private _formatDate;
+    sendTo(instanceName: string, message: any, callback?: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo): void;
+    sendTo(instanceName: string, command: string, message: any, callback?: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo): void;
+    private _sendTo;
+    sendToHost(hostName: string, message: any, callback?: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo): void;
+    sendToHost(hostName: string, command: string, message: any, callback?: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo): void;
+    private _sendToHost;
+    registerNotification<Scope extends keyof ioBroker.NotificationScopes>(scope: Scope, category: ioBroker.NotificationScopes[Scope] | null, message: string): Promise<void>;
+    setState<T extends ioBroker.SetStateCallback | undefined>(id: string | IdObject, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, callback?: T): T extends ioBroker.SetStateCallback ? Promise<void> : ioBroker.SetStatePromise;
+    setState<T extends ioBroker.SetStateCallback>(id: string | IdObject, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, callback?: T): T extends ioBroker.SetStateCallback ? Promise<void> : ioBroker.SetStatePromise;
+    setState<T extends ioBroker.SetStateCallback>(id: string | IdObject, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, options: unknown, callback?: T): T extends ioBroker.SetStateCallback ? Promise<void> : ioBroker.SetStatePromise;
+    setState<T extends ioBroker.SetStateCallback>(id: string | IdObject, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, options: unknown, callback?: T): T extends ioBroker.SetStateCallback ? Promise<void> : ioBroker.SetStatePromise;
+    private _setState;
+    private _getUserGroups;
+    private _checkState;
+    private _checkStates;
+    private _getGroups;
+    private _setStateChangedHelper;
+    setStateChanged(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, callback?: ioBroker.SetStateChangedCallback): void;
+    setStateChanged(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, callback?: ioBroker.SetStateChangedCallback): void;
+    setStateChanged(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, options: unknown, callback?: ioBroker.SetStateChangedCallback): void;
+    setStateChanged(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, options: unknown, callback?: ioBroker.SetStateChangedCallback): void;
+    private _setStateChanged;
+    setForeignState(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, callback?: ioBroker.SetStateCallback): void;
+    setForeignState(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, callback?: ioBroker.SetStateCallback): void;
+    setForeignState(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, options: unknown, callback?: ioBroker.SetStateCallback): void;
+    setForeignState(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, options: unknown, callback?: ioBroker.SetStateCallback): void;
+    setForeignStateChanged(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, callback?: ioBroker.SetStateChangedCallback): void;
+    setForeignStateChanged(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, callback?: ioBroker.SetStateChangedCallback): void;
+    setForeignStateChanged(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, options: unknown, callback?: ioBroker.SetStateChangedCallback): void;
+    setForeignStateChanged(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, options: unknown, callback?: ioBroker.SetStateChangedCallback): void;
+    getState(id: string, callback: ioBroker.GetStateCallback): void;
+    getState(id: string, options: unknown, callback: ioBroker.GetStateCallback): void;
+    getForeignState(id: string, callback: ioBroker.GetStateCallback): ioBroker.GetStatePromise;
+    getForeignState(id: string, options: unknown, callback: ioBroker.GetStateCallback): ioBroker.GetStatePromise;
+    private _getForeignState;
+    private _getDefaultHistory;
+    getHistory(id: string, options: ioBroker.GetHistoryOptions, callback: ioBroker.GetHistoryCallback): void;
+    getHistory(id: string, callback: ioBroker.GetHistoryCallback): void;
+    private _getHistory;
+    idToDCS(id: string): {
+        device: string;
+        channel: string;
+        state: string;
+    } | null;
+    delState(id: string, callback?: ioBroker.ErrorCallback): void;
+    delState(id: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    private _delState;
+    delForeignState(id: string, callback?: ioBroker.ErrorCallback): void;
+    delForeignState(id: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    private _delForeignState;
+    getStates(pattern: string, callback: ioBroker.GetStatesCallback): void;
+    getStates(pattern: string, options: unknown, callback: ioBroker.GetStatesCallback): void;
+    private _processStatesSecondary;
+    private _processStates;
+    getForeignStates(pattern: string | string[], callback: ioBroker.GetStatesCallback): void;
+    getForeignStates(pattern: string | string[], options: unknown, callback: ioBroker.GetStatesCallback): void;
+    private _getForeignStates;
+    private _addAliasSubscribe;
+    private _removeAliasSubscribe;
+    subscribeForeignStates(pattern: string | string[], callback?: ioBroker.ErrorCallback): void;
+    subscribeForeignStates(pattern: string | string[], options: unknown, callback?: ioBroker.ErrorCallback): void;
+    private _subscribeForeignStates;
+    unsubscribeForeignStates(pattern: string, callback?: ioBroker.ErrorCallback): void;
+    unsubscribeForeignStates(pattern: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    private _unsubscribeForeignStates;
+    subscribeStates(pattern: string, callback?: ioBroker.ErrorCallback): void;
+    subscribeStates(pattern: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    unsubscribeStates(pattern: string, callback?: ioBroker.ErrorCallback): void;
+    unsubscribeStates(pattern: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    setForeignBinaryState(id: string, binary: Buffer, callback: ioBroker.SetStateCallback): void;
+    setForeignBinaryState(id: string, binary: Buffer, options: unknown, callback: ioBroker.SetStateCallback): void;
+    private _setForeignBinaryState;
+    setBinaryState(id: string, binary: Buffer, callback: ioBroker.SetStateCallback): void;
+    setBinaryState(id: string, binary: Buffer, options: unknown, callback: ioBroker.SetStateCallback): void;
+    getForeignBinaryState(id: string, callback: ioBroker.GetBinaryStateCallback): void;
+    getForeignBinaryState(id: string, options: unknown, callback: ioBroker.GetBinaryStateCallback): void;
+    private _getForeignBinaryState;
+    getBinaryState(id: string, callback: ioBroker.GetBinaryStateCallback): void;
+    getBinaryState(id: string, options: unknown, callback: ioBroker.GetBinaryStateCallback): void;
+    delForeignBinaryState(id: string, callback?: ioBroker.ErrorCallback): void;
+    delForeignBinaryState(id: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    private _delForeignBinaryState;
+    delBinaryState(id: string, callback?: ioBroker.ErrorCallback): void;
+    delBinaryState(id: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    getPluginInstance(name: string): ioBroker.Plugin | null;
+    getPluginConfig(name: string): Record<string, any> | null;
+    private _autoSubscribeOn;
+    getSuitableLicenses(all?: boolean, adapterName?: string): Promise<any[]>;
+    private _reportStatus;
+    private _checkLogging;
+    private _initLogging;
+    private _initStates;
+    private _initObjects;
+    /**
+     * Called if states and objects successfully initialized
+     */
+    private _prepareInitAdapter;
+    private _initAdapter;
+    private _exceptionHandler;
+    private _createInstancesObjects;
+    private _extendObjects;
+    private _init;
+}
+
+export declare interface AdapterOptions {
+    subscribesChange?: (subs: Record<string, {
+        regex: RegExp;
+    }>) => void;
+    /** If the adapter collects logs from all adapters (experts only). Default: false */
+    logTransporter?: boolean;
+    /** if true, the date format from system.config */
+    useFormatDate?: boolean;
+    /** if it is possible for other instances to retrive states of this adapter automatically */
+    subscribable?: boolean;
+    /** compact group instance if running in compact mode */
+    compactInstance?: number;
+    /** if desired to have oStates. This is a list with all states values, and it will be updated automatically. */
+    states?: boolean;
+    /** if desired to have oObjects. This is a list with all states, channels and devices of this adapter, and it will be updated automatically.*/
+    objects?: boolean;
+    /** instance number of adapter */
+    instance?: number;
+    /** adapter directory name */
+    dirname?: string;
+    /** flag which defaults to true - if true, adapter warns if states are set without a corresponding existing object */
+    strictObjectChecks?: boolean;
+    /** If true runs in compact mode */
+    compact?: boolean;
+    /** configuration of the connection to controller */
+    config?: AdapterOptionsConfig;
+    /** name of the adapter. Must be exactly the same as directory name. */
+    name: string;
+    /** If true, the systemConfig (iobroker.json) will be available in this.systemConfig */
+    systemConfig?: boolean;
+    /** callback function (id, obj) that will be called if object changed */
+    objectChange?: ioBroker.ObjectChangeHandler;
+    /** callback function (id, obj) that will be called if state changed */
+    stateChange?: ioBroker.StateChangeHandler;
+    /** callback function (id, file) that will be called if file changed */
+    fileChange?: ChangeFileFunction;
+    /** callback to inform about new message the adapter */
+    message?: ioBroker.MessageHandler;
+    /** callback to stop the adapter */
+    unload?: ioBroker.UnloadHandler;
+    /** called when adapter is ready */
+    ready?: ioBroker.ReadyHandler;
+    /** called on reconnection to DB */
+    reconnect?: () => MaybePromise;
+    /** Handler to handle uncaught exceptions, return true if no further handling required */
+    error?: ioBroker.ErrorHandler;
+}
+
+export declare interface AdapterOptionsConfig {
+    log: {
+        level: ioBroker.LogLevel;
+    };
+}
+
+export declare interface AliasDetails {
+    source: AliasDetailsSource | null;
+    targets: AliasTargetEntry[];
+}
+
+export declare interface AliasDetailsSource {
+    min?: number;
+    max?: number;
+    type: string;
+    unit?: string;
+}
+
+export declare interface AliasTargetEntry {
+    alias: ioBroker.StateCommon['alias'];
+    id: string;
+    pattern: string;
+    type: string;
+    max?: number;
+    min?: number;
+    unit?: string;
+}
+
+export declare type CalculatePermissionsCallback = (result: ioBroker.PermissionSet) => void;
+
+declare type Callback = (...args: any[]) => void | Promise<void>;
+
+export declare type CheckGroupCallback = (result: boolean) => void;
+
+export declare type CheckPasswordCallback = (success: boolean, user: string) => void;
+
+export declare type CheckStateCommand = 'getState' | 'setState' | 'delState';
+
+export declare interface CheckStatesResult {
+    objs: ioBroker.StateObject[];
+    ids: string[];
+}
+
+export declare type CommandsPermissions = CommandsPermissionsObject | CommandsPermissionsEntry[];
+
+export declare type CommandsPermissionsEntry = {
+    type: 'object' | 'state' | '' | 'other' | 'file';
+    operation: string;
+};
+
+export declare type CommandsPermissionsObject = {
+    [permission: string]: CommandsPermissionsEntry;
+};
+
+export declare type GetCertificatesCallback = (err: string | null, certs?: ioBroker.Certificates, useLetsEncryptCert?: boolean) => void;
+
+export declare type GetEncryptedConfigCallback = (error: Error | null | undefined, result?: string) => void;
+
+export declare interface GetUserGroupsOptions {
+    user: `system.user.${string}`;
+    [other: string]: any;
+}
+
+declare interface IdObject {
+    device?: string;
+    channel?: string;
+    state?: string;
+}
+
+export declare interface InternalAddChannelToEnumOptions {
+    enumName: string;
+    addTo: string;
+    parentDevice: string;
+    channelName: string;
+    options?: Record<string, any> | null;
+    callback?: ioBroker.ErrorCallback;
+}
+
+export declare interface InternalAddStateToEnumOptions {
+    enumName: string;
+    addTo: string;
+    parentDevice: string;
+    parentChannel: string;
+    stateName: string;
+    options?: Record<string, any> | null;
+    callback?: ioBroker.ErrorCallback;
+}
+
+export declare interface InternalCalculatePermissionsOptions {
+    user: string;
+    commandsPermissions: CommandsPermissions;
+    options?: Record<string, any> | null;
+    callback?: CalculatePermissionsCallback;
+}
+
+export declare interface InternalCheckGroupOptions {
+    user: string;
+    group: string;
+    options?: Record<string, any> | null;
+    callback?: CheckGroupCallback;
+}
+
+export declare interface InternalCheckPasswordOptions {
+    user: string;
+    pw: string;
+    options?: Record<string, any> | null;
+    callback: CheckPasswordCallback;
+}
+
+export declare interface InternalCreateDeviceOptions {
+    deviceName: string;
+    common?: Partial<ioBroker.DeviceCommon>;
+    _native?: Record<string, any> | null;
+    options: unknown;
+    callback?: ioBroker.SetObjectCallback;
+}
+
+export declare interface InternalCreateStateOptions {
+    parentDevice: string;
+    parentChannel: string;
+    stateName: string;
+    common: Partial<ioBroker.StateCommon>;
+    _native: Record<string, any>;
+    options?: Record<string, any> | null;
+    callback?: ioBroker.SetObjectCallback;
+}
+
+export declare interface InternalDelBinaryStateOptions {
+    id: string;
+    options: Record<string, any>;
+    callback?: ioBroker.ErrorCallback;
+}
+
+export declare interface InternalDeleteChannelFromEnumOptions {
+    enumName: string;
+    parentDevice: string;
+    channelName: string;
+    options?: Record<string, any> | null;
+    callback?: ioBroker.ErrorCallback;
+}
+
+export declare interface InternalDeleteChannelOptions {
+    parentDevice: string;
+    channelName: string;
+    callback?: ioBroker.ErrorCallback;
+}
+
+export declare interface InternalDeleteDeviceOptions {
+    deviceName: string;
+    callback?: ioBroker.ErrorCallback;
+}
+
+export declare interface InternalDeleteStateFromEnumOptions {
+    enumName: string;
+    parentDevice: string;
+    parentChannel: string;
+    stateName: string;
+    options?: Record<string, any> | null;
+    callback?: ioBroker.ErrorCallback;
+}
+
+export declare interface InternalDeleteStateOptions {
+    parentDevice: string;
+    parentChannel: string;
+    stateName: string;
+    options?: Record<string, any> | null;
+    callback?: ioBroker.ErrorCallback;
+}
+
+export declare interface InternalDelObjectOptions {
+    id: string;
+    options?: ioBroker.DelObjectOptions | null;
+    callback?: ioBroker.ErrorCallback;
+}
+
+export declare interface InternalDelStateOptions {
+    id: string;
+    options?: Record<string, any> | null;
+    callback?: ioBroker.ErrorCallback;
+}
+
+export declare interface InternalDestroySessionOptions {
+    id: string;
+    callback?: ioBroker.ErrorCallback;
+}
+
+export declare interface InternalFormatDateOptions {
+    dateObj: string | Date | number;
+    isDuration: boolean;
+    _format?: string;
+}
+
+export declare interface InternalGetAdapterObjectsOptions {
+    callback?: (objects: Record<string, ioBroker.AdapterScopedObject>) => void;
+}
+
+export declare interface InternalGetBinaryStateOption {
+    id: string;
+    options: Record<string, any>;
+    callback?: ioBroker.GetBinaryStateCallback;
+}
+
+export declare interface InternalGetCertificatesOptions {
+    publicName: string;
+    privateName: string;
+    chainedName: string;
+    callback?: GetCertificatesCallback;
+}
+
+export declare interface InternalGetChannelsOfOptions {
+    parentDevice: string;
+    callback?: ioBroker.GetObjectsCallback3<ioBroker.ChannelObject>;
+    options?: Record<string, any> | null;
+}
+
+export declare interface InternalGetDevicesOptions {
+    options?: Record<string, any> | null;
+    callback: ioBroker.GetObjectsCallback3<ioBroker.DeviceObject>;
+}
+
+export declare interface InternalGetEncryptedConfigOptions {
+    attribute: string;
+    callback?: GetEncryptedConfigCallback;
+}
+
+export declare interface InternalGetEnumOptions {
+    _enum: string;
+    options?: Record<string, any> | null;
+    callback?: ioBroker.GetEnumCallback;
+}
+
+export declare interface InternalGetEnumsOptions {
+    _enumList?: ioBroker.EnumList;
+    options?: Record<string, any> | null;
+    callback?: ioBroker.GetEnumsCallback;
+}
+
+export declare interface InternalGetHistoryOptions {
+    id: string;
+    options?: ioBroker.GetHistoryOptions | null;
+    callback: ioBroker.GetHistoryCallback;
+}
+
+export declare interface InternalGetObjectOptions {
+    id: string;
+    options: unknown;
+    callback?: ioBroker.GetObjectCallback<any>;
+}
+
+export declare interface InternalGetObjectsOptions {
+    pattern: string;
+    type?: string;
+    enums?: ioBroker.EnumList | null;
+    options?: Record<string, any> | null;
+    callback?: ioBroker.GetObjectsCallbackTyped<any>;
+}
+
+export declare interface InternalGetObjectViewOptions {
+    design: string;
+    search: string;
+    params: ioBroker.GetObjectViewParams;
+    options?: Record<string, any> | null;
+    callback?: ioBroker.GetObjectViewCallback<ioBroker.AnyObject>;
+}
+
+export declare interface InternalGetPortOptions {
+    port: number;
+    host?: string;
+    callback?: (port: number) => void;
+}
+
+export declare interface InternalGetSessionOptions {
+    id: string;
+    callback: ioBroker.GetSessionCallback;
+}
+
+export declare interface InternalGetStateOptions {
+    id: string;
+    options?: Record<string, any> | null;
+    callback?: ioBroker.GetStateCallback;
+}
+
+export declare interface InternalGetStatesOfOptions {
+    parentDevice: string | null | undefined;
+    parentChannel: string | null | undefined;
+    options?: Record<string, any> | null;
+    callback: ioBroker.GetObjectsCallback3<ioBroker.StateObject>;
+}
+
+export declare interface InternalGetStatesOptions {
+    pattern: string | string[];
+    options: Record<string, any>;
+    callback: ioBroker.GetStatesCallback;
+}
+
+export declare interface InternalGetUserIDOptions {
+    username: string;
+}
+
+export declare interface InternalSendToHostOptions {
+    hostName: string;
+    command: string;
+    message: any;
+    callback?: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo;
+}
+
+export declare interface InternalSendToOptions {
+    instanceName: string;
+    command: string;
+    message: any;
+    callback?: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo;
+}
+
+export declare interface InternalSetBinaryStateOptions {
+    id: string;
+    options?: Record<string, any> | null;
+    binary: Buffer;
+    callback?: ioBroker.SetStateCallback;
+}
+
+export declare interface InternalSetObjectOptions {
+    id: string;
+    options?: Record<string, any> | null;
+    obj: ioBroker.SettableObject;
+    callback?: ioBroker.SetObjectCallback;
+}
+
+export declare interface InternalSetPasswordOptions {
+    user: string;
+    pw: string;
+    options?: Record<string, any> | null;
+    callback?: ioBroker.ErrorCallback;
+}
+
+export declare interface InternalSetSessionOptions {
+    id: string;
+    ttl: number;
+    data: Record<string, any>;
+    callback?: ioBroker.ErrorCallback;
+}
+
+export declare interface InternalSetStateChangedOptions extends InternalSetStateOptions {
+    callback?: ioBroker.SetStateChangedCallback;
+}
+
+export declare interface InternalSetStateOptions {
+    id: string | IdObject;
+    state: ioBroker.StateValue | ioBroker.SettableState;
+    ack?: boolean;
+    options?: Record<string, any> | null;
+    callback?: ioBroker.SetStateCallback;
+}
+
+export declare interface InternalSubscribeOptions {
+    pattern: string | string[];
+    options?: Record<string, any> | null;
+    callback?: ioBroker.ErrorCallback;
+}
+
+export declare interface InternalUpdateConfigOptions {
+    newConfig: Record<string, any>;
+}
+
+/**
+ * Log class for adapter.js
+ *
+ * It prefixes every message with the given namespace
+ */
+declare class Log {
+    private readonly namespaceLog;
+    readonly level: string;
+    private readonly logger;
+    /**
+     * @param namespaceLog Logging namespace to prefix
+     * @param level The log level
+     * @param logger logger instance
+     */
+    constructor(namespaceLog: string, level: string, logger: any);
+    silly(msg: string): void;
+    debug(msg: string): void;
+    info(msg: string): void;
+    error(msg: string): void;
+    warn(msg: string): void;
+}
+
+export declare type MaybePromise = Promise<void> | void;
+
+declare type OptionalCallback = undefined | Callback;
+
+declare type Pattern = string | string[];
+
+export declare interface SetStateChangedResult {
+    notChanged: boolean;
+    id: string;
+}
+
+export declare type TimeoutCallback = (args?: any[]) => void;
+
+export declare class Utils {
+    private readonly objects;
+    private readonly states;
+    private readonly namespaceLog;
+    private readonly log;
+    private readonly namespace;
+    private readonly namespaceRegExp;
+    /**
+     * Utils for internal adapter.js usage
+     * @param objects - Objects DB
+     * @param states - States DB
+     * @param namespaceLog - Log prefix
+     * @param logger - Logger instance
+     * @param namespace - the namespace of the adapter
+     * @param namespaceRegExp - the namespace RegExp of the adapter adapter.0
+     */
+    constructor(objects: any, states: any, namespaceLog: string, logger: any, namespace: string, namespaceRegExp: RegExp);
+    /**
+     * Performs the strict object check, which includes checking object existence, read-only logic, type and min/max
+     * additionally it rounds state values whose objects have a common.step attribute defined
+     *
+     * @param id - id of the state
+     * @param state - ioBroker setState object
+     */
+    performStrictObjectCheck(id: string, state: ioBroker.SettableState): Promise<void>;
+    /**
+     * Checks if a passed ID is valid. Throws an error if id is invalid
+     *
+     * @param id id to check or object with properties device, channel and state
+     * @param isForeignId true&false if the ID is a foreign/full ID or only an "adapter local" id
+     * @param options optional
+     * @throws Error when id is invalid
+     */
+    validateId(id: string | any, isForeignId: boolean, options?: ValidateIdOptions | null): asserts id is string;
+    /**
+     * Look up the error description for an error code
+     *
+     * @param code error code
+     * @return error description
+     */
+    static getErrorText(code: number): string;
+    /**
+     * Throws if type is not matching the expected type
+     * @param value value to check type of
+     * @param name name of the parameter for logging
+     */
+    static assertString(value: unknown, name: string): asserts value is string;
+    /**
+     * Throws if type is not a pattern
+     * @param value value to check type of
+     * @param name name of the parameter for logging
+     */
+    static assertPattern(value: unknown, name: string): asserts value is Pattern;
+    /**
+     * Throws if type is not matching the expected type
+     * @param value value to check type of
+     * @param name name of the parameter for logging
+     */
+    static assertBoolean(value: unknown, name: string): asserts value is boolean;
+    /**
+     * Throws if type is not matching the expected type
+     * @param value value to check type of
+     * @param name name of the parameter for logging
+     */
+    static assertNumber(value: unknown, name: string): asserts value is number;
+    /**
+     * Throws if type is not matching the expected type
+     * @param value value to check type of
+     * @param name name of the parameter for logging
+     */
+    static assertObject(value: unknown, name: string): asserts value is Record<string, any>;
+    /**
+     * Throws if type is not an optional callback
+     * @param value value to check type of
+     * @param name name of the parameter for logging
+     */
+    static assertBuffer(value: unknown, name: string): asserts value is Buffer;
+    /**
+     * Throws if type is not an optional callback
+     * @param value value to check type of
+     * @param name name of the parameter for logging
+     */
+    static assertOptionalCallback(value: unknown, name: string): asserts value is OptionalCallback;
+    /**
+     * Throws if type is not an optional callback
+     * @param value value to check type of
+     * @param name name of the parameter for logging
+     */
+    static assertCallback(value: unknown, name: string): asserts value is Callback;
+    /**
+     * Adds the namespace to the id if it is missing, if an object is passed it will be converted to an id string
+     *
+     * @param id id which will be fixed
+     * @param isPattern if the id is a pattern
+     */
+    fixId(id: string | IdObject, isPattern?: boolean): string;
+    /**
+     * Validates the object-type argument that is passed to setState
+     * @param obj object to validate
+     */
+    validateSetStateObjectArgument(obj: Record<string, any>): void;
+}
+
+declare interface ValidateIdOptions {
+    /** in maintenance mode we can access ivnalid ids to delete them, only works with the admin user */
+    maintenance?: boolean;
+    user?: string;
+}
+
+export { }