@iobroker/js-controller-adapter 7.2.3 → 8.0.0-alpha.1-20260921-e5941ca8a

package/build/esm/lib/adapter/adapter.d.ts

@@ -2,20 +2,28 @@ import { EventEmitter } from 'node:events';
 import type { CommandResult } from '@alcalzone/pak';
 import { Log } from '../../lib/adapter/log.js';
 import { STATE_QUALITY } from '../../lib/adapter/constants.js';
-import type { AdapterOptions, CalculatePermissionsCallback, CheckGroupCallback, CheckPasswordCallback, CommandsPermissions, GetCertificatesCallback, GetCertificatesPromiseReturnType, GetEncryptedConfigCallback, GetUserGroupsOptions, InstallNodeModuleOptions, MaybePromise, NotificationOptions, Pattern, SendToOptions, SendToUserInterfaceClientOptions, StopParameters, TimeoutCallback } from '../../lib/_Types.js';
+import type { AdapterOptions, CalculatePermissionsCallback, CheckGroupCallback, CheckPasswordCallback, CommandsPermissions, GetCertificatesCallback, GetCertificatesPromiseReturnType, GetEncryptedConfigCallback, InstallNodeModuleOptions, MaybePromise, NotificationOptions, Pattern, SendToOptions, SendToUserInterfaceClientOptions, StopParameters, SuitableLicense, TimeoutCallback } from '../../lib/_Types.js';
 /**
  * Here we define dynamically created methods
  */
 export interface AdapterClass {
+    /** Listen for state changes */
     on(event: 'stateChange', listener: ioBroker.StateChangeHandler): this;
+    /** Listen for object changes */
     on(event: 'objectChange', listener: ioBroker.ObjectChangeHandler): this;
+    /** Listen for file changes */
     on(event: 'fileChange', listener: ioBroker.FileChangeHandler): this;
+    /** Emitted when the adapter is ready */
     on(event: 'ready', listener: ioBroker.ReadyHandler): this;
+    /** Emitted when the adapter is installed */
     on(event: 'install', listener: ioBroker.ReadyHandler): this;
+    /** Emitted when the adapter is unloaded */
     on(event: 'unload', listener: ioBroker.UnloadHandler): this;
+    /** Emitted when a message is received */
     on(event: 'message', listener: ioBroker.MessageHandler): this;
     /** Only emitted for compact instances */
     on(event: 'exit', listener: (exitCode: number, reason: string) => Promise<void> | void): this;
+    /** Emitted on a new log message */
     on(event: 'log', listener: (message: ioBroker.LogMessage) => Promise<void> | void): this;
     /**
      * Extend an object and create it if it might not exist
@@ -38,61 +46,121 @@ export interface AdapterClass {
     /** 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;
+        user?: ioBroker.ObjectIDs.User;
+    } | null): ioBroker.GetObjectListPromise;
     /** Returns the enum tree, filtered by the optional enum name */
-    getEnumAsync(name: string, options?: unknown): Promise<{
-        result: Record<string, any>;
+    getEnumAsync(name: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<{
+        result: Record<string, ioBroker.EnumObject>;
         requestEnum: string;
     }>;
     /** Returns the enum tree, filtered by the optional enum name */
-    getEnumsAsync(enumList?: ioBroker.EnumList, options?: unknown): ioBroker.GetEnumsPromise;
+    getEnumsAsync(enumList?: ioBroker.EnumList, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): 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>;
+    subscribeObjectsAsync(pattern: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<void>;
     /** Unsubscribe from changes of objects in this instance */
-    unsubscribeObjectsAsync(pattern: string, options?: unknown): Promise<void>;
+    unsubscribeObjectsAsync(pattern: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<void>;
     /** Read a value from the states DB. */
-    getStateAsync(id: string, options?: unknown): ioBroker.GetStatePromise;
+    getStateAsync(id: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): ioBroker.GetStatePromise;
     /** Subscribe to changes of objects (which might not belong to this adapter) */
-    subscribeForeignObjectsAsync(pattern: string | string[], options?: unknown): Promise<void>;
+    subscribeForeignObjectsAsync(pattern: string | string[], options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<void>;
     /** Unsubscribe from changes of objects (which might not belong to this adapter) */
-    unsubscribeForeignObjectsAsync(pattern: string | string[], options?: unknown): Promise<void>;
+    unsubscribeForeignObjectsAsync(pattern: string | string[], options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<void>;
     /** Creates an object in the object db. Existing objects are not overwritten. */
-    setObjectNotExistsAsync(id: string, obj: ioBroker.SettableObject, options?: unknown): ioBroker.SetObjectPromise;
+    setObjectNotExistsAsync(id: string, obj: ioBroker.SettableObject, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): 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;
+    setForeignObjectNotExistsAsync<T extends string>(id: T, obj: ioBroker.SettableObject<ioBroker.ObjectIdToObjectType<T, 'write'>>, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): 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>;
+    /** Adds a channel to an enum */
+    addChannelToEnumAsync(enumName: string, addTo: string, parentDevice: string, channelName: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<void>;
+    /** Removes a channel from an enum */
+    deleteChannelFromEnumAsync(enumName: string, parentDevice: string, channelName: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): 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>;
+    getDevicesAsync(options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<ioBroker.DeviceObject[]>;
+    /** Adds a state to an enum */
+    addStateToEnumAsync(enumName: string, addTo: string, parentDevice: string, parentChannel: string, stateName: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<void>;
+    /** Removes a state from an enum */
+    deleteStateFromEnumAsync(enumName: string, parentDevice: string, parentChannel: string, stateName: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): 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<{
+        user?: ioBroker.ObjectIDs.User;
+    }): Promise<{
         entries: ioBroker.ChownFileResult[];
         id: string;
     }>;
+    /** Changes the owner of all files in the adapter directory */
     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;
+    readDirAsync(adapterName: string | null, path: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): ioBroker.ReadDirPromise;
     /** Deletes a given file */
-    unlinkAsync(adapterName: string | null, path: string, options?: unknown): Promise<void>;
+    unlinkAsync(adapterName: string | null, path: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): 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>;
+    delFileAsync(adapterName: string | null, path: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<void>;
+    /** Renames a file in the DB */
+    renameAsync(adapterName: string | null, oldName: string, newName: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<void>;
+    /** Creates a directory in the DB */
+    mkdirAsync(adapterName: string | null, path: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+        owner?: ioBroker.ObjectIDs.User;
+        ownerGroup?: ioBroker.ObjectIDs.Group;
+    } | null): 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>;
+    readFileAsync(adapterName: string | null, path: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): ioBroker.ReadFilePromise;
+    /** Writes a file into the DB */
+    writeFileAsync(adapterName: string | null, path: string, data: Buffer | string, options?: {
+        virtualFile?: boolean;
+        user?: ioBroker.ObjectIDs.User;
+        group?: ioBroker.ObjectIDs.Group;
+        mode?: number;
+        mimeType?: string;
+    } | null): Promise<void>;
     /** Checks if a file exists in the DB */
-    fileExistsAsync(adapterName: string | null, path: string, options?: unknown): Promise<boolean>;
+    fileExistsAsync(adapterName: string | null, path: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<boolean>;
     /** Read historian data for states of any instance or system state. */
     getHistoryAsync(id: string, options?: ioBroker.GetHistoryOptions): Promise<{
         result?: ioBroker.GetHistoryResult;
@@ -100,79 +168,181 @@ export interface AdapterClass {
         sessionId?: number;
     }>;
     /** Deletes a state from the states DB, but not the associated object. Consider using deleteState instead */
-    delStateAsync(id: string, options?: unknown): Promise<void>;
+    delStateAsync(id: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<void>;
     /** Deletes a state from the states DB, but not the associated object */
-    delForeignStateAsync(id: string, options?: unknown): Promise<void>;
+    delForeignStateAsync(id: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<void>;
     /** Read all states of this adapter that match the given pattern */
-    getStatesAsync(pattern: string, options?: unknown): ioBroker.GetStatesPromise;
+    getStatesAsync(pattern: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): ioBroker.GetStatesPromise;
     /** Read all states (which might not belong to this adapter) which match the given pattern */
-    getForeignStatesAsync(pattern: Pattern, options?: unknown): ioBroker.GetStatesPromise;
+    getForeignStatesAsync(pattern: Pattern, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): ioBroker.GetStatesPromise;
     /** Subscribe to changes of states (which might not belong to this adapter) */
-    subscribeForeignStatesAsync(pattern: string | string[], options?: unknown): Promise<void>;
+    subscribeForeignStatesAsync(pattern: string | string[], options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<void>;
     /** Subscribe from changes of states (which might not belong to this adapter) */
-    unsubscribeForeignStatesAsync(pattern: string | string[], options?: unknown): Promise<void>;
+    unsubscribeForeignStatesAsync(pattern: string | string[], options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<void>;
     /** Subscribe to changes of states in this instance */
-    subscribeStatesAsync(pattern: Pattern, options?: unknown): Promise<void>;
+    subscribeStatesAsync(pattern: Pattern, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<void>;
     /** Subscribe from changes of states in this instance */
-    unsubscribeStatesAsync(pattern: Pattern, options?: unknown): Promise<void>;
+    unsubscribeStatesAsync(pattern: Pattern, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<void>;
     /**
      * Helper function that looks for the 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 state's DB. */
-    getForeignStateAsync(id: string, options?: unknown): ioBroker.GetStatePromise;
+    getForeignStateAsync(id: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): ioBroker.GetStatePromise;
     /** Validates username and password */
-    checkPasswordAsync(user: string, password: string, options?: unknown): Promise<[isPasswordCorrect: boolean, user: `system.user.${string}`]>;
+    checkPasswordAsync(user: string, password: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<[isPasswordCorrect: boolean, user: `system.user.${string}`]>;
     /** Sets a new password for the given user */
-    setPasswordAsync(user: string, password: string, options?: unknown): Promise<void>;
+    setPasswordAsync(user: string, password: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<void>;
     /** <INTERNAL> Checks if a user exists and is in the given group. */
-    checkGroupAsync(user: string, group: string, options?: unknown): Promise<boolean>;
+    checkGroupAsync(user: string, group: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<boolean>;
     /** <INTERNAL> Determines the users permissions */
-    calculatePermissionsAsync(user: string, commandsPermissions: CommandsPermissions, options?: unknown): Promise<ioBroker.PermissionSet>;
+    calculatePermissionsAsync(user: string, commandsPermissions: CommandsPermissions, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<ioBroker.PermissionSet>;
     /**
      * Creates or overwrites an object in the object db
      *
      * @deprecated use `adapter.setObject` without a callback instead
      */
-    setObjectAsync(id: string, obj: ioBroker.SettableObject, options?: unknown): ioBroker.SetObjectPromise;
+    setObjectAsync(id: string, obj: ioBroker.SettableObject, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): ioBroker.SetObjectPromise;
     /**
      * Creates or overwrites an object (which might not belong to this adapter) in the object db
      *
      * @deprecated use `adapter.setForeignObject` without a callback instead
      */
-    setForeignObjectAsync<T extends string>(id: T, obj: ioBroker.SettableObject<ioBroker.ObjectIdToObjectType<T, 'write'>>, options?: unknown): ioBroker.SetObjectPromise;
+    setForeignObjectAsync<T extends string>(id: T, obj: ioBroker.SettableObject<ioBroker.ObjectIdToObjectType<T, 'write'>>, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): ioBroker.SetObjectPromise;
+    /**
+     * Get the certificates of the system.
+     *
+     * @param publicName name of the public certificate
+     * @param privateName name of the private key
+     * @param chainedName name of the chained certificate
+     */
     getCertificatesAsync(publicName?: string, privateName?: string, chainedName?: string): Promise<GetCertificatesPromiseReturnType>;
     /** 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>;
+    getForeignObjectAsync<T extends string>(id: T, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): 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 (which might not belong to this adapter) into the states DB only if it has changed.
+     *
+     * @param id object ID of the state
+     * @param state simple value or object with attributes
+     * @param options optional user context
+     */
+    setForeignStateChangedAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): ioBroker.SetStateChangedPromise;
+    /**
+     * Writes a value (which might not belong to this adapter) into the states DB only if it has changed.
+     *
+     * @param id object ID of the state
+     * @param state simple value or object with attributes
+     * @param ack is command(false) or status(true)
+     * @param options optional user context
+     */
+    setForeignStateChangedAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): 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;
+    /**
+     * Writes a value into the states DB only if it has changed.
+     *
+     * @param id object ID of the state
+     * @param state simple value or object with attributes
+     * @param options optional user context
+     */
+    setStateChangedAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): ioBroker.SetStateChangedPromise;
+    /**
+     * Writes a value into the states DB only if it has changed.
+     *
+     * @param id object ID of the state
+     * @param state simple value or object with attributes
+     * @param ack is command(false) or status(true)
+     * @param options optional user context
+     */
+    setStateChangedAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): 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>;
+    sendToHostAsync(hostName: string, message: ioBroker.MessagePayload): Promise<ioBroker.MessagePayload>;
+    /**
+     * Sends a message to a specific host or all hosts.
+     *
+     * @param hostName name of the host
+     * @param command command name
+     * @param message message to send
+     */
+    sendToHostAsync(hostName: string, command: string, message: ioBroker.MessagePayload): Promise<ioBroker.MessagePayload>;
     /**
      * 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, options?: SendToOptions): Promise<ioBroker.Message | undefined>;
+    sendToAsync(instanceName: string, message: ioBroker.MessagePayload): Promise<ioBroker.MessagePayload>;
+    /**
+     * Sends a message to a specific instance or all instances of some specific adapter.
+     *
+     * @param instanceName name of the instance
+     * @param command command name
+     * @param message message to send
+     * @param options optional options to control the send behaviour
+     */
+    sendToAsync(instanceName: string, command: string, message: ioBroker.MessagePayload, options?: SendToOptions): Promise<ioBroker.MessagePayload>;
     /**
      * 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;
+    /**
+     * Deletes a given file
+     *
+     * @param adapterName adapter name, or null for the current adapter
+     * @param path path to the file
+     * @param options optional user context
+     * @param callback return result
+     */
+    delFile(adapterName: string | null, path: string, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null | undefined, callback: ioBroker.ErrnoCallback): void;
     /**
      * Writes a value into the states DB.
      *
@@ -180,21 +350,63 @@ export interface AdapterClass {
      */
     setStateAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack?: boolean): ioBroker.SetStatePromise;
     /** @deprecated use `adapter.setState` without callback instead */
-    setStateAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, options?: unknown): ioBroker.SetStatePromise;
+    setStateAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null | undefined): ioBroker.SetStatePromise;
     /** @deprecated use `adapter.setState` without callback instead */
-    setStateAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, options: unknown): ioBroker.SetStatePromise;
+    setStateAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null | undefined): 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;
+    /**
+     * Writes a value (which might not belong to this adapter) into the states DB.
+     *
+     * @param id object ID of the state
+     * @param state simple value or object with attributes
+     * @param options optional user context
+     */
+    setForeignStateAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): ioBroker.SetStatePromise;
+    /**
+     * Writes a value (which might not belong to this adapter) into the states DB.
+     *
+     * @param id object ID of the state
+     * @param state simple value or object with attributes
+     * @param ack is command(false) or status(true)
+     * @param options optional user context
+     */
+    setForeignStateAsync(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null | undefined): ioBroker.SetStatePromise;
     /**
      * Get foreign objects by pattern, by specific type and resolve their enums.
      */
-    getForeignObjectsAsync<T extends ioBroker.ObjectType>(pattern: Pattern, type: T, enums?: ioBroker.EnumList | null, options?: unknown): ioBroker.GetObjectsPromiseTyped<T>;
-    getForeignObjectsAsync<T extends ioBroker.ObjectType>(pattern: Pattern, type: T, options?: unknown): ioBroker.GetObjectsPromiseTyped<T>;
-    getForeignObjectsAsync(pattern: Pattern, options?: unknown): ioBroker.GetObjectsPromise;
+    getForeignObjectsAsync<T extends ioBroker.ObjectType>(pattern: Pattern, type: T, enums?: ioBroker.EnumList | null, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): ioBroker.GetObjectsPromiseTyped<T>;
+    /**
+     * Get foreign objects by pattern and specific type.
+     *
+     * @param pattern the pattern to match object ids against
+     * @param type restrict the result to objects of this type
+     * @param options optional user context
+     */
+    getForeignObjectsAsync<T extends ioBroker.ObjectType>(pattern: Pattern, type: T, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): ioBroker.GetObjectsPromiseTyped<T>;
+    /**
+     * Get foreign objects by pattern.
+     *
+     * @param pattern the pattern to match object ids against
+     * @param options optional user context
+     */
+    getForeignObjectsAsync(pattern: Pattern, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): ioBroker.GetObjectsPromise;
     /**
      * creates an object with type device
      *
@@ -204,7 +416,9 @@ export interface AdapterClass {
     /** @deprecated use `extendObject` instead */
     createDeviceAsync(deviceName: string, common: Partial<ioBroker.DeviceCommon>, native?: Record<string, any>): ioBroker.SetObjectPromise;
     /** @deprecated use `extendObject` instead */
-    createDeviceAsync(deviceName: string, common: Partial<ioBroker.DeviceCommon>, native: Record<string, any>, options?: unknown): ioBroker.SetObjectPromise;
+    createDeviceAsync(deviceName: string, common: Partial<ioBroker.DeviceCommon>, native: Record<string, any>, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): ioBroker.SetObjectPromise;
     /**
      * Creates an object with a type channel. It must be located under a device
      *
@@ -214,7 +428,9 @@ export interface AdapterClass {
     /** @deprecated use `extendObject` instead */
     createChannelAsync(parentDevice: string, channelName: string, roleOrCommon: string | Partial<ioBroker.ChannelCommon>, native?: Record<string, any>): ioBroker.SetObjectPromise;
     /** @deprecated use `extendObject` instead */
-    createChannelAsync(parentDevice: string, channelName: string, roleOrCommon: string | Partial<ioBroker.ChannelCommon>, native: Record<string, any>, options?: unknown): ioBroker.SetObjectPromise;
+    createChannelAsync(parentDevice: string, channelName: string, roleOrCommon: string | Partial<ioBroker.ChannelCommon>, native: Record<string, any>, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): ioBroker.SetObjectPromise;
     /**
      * Creates a state and the corresponding object. It must be located in a channel under a device
      *
@@ -224,15 +440,21 @@ export interface AdapterClass {
     /** @deprecated use `extendObject` instead */
     createStateAsync(parentDevice: string, parentChannel: string, stateName: string, roleOrCommon: string | Partial<ioBroker.StateCommon>, native?: Record<string, any>): ioBroker.SetObjectPromise;
     /** @deprecated use `extendObject` instead */
-    createStateAsync(parentDevice: string, parentChannel: string, stateName: string, roleOrCommon: string | Partial<ioBroker.StateCommon>, native: Record<string, any>, options?: unknown): ioBroker.SetObjectPromise;
+    createStateAsync(parentDevice: string, parentChannel: string, stateName: string, roleOrCommon: string | Partial<ioBroker.StateCommon>, native: Record<string, any>, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): ioBroker.SetObjectPromise;
     /**
      * Deletes a channel and its states. It must have been created with createChannel
      *
      * @deprecated use `this.delObject` instead
      */
-    deleteChannelAsync(channelName: string, options?: unknown): Promise<void>;
+    deleteChannelAsync(channelName: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<void>;
     /** @deprecated use `this.delObject` instead */
-    deleteChannelAsync(parentDevice: string, channelName: string, options?: unknown): Promise<void>;
+    deleteChannelAsync(parentDevice: string, channelName: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<void>;
     /**
      * Deletes a state. It must have been created with createState
      *
@@ -240,35 +462,82 @@ export interface AdapterClass {
      */
     deleteStateAsync(stateName: string, options?: unknown): Promise<void>;
     /** @deprecated use `this.delObject` instead */
-    deleteStateAsync(parentChannel: string, stateName: string, options?: unknown): Promise<void>;
+    deleteStateAsync(parentChannel: string, stateName: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<void>;
     /** @deprecated use `this.delObject` instead */
-    deleteStateAsync(parentDevice: string, parentChannel: string, stateName: string, options?: unknown): Promise<void>;
+    deleteStateAsync(parentDevice: string, parentChannel: string, stateName: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): 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.
+     * Returns a list of all channels in this adapter instance
      */
     getChannelsOfAsync(): Promise<ioBroker.ChannelObject[]>;
-    getChannelsOfAsync(parentDevice: string, options?: unknown): Promise<ioBroker.ChannelObject[]>;
+    /**
+     * Returns a list of all channels in this adapter instance, optionally filtered by parent device.
+     *
+     * @param parentDevice Name of the parent device to filter the channels by
+     * @param options Some internal options
+     */
+    getChannelsOfAsync(parentDevice: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<ioBroker.ChannelObject[]>;
     /**
      * Returns a list of all channels in this adapter instance
      */
     getChannels(callback: ioBroker.GetObjectsCallback3<ioBroker.ChannelObject>): void;
+    /**
+     * Returns a list of all channels in this adapter instance
+     *
+     * @param parentDevice Name of the parent device to filter the channels by
+     * @param callback return result
+     */
     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.
+     * Returns a list of all channels in this adapter instance
+     *
+     * @param parentDevice Name of the parent device to filter the channels by
+     * @param options optional user context
+     * @param callback return result
+     */
+    getChannels(parentDevice: string, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null | undefined, callback: ioBroker.GetObjectsCallback3<ioBroker.ChannelObject>): void;
+    /**
+     * Returns a list of all channels in this adapter instance {@link parentDevice} (optional)
+     * Name of the parent device to filter the channels by {@link 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.
+     * Returns a list of all channels in this adapter instance, optionally filtered by parent device.
+     *
+     * @param parentDevice Name of the parent device to filter the channels by
+     * @param options Some internal options
+     */
+    getChannelsAsync(parentDevice: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<ioBroker.ChannelObject[]>;
+    /**
+     * Returns a list of all states in this adapter instance
      */
     getStatesOfAsync(): Promise<ioBroker.StateObject[]>;
+    /**
+     * Returns a list of all states in this adapter instance, optionally filtered by parent device/channel.
+     *
+     * @param parentDevice Name of the parent device to filter the states by
+     * @param parentChannel Name of the parent channel to filter the states by
+     */
     getStatesOfAsync(parentDevice: string, parentChannel?: string): Promise<ioBroker.StateObject[]>;
-    getStatesOfAsync(parentDevice: string, parentChannel: string, options?: unknown): Promise<ioBroker.StateObject[]>;
+    /**
+     * Returns a list of all states in this adapter instance, optionally filtered by parent device/channel.
+     *
+     * @param parentDevice Name of the parent device to filter the states by
+     * @param parentChannel Name of the parent channel to filter the states by
+     * @param options Some internal options
+     */
+    getStatesOfAsync(parentDevice: string, parentChannel: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<ioBroker.StateObject[]>;
 }
 /**
  * Contents of iobroker.json plus some internal variables
@@ -304,14 +573,10 @@ export declare class AdapterClass extends EventEmitter {
     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;
     adapterReady: boolean;
-    /** Callbacks from sendTo */
-    private readonly messageCallbacks;
     /**
      * Contains a live cache of the adapter's states.
      * NOTE: This is only defined if the adapter was initialized with the option states: true.
@@ -323,7 +588,6 @@ export declare class AdapterClass extends EventEmitter {
      */
     oObjects?: Record<string, ioBroker.Object | undefined>;
     private _stopInProgress;
-    private _callbackId;
     private _firstConnection;
     private readonly _timers;
     private readonly _intervals;
@@ -338,6 +602,8 @@ export declare class AdapterClass extends EventEmitter {
     namespace: `${string}.${number}`;
     name: string;
     private _systemSecret?;
+    /** Attributes of `encryptedNative`: their values in `this.config` are decrypted on start */
+    private _decryptedNativeAttributes;
     /** Whether the adapter has already terminated */
     private terminated;
     /** The cache of usernames */
@@ -350,8 +616,6 @@ export declare class AdapterClass extends EventEmitter {
     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?;
@@ -372,7 +636,7 @@ export declare class AdapterClass extends EventEmitter {
     /** contents of iobroker.json if required via AdapterOptions */
     systemConfig?: InternalAdapterJsonConfig;
     /** the configured date format of system.config, only available if requested via AdapterOptions `useFormatDate` */
-    dateFormat?: any;
+    dateFormat?: string;
     /** if float comma instead of dot is used, only available if requested via AdapterOptions `useFormatDate` */
     isFloatComma?: boolean;
     /** configured language of system.config, only available if requested via AdapterOptions `useFormatDate` */
@@ -382,11 +646,9 @@ export declare class AdapterClass extends EventEmitter {
     /** latitude configured in system.config, only available if requested via AdapterOptions `useFormatDate`*/
     latitude?: number;
     private _defaultObjs?;
-    private _aliasObjectsSubscribed?;
     config: ioBroker.AdapterConfig;
     host?: string;
     common?: ioBroker.InstanceCommon;
-    private mboxSubscribed?;
     /** Stop the adapter */
     stop?: (params?: StopParameters) => Promise<void>;
     version?: string;
@@ -401,7 +663,9 @@ export declare class AdapterClass extends EventEmitter {
      * @param isActive - if log subscription should be activated or deactivated
      * @param options - options passed to setState e.g. user permissions
      */
-    requireLog?: (isActive: boolean, options?: Partial<GetUserGroupsOptions>) => Promise<void> | void;
+    requireLog?: (isActive: boolean, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null) => Promise<void> | void;
     private logOffTimer?;
     private logRequired?;
     private patterns?;
@@ -414,6 +678,9 @@ export declare class AdapterClass extends EventEmitter {
     private readonly SUPPORTED_FEATURES;
     /** Controller for messaging related functionality */
     private readonly uiMessagingController;
+    /**
+     * @param options Adapter options, or the adapter name as a string
+     */
     constructor(options: AdapterOptions | string);
     /**
      * Get the adapter scoped package identifier of a node module
@@ -421,47 +688,209 @@ export declare class AdapterClass extends EventEmitter {
      * @param moduleName name of the node module
      */
     getAdapterScopedPackageIdentifier(moduleName: string): string;
+    /**
+     * Install specified npm module
+     *
+     * @param moduleName name of the node module
+     * @param options install options including the version
+     */
     installNodeModule(moduleName: string, options: InstallNodeModuleOptions): Promise<CommandResult>;
     private _installNodeModule;
     /**
      * List all additional installed node modules from this adapter
      */
     listInstalledNodeModules(): Promise<string[]>;
+    /**
+     * Uninstall specified npm module
+     *
+     * @param moduleName name of the node module
+     */
     uninstallNodeModule(moduleName: string): Promise<CommandResult>;
+    /**
+     * Import a node module which has been installed via `installNodeModule`
+     *
+     * @param moduleName name of the node module
+     * @returns the required node module
+     */
     importNodeModule(moduleName: string): Promise<unknown>;
+    /**
+     * Decrypt the password/value with given key
+     *
+     * @param secretVal to use for decrypt (or value if only one parameter is given)
+     * @param value value to decrypt (if secret is provided)
+     */
     decrypt(secretVal: string, value?: string): string;
+    /**
+     * Decrypt the password/value with the system secret
+     *
+     * @param value value to decrypt
+     */
     decrypt(value: string): string;
+    /**
+     * Encrypt the password/value with given key
+     *
+     * @param secretVal to use for encrypting (or value if only one parameter is given)
+     * @param value value to encrypt (if secret is provided)
+     */
     encrypt(secretVal: string, value?: string): string;
+    /**
+     * Encrypt the password/value with the system secret
+     *
+     * @param value value to encrypt
+     */
     encrypt(value: string): string;
+    /**
+     * Read a session from the states DB
+     *
+     * @param id the session id
+     * @param callback return result
+     */
     getSession(id: string, callback: ioBroker.GetSessionCallback): MaybePromise;
     private _getSession;
-    setSession(id: string, ttl: number, data: Record<string, any>, callback?: ioBroker.ErrorCallback): MaybePromise;
+    /**
+     * Store a session in the states DB
+     *
+     * @param id the session id
+     * @param ttl time to live in seconds
+     * @param data the session data to store
+     * @param callback return result
+     */
+    setSession(id: string, ttl: number, data: ioBroker.Session, callback?: ioBroker.ErrorCallback): MaybePromise;
     private _setSession;
+    /**
+     * Destroy a session in the states DB
+     *
+     * @param id the session id
+     * @param callback return result
+     */
     destroySession(id: string, callback?: ioBroker.ErrorCallback): MaybePromise;
     private _destroySession;
     private _getObjectsByArray;
+    /**
+     * Stops the execution of adapter, but does not disable it.
+     *
+     * @param exitCode optional exit code
+     */
     terminate(exitCode?: number): never;
+    /**
+     * Stops the execution of adapter, but does not disable it.
+     *
+     * @param reason optional reason for termination
+     * @param exitCode optional exit code
+     */
     terminate(reason?: string, exitCode?: number): never;
+    /**
+     * Helper function to find next free port
+     *
+     * @param port port to start searching from
+     * @param host host to bind to
+     * @param callback return result
+     */
     getPort(port: number, host?: string, callback?: (port: number) => void): void;
+    /**
+     * Helper function to find next free port
+     *
+     * @param port port to start searching from
+     * @param callback return result
+     */
     getPort(port: number, callback?: (port: number) => void): void;
     private _getPort;
+    /**
+     * Method to check for available Features for adapter development
+     *
+     * @param featureName the name of the feature to check
+     * @returns true/false if the feature is in the list of supported features
+     */
     supportsFeature(featureName: ioBroker.SupportedFeature): boolean;
-    checkPassword(user: string, pw: string, options: Record<string, any>, callback: CheckPasswordCallback): Promise<void>;
+    /**
+     * Validates user and password
+     *
+     * @param user user name as text
+     * @param pw password as text
+     * @param options optional user context
+     * @param callback return result
+     */
+    checkPassword(user: string, pw: string, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null | undefined, callback: CheckPasswordCallback): Promise<void>;
+    /**
+     * Validates user and password
+     *
+     * @param user user name as text
+     * @param pw password as text
+     * @param callback return result
+     */
     checkPassword(user: string, pw: string, callback: CheckPasswordCallback): Promise<void>;
     private _checkPassword;
     /**
      * This method updates the cached values in `this.usernames`
      */
     private _updateUsernameCache;
+    /**
+     * Return ID of given username
+     *
+     * @param username name of the user
+     */
     getUserID(username: string): Promise<string | undefined>;
     private _getUserID;
-    setPassword(user: string, pw: string, options: Record<string, any>, callback?: ioBroker.ErrorCallback): Promise<void>;
+    /**
+     * Sets the user's password
+     *
+     * @param user user name as text
+     * @param pw password as text
+     * @param options optional user context
+     * @param callback return result
+     */
+    setPassword(user: string, pw: string, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null | undefined, callback?: ioBroker.ErrorCallback): Promise<void>;
+    /**
+     * Sets the user's password
+     *
+     * @param user user name as text
+     * @param pw password as text
+     * @param callback return result
+     */
     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>;
+    /**
+     * Returns if user exists and is in the group
+     *
+     * @param user user name as text
+     * @param group group name
+     * @param options optional user context
+     * @param callback return result
+     */
+    checkGroup(user: string, group: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: CheckGroupCallback): Promise<void>;
+    /**
+     * Returns if user exists and is in the group
+     *
+     * @param user user name as text
+     * @param group group name
+     * @param callback return result
+     */
     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>;
+    /**
+     * Calculate the effective permissions of a user for the given commands
+     *
+     * @param user user name as text
+     * @param commandsPermissions the permission requirements of the commands
+     * @param options optional user context
+     * @param callback return result
+     */
+    calculatePermissions(user: string, commandsPermissions: CommandsPermissions, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: CalculatePermissionsCallback): Promise<void | ioBroker.PermissionSet>;
+    /**
+     * Calculate the effective permissions of a user for the given commands
+     *
+     * @param user user name as text
+     * @param commandsPermissions the permission requirements of the commands
+     * @param callback return result
+     */
     calculatePermissions(user: string, commandsPermissions: CommandsPermissions, callback?: CalculatePermissionsCallback): Promise<void | ioBroker.PermissionSet>;
     private _calculatePermissions;
     /**
@@ -471,19 +900,30 @@ export declare class AdapterClass extends EventEmitter {
      */
     private _stop;
     /**
-     * Reads the file certificate from a given path and adds a file watcher to restart adapter on cert changes
-     * if a cert is passed it is returned as it is
+     * Tears down the certificate watching installed by {@link getCertificatesAsync}: closes the file
+     * watchers, unsubscribes from `system.certificates`, and forgets the certificates handed out by the
+     * last call, so a later change no longer schedules a restart. Called on adapter stop.
+     */
+    private stopWatchingCertificates;
+    /**
+     * Get the certificates of the system.
      *
-     * @param cert cert or path to cert
+     * @param publicName name of the public certificate
+     * @param privateName name of the private key
+     * @param chainedName name of the chained certificate
+     * @param callback return result
      */
-    private _readFileCertificate;
     getCertificates(publicName?: string, privateName?: string, chainedName?: string, callback?: GetCertificatesCallback): void;
-    private _getCertificates;
     /**
      * Restarts an instance of the adapter.
      *
      */
     restart(): void;
+    /**
+     * Updates the adapter config with new values, merged with the existing config.
+     *
+     * @param newConfig the new configuration values to merge into the existing config
+     */
     updateConfig(newConfig: Record<string, any>): ioBroker.SetObjectPromise;
     private _updateConfig;
     /**
@@ -491,21 +931,94 @@ export declare class AdapterClass extends EventEmitter {
      *
      */
     disable(): ioBroker.SetObjectPromise;
+    /**
+     * Reads a parameter which is stored encrypted and returns its decrypted value.
+     *
+     * An attribute listed in `encryptedNative` is already decrypted in `this.config` when the adapter
+     * starts, and is returned as it is.
+     *
+     * @param attribute the config attribute to decrypt
+     * @param callback return result
+     */
     getEncryptedConfig(attribute: string, callback?: GetEncryptedConfigCallback): Promise<string | string[] | void>;
     private _getEncryptedConfig;
     /**
      * Get the system secret, after retrieved once it will be read from the cache
      */
     private getSystemSecret;
+    /**
+     * Same as setTimeout, but it clears the running timers during the unloading process
+     *
+     * @param cb timer callback
+     * @param timeout timeout in milliseconds
+     * @param args as many arguments as needed, which will be passed to setTimeout
+     * @returns timer id
+     */
     setTimeout<TCallback extends TimeoutCallback>(cb: TCallback, timeout: number, ...args: Parameters<TCallback>): ioBroker.Timeout | undefined;
+    /**
+     * Same as clearTimeout but it checks the running timers on unload
+     *
+     * @param timer the timer object
+     */
     clearTimeout(timer: ioBroker.Timeout | undefined): void;
+    /**
+     * Delays the fulfillment of the promise the amount of time.
+     *
+     * @param timeout timeout in milliseconds
+     * @returns promise when timeout is over
+     */
     delay(timeout: number): Promise<void>;
+    /**
+     * Same as setInterval, but it clears the running intervals during the unloading process
+     *
+     * @param cb interval callback
+     * @param timeout interval in milliseconds
+     * @param args as many arguments as needed, which will be passed to setInterval
+     * @returns interval id
+     */
     setInterval<TCallback extends TimeoutCallback>(cb: TCallback, timeout: number, ...args: Parameters<TCallback>): ioBroker.Interval | undefined;
+    /**
+     * Same as clearInterval but it checks the running intervals on unload
+     *
+     * @param interval interval object
+     */
     clearInterval(interval: ioBroker.Interval | undefined): void;
+    /**
+     * Creates or overwrites an object in objectDB.
+     *
+     * @param id object ID (without namespace)
+     * @param obj the object to write
+     */
     setObject(id: string, obj: ioBroker.SettableObject): Promise<ioBroker.NonNullCallbackReturnTypeOf<ioBroker.SetObjectCallback>>;
+    /**
+     * Creates or overwrites an object in objectDB.
+     *
+     * @param id object ID (without namespace)
+     * @param obj the object to write
+     * @param callback return result
+     */
     setObject(id: string, obj: ioBroker.SettableObject, callback: ioBroker.SetObjectCallback): void;
-    setObject(id: string, obj: ioBroker.SettableObject, options: unknown, callback: ioBroker.SetObjectCallback): void;
-    setObject(id: string, obj: ioBroker.SettableObject, options: unknown): Promise<ioBroker.NonNullCallbackReturnTypeOf<ioBroker.SetObjectCallback>>;
+    /**
+     * Creates or overwrites an object in objectDB.
+     *
+     * @param id object ID (without namespace)
+     * @param obj the object to write
+     * @param options optional user context
+     * @param callback return result
+     */
+    setObject(id: string, obj: ioBroker.SettableObject, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null | undefined, callback: ioBroker.SetObjectCallback): void;
+    /**
+     * Creates or overwrites an object in objectDB.
+     *
+     * @param id object ID (without namespace)
+     * @param obj the object to write
+     * @param options optional user context
+     */
+    setObject(id: string, obj: ioBroker.SettableObject, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<ioBroker.NonNullCallbackReturnTypeOf<ioBroker.SetObjectCallback>>;
     private _setObject;
     /**
      * Helper method for `set[Foreign]Object[NotExists]` that also sets the default value if one is configured
@@ -516,51 +1029,317 @@ export declare class AdapterClass extends EventEmitter {
      * @param callback optional callback
      */
     private _setObjectWithDefaultValue;
+    /**
+     * Get all states, channels and devices of this adapter.
+     *
+     * @param callback return result
+     */
     getAdapterObjects(callback: (objects: Record<string, ioBroker.AdapterScopedObject>) => void): Promise<Record<string, ioBroker.AdapterScopedObject> | void>;
     private _getAdapterObjects;
+    /**
+     * Extend some object and create it if it does not exist
+     *
+     * @param id object ID (without namespace)
+     * @param objPart the partial object to merge into the existing object
+     */
     extendObject(id: string, objPart: ioBroker.PartialObject): ioBroker.SetObjectPromise;
+    /**
+     * Extend some object and create it if it does not exist
+     *
+     * @param id object ID (without namespace)
+     * @param objPart the partial object to merge into the existing object
+     * @param callback return result
+     */
     extendObject(id: string, objPart: ioBroker.PartialObject, callback?: ioBroker.SetObjectCallback): void;
+    /**
+     * Extend some object and create it if it does not exist
+     *
+     * @param id object ID (without namespace)
+     * @param objPart the partial object to merge into the existing object
+     * @param options optional user context
+     */
     extendObject(id: string, objPart: ioBroker.PartialObject, options: ioBroker.ExtendObjectOptions): ioBroker.SetObjectPromise;
+    /**
+     * Extend some object and create it if it does not exist
+     *
+     * @param id object ID (without namespace)
+     * @param objPart the partial object to merge into the existing object
+     * @param options optional user context
+     * @param callback return result
+     */
     extendObject(id: string, objPart: ioBroker.PartialObject, options: ioBroker.ExtendObjectOptions, callback?: ioBroker.SetObjectCallback): void;
     private _extendObject;
+    /**
+     * Same as {@link AdapterClass.setObject}, but for any object.
+     *
+     * @param id object ID with namespace
+     * @param obj new object
+     */
     setForeignObject<T extends string>(id: T, obj: ioBroker.SettableObject<ioBroker.ObjectIdToObjectType<T, 'write'>>): Promise<ioBroker.NonNullCallbackReturnTypeOf<ioBroker.SetObjectCallback>>;
+    /**
+     * Same as {@link AdapterClass.setObject}, but for any object.
+     *
+     * @param id object ID with namespace
+     * @param obj new object
+     * @param callback return result
+     */
     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): Promise<ioBroker.NonNullCallbackReturnTypeOf<ioBroker.SetObjectCallback>>;
-    setForeignObject<T extends string>(id: T, obj: ioBroker.SettableObject<ioBroker.ObjectIdToObjectType<T, 'write'>>, options: unknown, callback?: ioBroker.SetObjectCallback): void | Promise<ioBroker.NonNullCallbackReturnTypeOf<ioBroker.SetObjectCallback>>;
+    /**
+     * Same as {@link AdapterClass.setObject}, but for any object.
+     *
+     * @param id object ID with namespace
+     * @param obj new object
+     * @param options optional user context
+     */
+    setForeignObject<T extends string>(id: T, obj: ioBroker.SettableObject<ioBroker.ObjectIdToObjectType<T, 'write'>>, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null | undefined): Promise<ioBroker.NonNullCallbackReturnTypeOf<ioBroker.SetObjectCallback>>;
+    /**
+     * Same as {@link AdapterClass.setObject}, but for any object.
+     *
+     * @param id object ID with namespace
+     * @param obj new object
+     * @param options optional user context
+     * @param callback return result
+     */
+    setForeignObject<T extends string>(id: T, obj: ioBroker.SettableObject<ioBroker.ObjectIdToObjectType<T, 'write'>>, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.SetObjectCallback): void | Promise<ioBroker.NonNullCallbackReturnTypeOf<ioBroker.SetObjectCallback>>;
     private _setForeignObject;
+    /**
+     * Extend any object and create it if it might not exist.
+     *
+     * @param id object ID with namespace
+     * @param objPart the partial object to merge into the existing object
+     */
     extendForeignObject<T extends string>(id: T, objPart: ioBroker.PartialObject<ioBroker.ObjectIdToObjectType<T, 'write'>>): Promise<ioBroker.CallbackReturnTypeOf<ioBroker.SetObjectCallback>>;
+    /**
+     * Extend any object and create it if it might not exist.
+     *
+     * @param id object ID with namespace
+     * @param objPart the partial object to merge into the existing object
+     * @param callback return result
+     */
     extendForeignObject<T extends string>(id: T, objPart: ioBroker.PartialObject<ioBroker.ObjectIdToObjectType<T, 'write'>>, callback: ioBroker.SetObjectCallback): void;
+    /**
+     * Extend any object and create it if it might not exist.
+     *
+     * @param id object ID with namespace
+     * @param objPart the partial object to merge into the existing object
+     * @param options optional user context
+     * @param callback return result
+     */
     extendForeignObject<T extends string>(id: T, objPart: ioBroker.PartialObject<ioBroker.ObjectIdToObjectType<T, 'write'>>, options: ioBroker.ExtendObjectOptions, callback: ioBroker.SetObjectCallback): void;
+    /**
+     * Extend any object and create it if it might not exist.
+     *
+     * @param id object ID with namespace
+     * @param objPart the partial object to merge into the existing object
+     * @param options optional user context
+     */
     extendForeignObject<T extends string>(id: T, objPart: ioBroker.PartialObject<ioBroker.ObjectIdToObjectType<T, 'write'>>, options: ioBroker.ExtendObjectOptions): Promise<ioBroker.CallbackReturnTypeOf<ioBroker.SetObjectCallback>>;
     private _extendForeignObjectAsync;
-    objectExists(id: string, options?: Record<string, any> | null): Promise<boolean | void>;
+    /**
+     * Checks if an object exists to the given id, id will be fixed first
+     *
+     * @param id id of the object
+     * @param options optional user context
+     */
+    objectExists(id: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null): Promise<boolean | void>;
+    /**
+     * Checks if an object exists to the given id
+     *
+     * @param id id of the object
+     * @param options optional user context
+     */
     foreignObjectExists(id: string, options?: Record<string, any> | null): Promise<boolean | void>;
+    /**
+     * Get object of this instance.
+     *
+     * @param id exactly object ID (without namespace)
+     * @param callback return result
+     */
     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<ioBroker.Object>): void;
-    getObjectList(params: ioBroker.GetObjectListParams | null, options: {
+    /**
+     * Get object of this instance.
+     *
+     * @param id exactly object ID (without namespace)
+     * @param options optional user context
+     * @param callback return result
+     */
+    getObject(id: string, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null | undefined, callback: ioBroker.GetObjectCallback): void;
+    /**
+     * Read object view from DB.
+     *
+     * @param design name of the design
+     * @param search name of the view
+     * @param params object containing startkey: first id to include in result; endkey: last id to include in result
+     * @param callback return result
+     */
+    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;
+    /**
+     * Read object view from DB.
+     *
+     * @param design name of the design
+     * @param search name of the view
+     * @param params object containing startkey: first id to include in result; endkey: last id to include in result
+     * @param options additional options, e.g. for permissions
+     * @param callback return result
+     */
+    getObjectView<Design extends string = string, Search extends string = string>(design: Design, search: Search, params: ioBroker.GetObjectViewParams | null | undefined, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null | undefined, callback: ioBroker.GetObjectViewCallback<ioBroker.InferGetObjectViewItemType<Design, Search>>): void;
+    private _getObjectView;
+    /**
+     * Read object list from DB.
+     *
+     * @param params startkey and endkey information
+     * @param callback optional callback
+     */
+    getObjectList(params: ioBroker.GetObjectListParams | null, callback: ioBroker.GetObjectListCallback<ioBroker.Object>): void;
+    /**
+     * Read object list from DB.
+     *
+     * @param params startkey and endkey information
+     * @param options additional options, e.g. for permissions
+     * @param callback optional callback
+     */
+    getObjectList(params: ioBroker.GetObjectListParams | null, options: {
         sorted?: boolean;
-    } | Record<string, any>, callback: ioBroker.GetObjectListCallback<ioBroker.Object>): void;
+        user?: ioBroker.ObjectIDs.User;
+    }, callback: ioBroker.GetObjectListCallback<ioBroker.Object>): void;
+    /**
+     * Get the enum tree.
+     *
+     * @param callback return result
+     */
     getEnum(callback: ioBroker.GetEnumCallback): void;
+    /**
+     * Get the enum tree.
+     *
+     * @param name the enum name to read
+     * @param callback return result
+     */
     getEnum(name: string, callback: ioBroker.GetEnumCallback): void;
-    getEnum(name: string, options: unknown, callback: ioBroker.GetEnumCallback): void;
+    /**
+     * Get the enum tree.
+     *
+     * @param name the enum name to read
+     * @param options optional user context
+     * @param callback return result
+     */
+    getEnum(name: string, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null | undefined, callback: ioBroker.GetEnumCallback): void;
     private _getEnum;
+    /**
+     * Read the members of given enums.
+     *
+     * @param callback return result
+     */
     getEnums(callback: ioBroker.GetEnumsCallback): void;
+    /**
+     * Read the members of given enums.
+     *
+     * @param enumList the enum(s) to read
+     * @param callback return result
+     */
     getEnums(enumList: ioBroker.EnumList, callback: ioBroker.GetEnumsCallback): void;
-    getEnums(enumList: ioBroker.EnumList, options: unknown, callback: ioBroker.GetEnumsCallback): void;
+    /**
+     * Read the members of given enums.
+     *
+     * @param enumList the enum(s) to read
+     * @param options optional user context
+     * @param callback return result
+     */
+    getEnums(enumList: ioBroker.EnumList, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null | undefined, callback: ioBroker.GetEnumsCallback): void;
     private _getEnums;
+    /**
+     * Get all objects matching the given pattern.
+     *
+     * @param patter the pattern to match object ids against
+     */
     getForeignObjects(patter: Pattern): Promise<ioBroker.NonNullCallbackReturnTypeOf<ioBroker.GetObjectsCallback>>;
+    /**
+     * Get all objects matching the given pattern.
+     *
+     * @param pattern the pattern to match object ids against
+     * @param callback return result
+     */
     getForeignObjects(pattern: Pattern, callback: ioBroker.GetObjectsCallback): void;
-    getForeignObjects(pattern: Pattern, options: unknown, callback: ioBroker.GetObjectsCallback): void;
+    /**
+     * Get all objects matching the given pattern.
+     *
+     * @param pattern the pattern to match object ids against
+     * @param options optional user context
+     * @param callback return result
+     */
+    getForeignObjects(pattern: Pattern, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null | undefined, callback: ioBroker.GetObjectsCallback): void;
+    /**
+     * Get all objects of the given type matching the given pattern.
+     *
+     * @param pattern the pattern to match object ids against
+     * @param type restrict the result to objects of this type
+     * @param callback return result
+     */
     getForeignObjects<T extends ioBroker.ObjectType>(pattern: Pattern, type: T, callback: ioBroker.GetObjectsCallbackTyped<T>): void;
+    /**
+     * Get all objects of the given type matching the given pattern.
+     *
+     * @param pattern the pattern to match object ids against
+     * @param type restrict the result to objects of this type
+     * @param enums restrict the result to objects within these enums
+     * @param callback return result
+     */
     getForeignObjects<T extends ioBroker.ObjectType>(pattern: Pattern, type: T, enums: ioBroker.EnumList, callback: ioBroker.GetObjectsCallbackTyped<T>): void;
-    getForeignObjects<T extends ioBroker.ObjectType>(pattern: Pattern, type: T, options: unknown, callback: ioBroker.GetObjectsCallbackTyped<T>): void;
-    getForeignObjects<T extends ioBroker.ObjectType>(pattern: Pattern, type: T, enums: ioBroker.EnumList | null, options: unknown, callback: ioBroker.GetObjectsCallbackTyped<T>): void;
+    /**
+     * Get all objects of the given type matching the given pattern.
+     *
+     * @param pattern the pattern to match object ids against
+     * @param type restrict the result to objects of this type
+     * @param options optional user context
+     * @param callback return result
+     */
+    getForeignObjects<T extends ioBroker.ObjectType>(pattern: Pattern, type: T, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null | undefined, callback: ioBroker.GetObjectsCallbackTyped<T>): void;
+    /**
+     * Get all objects of the given type matching the given pattern.
+     *
+     * @param pattern the pattern to match object ids against
+     * @param type restrict the result to objects of this type
+     * @param enums restrict the result to objects within these enums
+     * @param options optional user context
+     * @param callback return result
+     */
+    getForeignObjects<T extends ioBroker.ObjectType>(pattern: Pattern, type: T, enums: ioBroker.EnumList | null, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null | undefined, callback: ioBroker.GetObjectsCallbackTyped<T>): void;
     private _getForeignObjects;
+    /**
+     * Find any object by name or ID.
+     *
+     * @param idOrName exactly object ID or name (without namespace)
+     * @param type optional `common.type` of state: 'number', 'string', 'boolean', 'file', ...
+     * @param callback return result
+     */
     findForeignObject(idOrName: string, type: ioBroker.CommonType | null, callback: ioBroker.FindObjectCallback): void;
+    /**
+     * Find any object by name or ID.
+     *
+     * @param idOrName exactly object ID or name (without namespace)
+     * @param type optional `common.type` of state: 'number', 'string', 'boolean', 'file', ...
+     * @param options optional user context
+     * @param callback return result
+     */
     findForeignObject(idOrName: string, type: ioBroker.CommonType | null, options: {
         user?: `system.user.${string}`;
         language?: ioBroker.Languages;
@@ -577,7 +1356,7 @@ export declare class AdapterClass extends EventEmitter {
      * @param options optional user context with language
      * @param options.user current user
      * @param options.language language in which the search must be done for multi-language names
-     * @result if the object was found by ID it will return id and may be the multi-language name it exists. If the object was found by name it will return id and the multi-language name. If the object was not found, it will return only name that was searched for.
+     * @returns if the object was found by ID it will return id and may be the multi-language name it exists. If the object was found by name it will return id and the multi-language name. If the object was not found, it will return only name that was searched for.
      */
     findForeignObjectAsync(id: string, type: ioBroker.CommonType | null, options?: {
         user?: `system.user.${string}`;
@@ -586,30 +1365,185 @@ export declare class AdapterClass extends EventEmitter {
         id?: string;
         name: ioBroker.StringOrTranslated;
     }>;
-    getForeignObject<T extends string>(id: T, callback: ioBroker.GetObjectCallback<T>): void | Promise<void | ioBroker.ObjectIdToObjectType<T> | null>;
-    getForeignObject<T extends string>(id: T, options: unknown, callback: ioBroker.GetObjectCallback<T>): void | Promise<void | ioBroker.ObjectIdToObjectType<T> | null>;
+    /**
+     * Get any object.
+     *
+     * @param id exactly object ID (with namespace)
+     * @param callback return result
+     */
+    getForeignObject<T extends string>(id: T, callback: ioBroker.GetObjectCallback<T>): void;
+    /**
+     * Get any object.
+     *
+     * @param id exactly object ID (with namespace)
+     * @param options optional user context
+     * @param callback return result
+     */
+    getForeignObject<T extends string>(id: T, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null | undefined, callback: ioBroker.GetObjectCallback<T>): void;
     private _getForeignObject;
+    /**
+     * Delete an object of this instance.
+     *
+     * @param id exactly object ID (without namespace)
+     * @param callback return result
+     */
     delObject(id: string, callback?: ioBroker.ErrorCallback): void;
+    /**
+     * Delete an object of this instance.
+     *
+     * @param id exactly object ID (without namespace)
+     * @param options optional user context. E.g. recursive option could be true
+     * @param callback return result
+     */
     delObject(id: string, options?: ioBroker.DelObjectOptions | null, callback?: ioBroker.ErrorCallback): void;
     private _deleteObjects;
+    /**
+     * Delete any object.
+     *
+     * @param id exactly object ID (with namespace)
+     * @param callback return result
+     */
     delForeignObject(id: string, callback?: ioBroker.ErrorCallback): void;
+    /**
+     * Delete any object.
+     *
+     * @param id exactly object ID (with namespace)
+     * @param options optional user context or `{ recursive: true }` to delete all underlying objects
+     * @param callback return result
+     */
     delForeignObject(id: string, options: ioBroker.DelObjectOptions, callback?: ioBroker.ErrorCallback): void;
     private _delForeignObject;
+    /**
+     * Subscribe for the changes of objects in this instance.
+     *
+     * @param pattern pattern like 'channel.*' or '*' (all objects of this adapter) - without namespaces
+     * @param callback optional returns result
+     */
     subscribeObjects(pattern: Pattern, callback?: ioBroker.ErrorCallback): void;
-    subscribeObjects(pattern: Pattern, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    /**
+     * Subscribe for the changes of objects in this instance.
+     *
+     * @param pattern pattern like 'channel.*' or '*' (all objects of this adapter) - without namespaces
+     * @param options optional user context
+     * @param callback optional returns result
+     */
+    subscribeObjects(pattern: Pattern, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.ErrorCallback): void;
+    /**
+     * Unsubscribe on the changes of objects in this instance.
+     *
+     * @param pattern pattern like 'channel.*' or '*' (all objects) - without namespaces
+     * @param callback optional returns result
+     */
     unsubscribeObjects(pattern: Pattern, callback?: ioBroker.ErrorCallback): void;
-    unsubscribeObjects(pattern: Pattern, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    /**
+     * Unsubscribe on the changes of objects in this instance.
+     *
+     * @param pattern pattern like 'channel.*' or '*' (all objects) - without namespaces
+     * @param options optional user context
+     * @param callback optional returns result
+     */
+    unsubscribeObjects(pattern: Pattern, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.ErrorCallback): void;
+    /**
+     * Subscribe for the changes of objects in any instance.
+     *
+     * @param pattern pattern like 'channel.*' or '*' (all objects) - without namespaces. You can use array of patterns
+     * @param callback optional returns result
+     */
     subscribeForeignObjects(pattern: string | string[], callback?: ioBroker.ErrorCallback): void;
-    subscribeForeignObjects(pattern: string | string[], options: unknown, callback?: ioBroker.ErrorCallback): void;
+    /**
+     * Subscribe for the changes of objects in any instance.
+     *
+     * @param pattern pattern like 'channel.*' or '*' (all objects) - without namespaces. You can use array of patterns
+     * @param options optional user context
+     * @param callback optional returns result
+     */
+    subscribeForeignObjects(pattern: string | string[], options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.ErrorCallback): void;
+    /**
+     * Unsubscribe for the patterns on all objects.
+     *
+     * @param pattern pattern like 'channel.*' or '*' (all objects) - without namespaces
+     * @param callback optional returns result
+     */
     unsubscribeForeignObjects(pattern: string | string[], callback?: ioBroker.ErrorCallback): void;
-    unsubscribeForeignObjects(pattern: string | string[], options: unknown, callback?: ioBroker.ErrorCallback): void;
+    /**
+     * Unsubscribe for the patterns on all objects.
+     *
+     * @param pattern pattern like 'channel.*' or '*' (all objects) - without namespaces
+     * @param options optional user context
+     * @param callback optional returns result
+     */
+    unsubscribeForeignObjects(pattern: string | string[], options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.ErrorCallback): void;
+    /**
+     * Subscribe for the changes of files in specific instance.
+     *
+     * @param id adapter ID like 'vis-2.0' or 'vis-2.admin'
+     * @param pattern pattern like 'channel.*' or '*' (all files) - without namespaces. You can use array of patterns
+     * @param options optional user context
+     */
     subscribeForeignFiles(id: string, pattern: string | string[], options?: unknown): Promise<void>;
+    /**
+     * Unsubscribe for the changes of files on specific instance.
+     *
+     * @param id adapter ID like 'vis-2.0' or 'vis-2.admin'
+     * @param pattern pattern like 'channel.*' or '*' (all objects) - without namespaces
+     * @param options optional user context
+     */
     unsubscribeForeignFiles(id: string, pattern: string | string[], options?: unknown): Promise<void>;
+    /**
+     * Same as {@link AdapterClass.setObject}, but with check if the object exists.
+     *
+     * @param id object ID, that must be overwritten or created.
+     * @param obj new object
+     * @param callback return result
+     */
     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;
+    /**
+     * Same as {@link AdapterClass.setObject}, but with check if the object exists.
+     *
+     * @param id object ID, that must be overwritten or created.
+     * @param obj new object
+     * @param options optional user context
+     * @param callback return result
+     */
+    setObjectNotExists(id: string, obj: ioBroker.SettableObject, options?: {
+        user?: ioBroker.ObjectIDs.User;
+        preserve?: {
+            [key: string]: boolean;
+        };
+    } | null, callback?: ioBroker.SetObjectCallback): Promise<void | ioBroker.CallbackReturnTypeOf<ioBroker.SetObjectCallback>> | void;
     private _setObjectNotExists;
+    /**
+     * Same as {@link AdapterClass.setForeignObject}, but with check if the object exists.
+     *
+     * @param id object ID, that must be overwritten or created.
+     * @param obj new object
+     * @param callback return result
+     */
     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;
+    /**
+     * Same as {@link AdapterClass.setForeignObject}, but with check if the object exists.
+     *
+     * @param id object ID, that must be overwritten or created.
+     * @param obj new object
+     * @param options optional user context
+     * @param callback return result
+     */
+    setForeignObjectNotExists<T extends string>(id: T, obj: ioBroker.SettableObject<ioBroker.ObjectIdToObjectType<T, 'write'>>, options?: {
+        user?: ioBroker.ObjectIDs.User;
+        preserve?: {
+            [key: string]: boolean;
+        };
+    } | null, callback?: ioBroker.SetObjectCallback): void;
     private _setForeignObjectNotExists;
     private _DCS2ID;
     /** @deprecated use `this.extendObject` instead */
@@ -619,7 +1553,9 @@ export declare class AdapterClass extends EventEmitter {
     /** @deprecated use `this.extendObject` instead */
     createDevice(deviceName: string, common: Partial<ioBroker.DeviceCommon>, native: Record<string, any>, callback?: ioBroker.SetObjectCallback): void;
     /** @deprecated use `this.extendObject` instead */
-    createDevice(deviceName: string, common: Partial<ioBroker.DeviceCommon>, native: Record<string, any>, options: unknown, callback?: ioBroker.SetObjectCallback): void;
+    createDevice(deviceName: string, common: Partial<ioBroker.DeviceCommon>, native: Record<string, any>, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.SetObjectCallback): void;
     private _createDevice;
     /** @deprecated use `this.extendObject` instead */
     createChannel(parentDevice: string, channelName: string, callback?: ioBroker.SetObjectCallback): void;
@@ -628,7 +1564,9 @@ export declare class AdapterClass extends EventEmitter {
     /** @deprecated use `this.extendObject` instead */
     createChannel(parentDevice: string, channelName: string, roleOrCommon: string | Partial<ioBroker.ChannelCommon>, native: Record<string, any>, callback?: ioBroker.SetObjectCallback): void;
     /** @deprecated use `this.extendObject` instead */
-    createChannel(parentDevice: string, channelName: string, roleOrCommon: string | Partial<ioBroker.ChannelCommon>, native: Record<string, any>, options: unknown, callback?: ioBroker.SetObjectCallback): void;
+    createChannel(parentDevice: string, channelName: string, roleOrCommon: string | Partial<ioBroker.ChannelCommon>, native: Record<string, any>, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.SetObjectCallback): void;
     /** @deprecated use `this.extendObject` instead */
     createState(parentDevice: string, parentChannel: string, stateName: string, callback?: ioBroker.SetObjectCallback): void;
     /** @deprecated use `this.extendObject` instead */
@@ -636,18 +1574,62 @@ export declare class AdapterClass extends EventEmitter {
     /** @deprecated use `this.extendObject` instead */
     createState(parentDevice: string, parentChannel: string, stateName: string, roleOrCommon: string | Partial<ioBroker.StateCommon>, native: Record<string, any>, callback?: ioBroker.SetObjectCallback): void;
     /** @deprecated use `this.extendObject` instead */
-    createState(parentDevice: string, parentChannel: string, stateName: string, roleOrCommon: string | Partial<ioBroker.StateCommon>, native: Record<string, any>, options: unknown, callback?: ioBroker.SetObjectCallback): void;
+    createState(parentDevice: string, parentChannel: string, stateName: string, roleOrCommon: string | Partial<ioBroker.StateCommon>, native: Record<string, any>, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.SetObjectCallback): void;
     private _createState;
     /** @deprecated use `this.delObject` instead */
     deleteDevice(deviceName: string, callback?: ioBroker.ErrorCallback): void;
     /** @deprecated use `this.delObject` instead */
-    deleteDevice(deviceName: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    deleteDevice(deviceName: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.ErrorCallback): void;
     private _deleteDevice;
+    /**
+     * Add a channel to an enum.
+     *
+     * @param enumName the enum category (e.g. rooms, functions)
+     * @param addTo the enum id to add the channel to
+     * @param parentDevice the parent device name
+     * @param channelName the name of the channel
+     * @param callback return result
+     */
     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;
+    /**
+     * Add a channel to an enum.
+     *
+     * @param enumName the enum category (e.g. rooms, functions)
+     * @param addTo the enum id to add the channel to
+     * @param parentDevice the parent device name
+     * @param channelName the name of the channel
+     * @param options optional user context
+     * @param callback return result
+     */
+    addChannelToEnum(enumName: string, addTo: string, parentDevice: string, channelName: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.ErrorCallback): void;
     private _addChannelToEnum;
+    /**
+     * Remove a channel from an enum.
+     *
+     * @param enumName the enum category (e.g. rooms, functions)
+     * @param parentDevice the parent device name
+     * @param channelName the name of the channel
+     * @param callback return result
+     */
     deleteChannelFromEnum(enumName: string, parentDevice: string, channelName: string, callback?: ioBroker.ErrorCallback): void;
-    deleteChannelFromEnum(enumName: string, parentDevice: string, channelName: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    /**
+     * Remove a channel from an enum.
+     *
+     * @param enumName the enum category (e.g. rooms, functions)
+     * @param parentDevice the parent device name
+     * @param channelName the name of the channel
+     * @param options optional user context
+     * @param callback return result
+     */
+    deleteChannelFromEnum(enumName: string, parentDevice: string, channelName: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.ErrorCallback): void;
     private _deleteChannelFromEnum;
     /** @deprecated use `this.delObject` instead */
     deleteChannel(channelName: string, callback?: ioBroker.ErrorCallback): void;
@@ -663,103 +1645,685 @@ export declare class AdapterClass extends EventEmitter {
     /** @deprecated use `this.delObject` instead */
     deleteState(parentDevice: string | null, parentChannel: string | null, stateName: string, options?: unknown, callback?: ioBroker.ErrorCallback): void;
     private _deleteState;
+    /**
+     * Get all devices of this adapter.
+     *
+     * @param callback return result
+     */
     getDevices(callback: ioBroker.GetObjectsCallback3<ioBroker.DeviceObject>): void;
-    getDevices(options: unknown, callback: ioBroker.GetObjectsCallback3<ioBroker.DeviceObject>): void;
+    /**
+     * Get all devices of this adapter.
+     *
+     * @param options optional user context
+     * @param callback return result
+     */
+    getDevices(options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback: ioBroker.GetObjectsCallback3<ioBroker.DeviceObject>): void;
     private _getDevices;
+    /**
+     * Get all channels of this adapter or of the given device.
+     *
+     * @param callback return result
+     */
     getChannelsOf(callback: ioBroker.GetObjectsCallback3<ioBroker.ChannelObject>): void;
+    /**
+     * Get all channels of this adapter or of the given device.
+     *
+     * @param parentDevice the parent device name
+     * @param callback return result
+     */
     getChannelsOf(parentDevice: string, callback: ioBroker.GetObjectsCallback3<ioBroker.ChannelObject>): void;
-    getChannelsOf(parentDevice: string, options: unknown, callback: ioBroker.GetObjectsCallback3<ioBroker.ChannelObject>): void;
+    /**
+     * Get all channels of this adapter or of the given device.
+     *
+     * @param parentDevice the parent device name
+     * @param options optional user context
+     * @param callback return result
+     */
+    getChannelsOf(parentDevice: string, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback: ioBroker.GetObjectsCallback3<ioBroker.ChannelObject>): void;
     private _getChannelsOf;
+    /**
+     * Get all states of this adapter or of the given device/channel.
+     *
+     * @param callback return result
+     */
     getStatesOf(callback: ioBroker.GetObjectsCallback3<ioBroker.StateObject>): void;
+    /**
+     * Get all states of this adapter or of the given device/channel.
+     *
+     * @param parentDevice the parent device name
+     * @param callback return result
+     */
     getStatesOf(parentDevice: string, callback: ioBroker.GetObjectsCallback3<ioBroker.StateObject>): void;
+    /**
+     * Get all states of this adapter or of the given device/channel.
+     *
+     * @param parentDevice the parent device name
+     * @param parentChannel the parent channel name
+     * @param callback return result
+     */
     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;
+    /**
+     * Get all states of this adapter or of the given device/channel.
+     *
+     * @param parentDevice the parent device name
+     * @param parentChannel the parent channel name
+     * @param options optional user context
+     * @param callback return result
+     */
+    getStatesOf(parentDevice: string | null | undefined, parentChannel: string | null | undefined, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback: ioBroker.GetObjectsCallback3<ioBroker.StateObject>): void;
     private _getStatesOf;
+    /**
+     * Add a state to an enum.
+     *
+     * @param enumName the enum category (e.g. rooms, functions)
+     * @param addTo the enum id to add the state to
+     * @param parentDevice the parent device name
+     * @param parentChannel the parent channel name
+     * @param stateName the name of the state
+     * @param callback return result
+     */
     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;
+    /**
+     * Add a state to an enum.
+     *
+     * @param enumName the enum category (e.g. rooms, functions)
+     * @param addTo the enum id to add the state to
+     * @param parentDevice the parent device name
+     * @param parentChannel the parent channel name
+     * @param stateName the name of the state
+     * @param options optional user context
+     * @param callback return result
+     */
+    addStateToEnum(enumName: string, addTo: string, parentDevice: string, parentChannel: string, stateName: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.ErrorCallback): void;
     private _addStateToEnum;
+    /**
+     * Remove a state from an enum.
+     *
+     * @param enumName the enum category (e.g. rooms, functions)
+     * @param parentDevice the parent device name
+     * @param parentChannel the parent channel name
+     * @param stateName the name of the state
+     * @param callback return result
+     */
     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;
+    /**
+     * Remove a state from an enum.
+     *
+     * @param enumName the enum category (e.g. rooms, functions)
+     * @param parentDevice the parent device name
+     * @param parentChannel the parent channel name
+     * @param stateName the name of the state
+     * @param options optional user context
+     * @param callback return result
+     */
+    deleteStateFromEnum(enumName: string, parentDevice: string, parentChannel: string, stateName: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.ErrorCallback): void;
     private _deleteStateFromEnum;
+    /**
+     * Change file access rights
+     *
+     * @param adapter adapter name, or null for the current adapter
+     * @param path path to file without adapter name
+     * @param options data with mode
+     * @param callback return result
+     */
     chmodFile(adapter: string | null, path: string, options: {
         mode: number | string;
-    } | Record<string, any>, callback: ioBroker.ChownFileCallback): void;
+        user?: ioBroker.ObjectIDs.User;
+    }, callback: ioBroker.ChownFileCallback): void;
+    /**
+     * Change file access rights
+     *
+     * @param adapter adapter name, or null for the current adapter
+     * @param path path to file without adapter name
+     * @param callback return result
+     */
     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;
+    /**
+     * Change a file owner
+     *
+     * @param _adapter adapter name, or null for the current adapter
+     * @param path path to file without adapter name
+     * @param options data with owner and ownerGroup
+     * @param callback return result
+     */
+    chownFile(_adapter: string, path: string, options: {
+        owner: ioBroker.ObjectIDs.User;
+        user?: ioBroker.ObjectIDs.User;
+        ownerGroup?: ioBroker.ObjectIDs.Group;
+        group?: ioBroker.ObjectIDs.Group;
+    }, callback: (err?: Error | null, processedFiles?: ioBroker.ChownFileResult[]) => void): void;
+    /**
+     * Change a file owner
+     *
+     * @param _adapter adapter name, or null for the current adapter
+     * @param path path to file without adapter name
+     * @param callback return result
+     */
+    chownFile(_adapter: string, path: string, callback: (err?: Error | null, processedFiles?: ioBroker.ChownFileResult[]) => void): void;
+    /**
+     * Read directory from DB.
+     *
+     * @param adapterName adapter name, or null for the current adapter
+     * @param path path to the directory
+     * @param callback return result
+     */
     readDir(adapterName: string | null, path: string, callback: ioBroker.ReadDirCallback): void;
-    readDir(adapterName: string | null, path: string, options: unknown, callback: ioBroker.ReadDirCallback): void;
+    /**
+     * Read directory from DB.
+     *
+     * @param adapterName adapter name, or null for the current adapter
+     * @param path path to the directory
+     * @param options optional user context
+     * @param callback return result
+     */
+    readDir(adapterName: string | null, path: string, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback: ioBroker.ReadDirCallback): void;
+    /**
+     * Deletes a file in the DB.
+     *
+     * @param adapterName adapter name, or null for the current adapter
+     * @param path path to the file
+     * @param callback return result
+     */
     unlink(adapterName: string | null, path: string, callback: ioBroker.ErrnoCallback): void;
-    unlink(adapterName: string | null, path: string, options: unknown, callback: ioBroker.ErrnoCallback): void;
+    /**
+     * Deletes a file in the DB.
+     *
+     * @param adapterName adapter name, or null for the current adapter
+     * @param path path to the file
+     * @param options optional user context
+     * @param callback return result
+     */
+    unlink(adapterName: string | null, path: string, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback: ioBroker.ErrnoCallback): void;
+    /**
+     * Renames a file in the DB.
+     *
+     * @param adapterName adapter name, or null for the current adapter
+     * @param oldName current path to the file
+     * @param newName new path to the file
+     * @param callback return result
+     */
     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;
+    /**
+     * Renames a file in the DB.
+     *
+     * @param adapterName adapter name, or null for the current adapter
+     * @param oldName current path to the file
+     * @param newName new path to the file
+     * @param options optional user context
+     * @param callback return result
+     */
+    rename(adapterName: string | null, oldName: string, newName: string, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback: ioBroker.ErrnoCallback): void;
+    /**
+     * Creates a directory in the DB.
+     *
+     * @param adapterName adapter name, or null for the current adapter
+     * @param path path to the directory
+     * @param callback return result
+     */
     mkdir(adapterName: string | null, path: string, callback: ioBroker.ErrnoCallback): void;
-    mkdir(adapterName: string | null, path: string, options: unknown, callback: ioBroker.ErrnoCallback): void;
+    /**
+     * Creates a directory in the DB.
+     *
+     * @param adapterName adapter name, or null for the current adapter
+     * @param path path to the directory
+     * @param options optional user context
+     * @param callback return result
+     */
+    mkdir(adapterName: string | null, path: string, options: {
+        user?: ioBroker.ObjectIDs.User;
+        owner?: ioBroker.ObjectIDs.User;
+        ownerGroup?: ioBroker.ObjectIDs.Group;
+    }, callback: ioBroker.ErrnoCallback): void;
+    /**
+     * Read file from DB.
+     *
+     * @param adapterName adapter name, or null for the current adapter
+     * @param path path to file without adapter name
+     * @param callback return result
+     */
     readFile(adapterName: string | null, path: string, callback: ioBroker.ReadFileCallback): void;
-    readFile(adapterName: string | null, path: string, options: unknown, callback: ioBroker.ReadFileCallback): void;
+    /**
+     * Read file from DB.
+     *
+     * @param adapterName adapter name, or null for the current adapter
+     * @param path path to file without adapter name
+     * @param options optional user context
+     * @param callback return result
+     */
+    readFile(adapterName: string | null, path: string, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback: ioBroker.ReadFileCallback): void;
+    /**
+     * Write file to DB.
+     *
+     * @param adapterName adapter name, or null for the current adapter
+     * @param path path to the file
+     * @param data data to write
+     * @param callback return result
+     */
     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;
+    /**
+     * Write file to DB.
+     *
+     * @param adapterName adapter name, or null for the current adapter
+     * @param path path to the file
+     * @param data data to write
+     * @param options optional user context
+     * @param callback return result
+     */
+    writeFile(adapterName: string | null, path: string, data: Buffer | string, options: {
+        virtualFile?: boolean;
+        user?: ioBroker.ObjectIDs.User;
+        group?: ioBroker.ObjectIDs.Group;
+        mode?: number;
+        mimeType?: string;
+    } | null, callback: ioBroker.ErrnoCallback): void;
+    /**
+     * Checks if file exists in DB.
+     *
+     * @param adapterName adapter name
+     * @param path path to file without adapter name
+     */
     fileExists(adapterName: string | null, path: string): Promise<boolean>;
+    /**
+     * Checks if file exists in DB.
+     *
+     * @param adapterName adapter name
+     * @param path path to file without adapter name
+     * @param callback cb function if none provided, a promise is returned
+     */
     fileExists(adapterName: string | null, path: string, callback?: ioBroker.GenericCallback<boolean>): void;
-    fileExists(adapterName: string | null, path: string, options: unknown, callback: ioBroker.GenericCallback<boolean>): void;
+    /**
+     * Checks if file exists in DB.
+     *
+     * @param adapterName adapter name
+     * @param path path to file without adapter name
+     * @param options optional user context
+     * @param callback cb function if none provided, a promise is returned
+     */
+    fileExists(adapterName: string | null, path: string, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback: ioBroker.GenericCallback<boolean>): void;
+    /**
+     * Formats a numeric value using the given format string.
+     *
+     * @param value the value to format
+     * @param format optional format string for the decimal and thousands separator
+     */
     formatValue(value: number | string, format?: string): string;
+    /**
+     * Formats a numeric value using the given format string.
+     *
+     * @param value the value to format
+     * @param decimals number of decimals to keep
+     * @param format optional format string for the decimal and thousands separator
+     */
     formatValue(value: number | string, decimals: number, format?: string): string;
+    /**
+     * Formats a date according to the given format string.
+     *
+     * @param dateObj the date to format
+     * @param format optional format string
+     */
     formatDate(dateObj: string | Date | number, format?: string): string;
+    /**
+     * Formats a date or duration according to the given format string.
+     *
+     * @param dateObj the date to format
+     * @param isDuration whether the value represents a duration
+     * @param format optional format string
+     */
     formatDate(dateObj: string | Date | number, isDuration: boolean | string, format?: string): string;
     private _formatDate;
+    /**
+     * Send a message to a specific instance or all instances of some specific adapter.
+     *
+     * @param instanceName name of the instance to send the message to
+     * @param message message to send
+     * @param callback optional return result
+     */
     sendTo(instanceName: string, message: any, callback?: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo): void;
+    /**
+     * Send a message to a specific instance or all instances of some specific adapter.
+     *
+     * @param instanceName name of the instance to send the message to
+     * @param command command name
+     * @param message message to send
+     * @param callback optional return result
+     * @param options optional options to control the send behaviour
+     */
     sendTo(instanceName: string, command: string, message: any, callback?: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo, options?: SendToOptions): void;
-    private _sendTo;
+    /**
+     * Send a message to a specific host or all hosts.
+     *
+     * @param hostName name of the host to send the message to, or null for all hosts
+     * @param message message to send
+     * @param callback optional return result
+     */
     sendToHost(hostName: string | null, message: any, callback?: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo): void;
+    /**
+     * Send a message to a specific host or all hosts.
+     *
+     * @param hostName name of the host to send the message to, or null for all hosts
+     * @param command command name
+     * @param message message to send
+     * @param callback optional return result
+     */
     sendToHost(hostName: string | null, command: string, message: any, callback?: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo): void;
-    private _sendToHost;
+    /**
+     * Send a message to an active UI Client
+     *
+     * @param options clientId and data options
+     */
     sendToUI(options: SendToUserInterfaceClientOptions): Promise<void>;
+    /**
+     * Send notification with given scope and category to host of this adapter
+     *
+     * @param scope scope to be addressed
+     * @param category to be addressed, if a null message will be checked by regex of given scope
+     * @param message message to be stored/checked
+     * @param options Additional options for the notification, currently `contextData` is supported
+     */
     registerNotification<Scope extends keyof ioBroker.NotificationScopes>(scope: Scope, category: ioBroker.NotificationScopes[Scope] | null, message: string, options?: NotificationOptions): Promise<void>;
+    /**
+     * Writes value into states DB.
+     *
+     * @param id object ID of the state.
+     * @param state simple value or object with attributes.
+     * @param callback return result
+     */
     setState<T extends ioBroker.SetStateCallback | undefined>(id: string | ioBroker.IdObject, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, callback?: T): T extends unknown ? ioBroker.SetStatePromise : void;
+    /**
+     * Writes value into states DB.
+     *
+     * @param id object ID of the state.
+     * @param state simple value or object with attributes.
+     * @param ack optional is command(false) or status(true)
+     * @param callback return result
+     */
     setState<T extends ioBroker.SetStateCallback | undefined>(id: string | ioBroker.IdObject, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, callback?: T): T extends unknown ? ioBroker.SetStatePromise : void;
-    setState<T extends ioBroker.SetStateCallback | undefined>(id: string | ioBroker.IdObject, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, options?: Partial<GetUserGroupsOptions> | null, callback?: T): T extends unknown ? ioBroker.SetStatePromise : void;
-    setState<T extends ioBroker.SetStateCallback | undefined>(id: string | ioBroker.IdObject, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, options?: Partial<GetUserGroupsOptions> | null, callback?: T): T extends unknown ? ioBroker.SetStatePromise : void;
+    /**
+     * Writes value into states DB.
+     *
+     * @param id object ID of the state.
+     * @param state simple value or object with attributes.
+     * @param options optional user context
+     * @param callback return result
+     */
+    setState<T extends ioBroker.SetStateCallback | undefined>(id: string | ioBroker.IdObject, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: T): T extends unknown ? ioBroker.SetStatePromise : void;
+    /**
+     * Writes value into states DB.
+     *
+     * @param id object ID of the state.
+     * @param state simple value or object with attributes.
+     * @param ack optional is command(false) or status(true)
+     * @param options optional user context
+     * @param callback return result
+     */
+    setState<T extends ioBroker.SetStateCallback | undefined>(id: string | ioBroker.IdObject, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: T): T extends unknown ? ioBroker.SetStatePromise : void;
     private _setState;
     private _getUserGroups;
     private _checkState;
     private _checkStates;
     private _getGroups;
     private _setStateChangedHelper;
+    /**
+     * Writes value into states DB only if the value really changed.
+     *
+     * @param id object ID of the state.
+     * @param state simple value or object with attributes.
+     * @param callback return result
+     */
     setStateChanged(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, callback?: ioBroker.SetStateChangedCallback): void;
+    /**
+     * Writes value into states DB only if the value really changed.
+     *
+     * @param id object ID of the state.
+     * @param state simple value or object with attributes.
+     * @param ack optional is command(false) or status(true)
+     * @param callback return result
+     */
     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;
+    /**
+     * Writes value into states DB only if the value really changed.
+     *
+     * @param id object ID of the state.
+     * @param state simple value or object with attributes.
+     * @param options optional user context
+     * @param callback return result
+     */
+    setStateChanged(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.SetStateChangedCallback): void;
+    /**
+     * Writes value into states DB only if the value really changed.
+     *
+     * @param id object ID of the state.
+     * @param state simple value or object with attributes.
+     * @param ack optional is command(false) or status(true)
+     * @param options optional user context
+     * @param callback return result
+     */
+    setStateChanged(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.SetStateChangedCallback): void;
     private _setStateChanged;
+    /**
+     * Writes value into states DB for any instance.
+     *
+     * @param id object ID of the state.
+     * @param state simple value or object with attributes.
+     * @param callback return result
+     */
     setForeignState(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, callback?: ioBroker.SetStateCallback): void;
+    /**
+     * Writes value into states DB for any instance.
+     *
+     * @param id object ID of the state.
+     * @param state simple value or object with attributes.
+     * @param ack optional is command(false) or status(true)
+     * @param callback return result
+     */
     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;
+    /**
+     * Writes value into states DB for any instance.
+     *
+     * @param id object ID of the state.
+     * @param state simple value or object with attributes.
+     * @param options optional user context
+     * @param callback return result
+     */
+    setForeignState(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.SetStateCallback): void;
+    /**
+     * Writes value into states DB for any instance.
+     *
+     * @param id object ID of the state.
+     * @param state simple value or object with attributes.
+     * @param ack optional is command(false) or status(true)
+     * @param options optional user context
+     * @param callback return result
+     */
+    setForeignState(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.SetStateCallback): void;
+    /**
+     * Writes value into states DB for any instance only if the value really changed.
+     *
+     * @param id object ID of the state.
+     * @param state simple value or object with attributes.
+     * @param callback return result
+     */
     setForeignStateChanged(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, callback?: ioBroker.SetStateChangedCallback): void;
+    /**
+     * Writes value into states DB for any instance only if the value really changed.
+     *
+     * @param id object ID of the state.
+     * @param state simple value or object with attributes.
+     * @param ack optional is command(false) or status(true)
+     * @param callback return result
+     */
     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;
+    /**
+     * Writes value into states DB for any instance only if the value really changed.
+     *
+     * @param id object ID of the state.
+     * @param state simple value or object with attributes.
+     * @param options optional user context
+     * @param callback return result
+     */
+    setForeignStateChanged(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.SetStateChangedCallback): void;
+    /**
+     * Writes value into states DB for any instance only if the value really changed.
+     *
+     * @param id object ID of the state.
+     * @param state simple value or object with attributes.
+     * @param ack optional is command(false) or status(true)
+     * @param options optional user context
+     * @param callback return result
+     */
+    setForeignStateChanged(id: string, state: ioBroker.State | ioBroker.StateValue | ioBroker.SettableState, ack: boolean, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.SetStateChangedCallback): void;
+    /**
+     * Read value from states DB.
+     *
+     * @param id object ID of the state.
+     * @param callback return result
+     */
     getState(id: string, callback: ioBroker.GetStateCallback): void;
-    getState(id: string, options: unknown, callback: ioBroker.GetStateCallback): void;
+    /**
+     * Read value from states DB.
+     *
+     * @param id object ID of the state.
+     * @param options optional user context
+     * @param callback return result
+     */
+    getState(id: string, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null | undefined, callback: ioBroker.GetStateCallback): void;
+    /**
+     * Read value from states DB for any instance and system state.
+     *
+     * @param id object ID of the state.
+     * @param callback return result
+     */
     getForeignState(id: string, callback: ioBroker.GetStateCallback): ioBroker.GetStatePromise;
-    getForeignState(id: string, options: unknown, callback: ioBroker.GetStateCallback): ioBroker.GetStatePromise;
+    /**
+     * Read value from states DB for any instance and system state.
+     *
+     * @param id object ID of the state.
+     * @param options optional user context
+     * @param callback return result
+     */
+    getForeignState(id: string, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null | undefined, callback: ioBroker.GetStateCallback): ioBroker.GetStatePromise;
     private _getForeignState;
     private _getDefaultHistory;
+    /**
+     * Read historian data for states of any instance or system state.
+     *
+     * @param id object ID of the state.
+     * @param options the query options for the history
+     * @param callback return result
+     */
     getHistory(id: string, options: ioBroker.GetHistoryOptions, callback: ioBroker.GetHistoryCallback): void;
+    /**
+     * Read historian data for states of any instance or system state.
+     *
+     * @param id object ID of the state.
+     * @param callback return result
+     */
     getHistory(id: string, callback: ioBroker.GetHistoryCallback): void;
     private _getHistory;
+    /**
+     * Convert ID into object with device's, channel's and state's name.
+     *
+     * @param id short or long string of ID like "stateID" or "adapterName.0.stateID".
+     * @returns parsed ID as an object
+     */
     idToDCS(id: string): {
         device: string;
         channel: string;
         state: string;
     } | null;
+    /**
+     * Deletes a state of this instance. The object is NOT deleted.
+     *
+     * @param id exactly object ID (without namespace)
+     * @param callback return result
+     */
     delState(id: string, callback?: ioBroker.ErrorCallback): void;
-    delState(id: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    /**
+     * Deletes a state of this instance. The object is NOT deleted.
+     *
+     * @param id exactly object ID (without namespace)
+     * @param options optional user context
+     * @param callback return result
+     */
+    delState(id: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.ErrorCallback): void;
     private _delState;
+    /**
+     * Deletes a state of any adapter. The object is NOT deleted.
+     *
+     * @param id long string for ID like "adapterName.0.stateID".
+     * @param callback return result
+     */
     delForeignState(id: string, callback?: ioBroker.ErrorCallback): void;
-    delForeignState(id: string, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    /**
+     * Deletes a state of any adapter. The object is NOT deleted.
+     *
+     * @param id long string for ID like "adapterName.0.stateID".
+     * @param options optional argument to describe the user context
+     * @param callback return result
+     */
+    delForeignState(id: string, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.ErrorCallback): void;
     private _delForeignState;
+    /**
+     * Read all states of this adapter, that pass the pattern
+     *
+     * @param pattern string in form 'adapter.0.*' or like this. It can be an array of IDs too.
+     * @param callback return result
+     */
     getStates(pattern: Pattern, callback: ioBroker.GetStatesCallback): void;
-    getStates(pattern: Pattern, options: unknown, callback: ioBroker.GetStatesCallback): void;
+    /**
+     * Read all states of this adapter, that pass the pattern
+     *
+     * @param pattern string in form 'adapter.0.*' or like this. It can be an array of IDs too.
+     * @param options optional argument to describe the user context
+     * @param callback return result
+     */
+    getStates(pattern: Pattern, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null | undefined, callback: ioBroker.GetStatesCallback): void;
     private _processStatesSecondary;
     /**
      * Ensures, that object information is read, and the alias id is mapped to the source id if an alias is contained in the getStates call
@@ -769,37 +2333,114 @@ export declare class AdapterClass extends EventEmitter {
      * @param targetObjs the target objects (e.g. alias objects or the actual objects)
      */
     private _processStates;
+    /**
+     * Read all states of all adapters (and system states), that pass the pattern
+     *
+     * @param pattern string in form 'adapter.0.*' or like this. It can be an array of IDs too.
+     * @param callback return result
+     */
     getForeignStates(pattern: Pattern, callback: ioBroker.GetStatesCallback): void;
-    getForeignStates(pattern: Pattern, options: unknown, callback: ioBroker.GetStatesCallback): void;
-    private _getForeignStates;
     /**
-     * Add subscription for given alias, if it is not a state it will be ignored
+     * Read all states of all adapters (and system states), that pass the pattern
      *
-     * @param aliasObj the alias object
-     * @param pattern pattern to subscribe for
+     * @param pattern string in form 'adapter.0.*' or like this. It can be an array of IDs too.
+     * @param options optional user context
+     * @param callback return result
      */
-    private _addAliasSubscribe;
+    getForeignStates(pattern: Pattern, options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null | undefined, callback: ioBroker.GetStatesCallback): void;
+    private _getForeignStates;
     /**
-     * Remove an alias subscribe
+     * Subscribe for changes on all states of all adapters (and system states), that pass the pattern
      *
-     * @param sourceId id of the source object
-     * @param aliasObjOrIdx the alias target or the index of the targets array
+     * @param pattern string in form 'adapter.0.*' or like this. It can be an array of IDs too.
+     * @param callback optional callback
      */
-    private _removeAliasSubscribe;
     subscribeForeignStates(pattern: Pattern, callback?: ioBroker.ErrorCallback): void;
-    subscribeForeignStates(pattern: Pattern, options: unknown, callback?: ioBroker.ErrorCallback): void;
-    private _subscribeForeignStates;
+    /**
+     * Subscribe for changes on all states of all adapters (and system states), that pass the pattern
+     *
+     * @param pattern string in form 'adapter.0.*' or like this. It can be an array of IDs too.
+     * @param options optional argument to describe the user context
+     * @param callback optional callback
+     */
+    subscribeForeignStates(pattern: Pattern, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.ErrorCallback): void;
+    /**
+     * Unsubscribe for changes for given pattern
+     *
+     * @param pattern string in form 'adapter.0.*'. Must be the same as subscribe.
+     * @param callback optional callback
+     */
     unsubscribeForeignStates(pattern: string | string[], callback?: ioBroker.ErrorCallback): void;
-    unsubscribeForeignStates(pattern: string | string[], options: unknown, callback?: ioBroker.ErrorCallback): void;
-    private _unsubscribeForeignStates;
+    /**
+     * Unsubscribe for changes for given pattern
+     *
+     * @param pattern string in form 'adapter.0.*'. Must be the same as subscribe.
+     * @param options optional argument to describe the user context
+     * @param callback optional callback
+     */
+    unsubscribeForeignStates(pattern: string | string[], options: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.ErrorCallback): void;
+    /**
+     * Subscribe for changes on all states of this instance, that pass the pattern
+     *
+     * @param pattern string in form 'adapter.0.*' or like this. Only string allowed
+     * @param callback optional callback
+     */
     subscribeStates(pattern: Pattern, callback?: ioBroker.ErrorCallback): void;
-    subscribeStates(pattern: Pattern, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    /**
+     * Subscribe for changes on all states of this instance, that pass the pattern
+     *
+     * @param pattern string in form 'adapter.0.*' or like this. Only string allowed
+     * @param options optional argument to describe the user context
+     * @param callback optional callback
+     */
+    subscribeStates(pattern: Pattern, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.ErrorCallback): void;
+    /**
+     * Unsubscribe for changes for given pattern for own states.
+     *
+     * @param pattern string in form 'adapter.0.*'. Must be the same as subscribe.
+     * @param callback optional callback
+     */
     unsubscribeStates(pattern: Pattern, callback?: ioBroker.ErrorCallback): void;
-    unsubscribeStates(pattern: Pattern, options: unknown, callback?: ioBroker.ErrorCallback): void;
+    /**
+     * Unsubscribe for changes for given pattern for own states.
+     *
+     * @param pattern string in form 'adapter.0.*'. Must be the same as subscribe.
+     * @param options optional argument to describe the user context
+     * @param callback optional callback
+     */
+    unsubscribeStates(pattern: Pattern, options?: {
+        user?: ioBroker.ObjectIDs.User;
+    } | null, callback?: ioBroker.ErrorCallback): void;
+    /**
+     * Return plugin instance
+     *
+     * @param name name of the plugin to return
+     * @returns plugin instance or null if not existent or not isActive
+     */
     getPluginInstance(name: string): ioBroker.Plugin | null;
+    /**
+     * Return plugin configuration
+     *
+     * @param name name of the plugin to return
+     * @returns plugin configuration or null if not existent or not isActive
+     */
     getPluginConfig(name: string): Record<string, any> | null;
-    private _autoSubscribeOn;
-    getSuitableLicenses(all?: boolean, adapterName?: string): Promise<any[]>;
+    /**
+     * This method returns the list of license that can be used by this adapter
+     *
+     * @param all if return the licenses, that used by other instances (true) or only for this instance (false)
+     * @param adapterName Return licenses for specific adapter
+     * @returns list of suitable licenses
+     */
+    getSuitableLicenses(all?: boolean, adapterName?: string): Promise<SuitableLicense[]>;
     /**
      * Add given id to log redirect list
      *