iobroker.javascript 9.0.9 → 9.0.11

package/build-backend/lib/javascript.d.ts

@@ -2,7 +2,44 @@
 // this has a nice side effect that we may augment the global scope
 import type * as os from 'node:os';
 import type { ChildProcess, ExecException } from 'node:child_process';
-import type { SubscribeObject } from '../types';
+
+export interface FsStats {
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isSymbolicLink(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+    dev: number;
+    ino: number;
+    mode: number;
+    nlink: number;
+    uid: number;
+    gid: number;
+    rdev: number;
+    size: number;
+    blksize: number;
+    blocks: number;
+    atimeMs: number;
+    mtimeMs: number;
+    ctimeMs: number;
+    birthtimeMs: number;
+    atime: Date;
+    mtime: Date;
+    ctime: Date;
+    birthtime: Date;
+}
+
+declare const __brand: unique symbol;
+type Brand<B> = { [__brand]: B };
+export type Branded<T, B> = T & Brand<B>;
+
+type SubscribeObject = {
+    name: string;
+    pattern: string;
+    callback: (id: string, obj?: iobJS.Object | null) => void;
+};
 
 type EmptyCallback = () => void | Promise<void>;
 type ErrorCallback = (err?: Error) => void | Promise<void>;
@@ -66,39 +103,80 @@ type AnyOf<
 // tslint:disable:no-namespace
 declare global {
     namespace iobJS {
-        enum StateQuality {
-            good = 0x00, // or undefined or null
-            bad = 0x01,
-            general_device_problem = 0x41,
-            general_sensor_problem = 0x81,
-            device_not_connected = 0x42,
-            sensor_not_connected = 0x82,
-            device_reports_error = 0x44,
-            sensor_reports_error = 0x84,
-        }
+        /** Two-way mapping for state quality ("q" attribute of a state) */
+        interface STATE_QUALITY {
+            /** The default value for a state */
+            GOOD: 0x00;
+            /** General problem */
+            BAD: 0x01;
+            /** The instance cannot establish a connection */
+            CONNECTION_PROBLEM: 0x02;
+            /** Substitute value from controller. Do not set this in adapters */
+            SUBSTITUTE_FROM_CONTROLLER: 0x10;
+            /** Quality for default values */
+            SUBSTITUTE_INITIAL_VALUE: 0x20;
+            /** Substitute value from instance or device */
+            SUBSTITUTE_DEVICE_INSTANCE_VALUE: 0x40;
+            /** Substitute value from a sensor */
+            SUBSTITUTE_SENSOR_VALUE: 0x80;
+            /** General problem by instance */
+            GENERAL_INSTANCE_PROBLEM: 0x11;
+            /** General problem by device */
+            GENERAL_DEVICE_PROBLEM: 0x41;
+            /** General problem by sensor */
+            GENERAL_SENSOR_PROBLEM: 0x81;
+            /** The instance is not connected */
+            INSTANCE_NOT_CONNECTED: 0x12;
+            /** The device is not connected */
+            DEVICE_NOT_CONNECTED: 0x42;
+            /** The sensor is not connected */
+            SENSOR_NOT_CONNECTED: 0x82;
+            /** The device has reported an error */
+            DEVICE_ERROR_REPORT: 0x44;
+            /** The sensor has reported an error */
+            SENSOR_ERROR_REPORT: 0x84;
+        }
+
+        type StateValue = string | number | boolean | null;
+
+        interface State {
+            /** The value of the state. */
+            val: StateValue;
 
-        type SettableState = AtLeastOne<ioBroker.State>;
+            /** Direction flag: false for desired value and true for actual value. Default: false. */
+            ack: boolean;
 
-        interface TypedState<T extends ioBroker.StateValue = any> extends ioBroker.State {
-            val: T;
+            /** Unix timestamp. Default: current time */
+            ts: number;
+
+            /** Unix timestamp of the last time the value changed */
+            lc: number;
+
+            /** Name of the adapter instance which set the value, e.g. "system.adapter.web.0" */
+            from: string;
+
+            /** The user who set this value */
+            user?: string;
+
+            /** Optional time in seconds after which the state is reset to null */
+            expire?: number;
+
+            /** Optional quality of the state value */
+            q?: STATE_QUALITY[keyof STATE_QUALITY];
+
+            /** Optional comment */
+            c?: string;
         }
 
-        interface AbsentState extends Omit<ioBroker.State, 'ack' | 'from' | 'ts' | 'lc'> {
-            val: null;
-            notExist: true;
+        type SettableState = AtLeastOne<State>;
 
-            ack: undefined;
-            ts: undefined;
-            lc: undefined;
-            from: undefined;
-            expire: undefined;
-            q: undefined;
-            c: undefined;
+        interface IdObject {
+            device?: string;
+            channel?: string;
+            state?: string;
         }
 
-        type Languages = 'en' | 'de' | 'ru' | 'pt' | 'nl' | 'fr' | 'it' | 'es' | 'pl' | 'uk' | 'zh-cn';
-        type StringOrTranslated = string | { [lang in Languages]?: string };
-        type CommonType = 'number' | 'string' | 'boolean' | 'array' | 'object' | 'mixed' | 'file';
+        type Session = any; // TODO: implement
 
         /** Defines access rights for a single object type */
         interface ObjectOperationPermissions {
@@ -139,6 +217,462 @@ declare global {
             };
         }
 
+        interface Permission {
+            /** The type of the permission */
+            type: string;
+            /** Defines which kind of operation is required */
+            operation: string;
+        }
+        interface ObjectOrStatePermission extends Permission {
+            type: 'object' | 'file' | 'users' | 'state';
+            operation: 'list' | 'read' | 'write' | 'create' | 'delete';
+        }
+        interface OtherPermission extends Permission {
+            type: 'other';
+            operation: 'execute' | 'http' | 'sendto';
+        }
+        interface CommandsPermissions {
+            // TODO: Are all properties required or is a partial object ok?
+            getObject: ObjectOrStatePermission;
+            getObjects: ObjectOrStatePermission;
+            getObjectView: ObjectOrStatePermission;
+            setObject: ObjectOrStatePermission;
+            subscribeObjects: ObjectOrStatePermission;
+            unsubscribeObjects: ObjectOrStatePermission;
+            getStates: ObjectOrStatePermission;
+            getState: ObjectOrStatePermission;
+            setState: ObjectOrStatePermission;
+            getStateHistory: ObjectOrStatePermission;
+            subscribe: ObjectOrStatePermission;
+            unsubscribe: ObjectOrStatePermission;
+            getVersion: Permission;
+            httpGet: OtherPermission;
+            sendTo: OtherPermission;
+            sendToHost: OtherPermission;
+            readFile: ObjectOrStatePermission;
+            readFile64: ObjectOrStatePermission;
+            writeFile: ObjectOrStatePermission;
+            writeFile64: ObjectOrStatePermission;
+            unlink: ObjectOrStatePermission;
+            rename: ObjectOrStatePermission;
+            mkdir: ObjectOrStatePermission;
+            readDir: ObjectOrStatePermission;
+            chmodFile: ObjectOrStatePermission;
+            authEnabled: Permission;
+            disconnect: Permission;
+            listPermissions: Permission;
+            getUserPermissions: ObjectOrStatePermission;
+        }
+
+        type UserGroup = any; // TODO find out how this looks like
+        // interface UserGroup { }
+
+        /** Contains information about a user */
+        interface User {
+            /** Which groups this user belongs to */
+            groups: UserGroup[];
+            /** Access rights of this user */
+            acl: ObjectPermissions;
+        }
+
+        /** Parameters for adapter.getObjectView */
+        interface GetObjectViewParams {
+            /** First id to include in the return list */
+            startkey?: string;
+            /** Last id to include in the return list */
+            endkey?: string;
+            /** Whether docs should be included in the return list */ // TODO: What are docs?
+            include_docs?: boolean;
+        }
+
+        /** Parameters for adapter.getObjectList */
+        type GetObjectListParams = GetObjectViewParams;
+
+        interface Logger {
+            /** log a message with silly level */
+            silly(message: string): void;
+            /** log a message with debug level */
+            debug(message: string): void;
+            /** log a message with info level (default output level for all adapters) */
+            info(message: string): void;
+            /** log a message with warning severity */
+            warn(message: string): void;
+            /** log a message with error severity */
+            error(message: string): void;
+
+            /** Verbosity of the log output */
+            level: LogLevel;
+        }
+
+        /** Log message */
+        interface LogMessage {
+            /** unique ID */
+            _id: number;
+            /** id of the source instance */
+            from: string;
+            /** log level */
+            severity: string;
+            /** timestamp */
+            ts: number;
+            /** actual content */
+            message: string;
+        }
+
+        interface Certificates {
+            /** private key file */
+            key: string;
+            /** public certificate */
+            cert: string;
+            /** chained CA certificates */
+            ca?: string;
+        }
+
+        type MessagePayload = any;
+
+        /** Callback information for a passed message */
+        interface MessageCallbackInfo {
+            /** The original message payload */
+            message: MessagePayload;
+            /** ID of this callback */
+            id: number;
+            /** If ack is false, it means the message is a request. If ack is true, it means the message is a response */
+            ack: boolean;
+            /** Timestamp of this message */
+            time: number;
+        }
+
+        interface SendableMessage {
+            /** The command to be executed */
+            command: string;
+            /** The message payload */
+            message: MessagePayload;
+            /** The source of this message */
+            from: string;
+            /** Callback information. This is set when the source expects a response */
+            callback?: MessageCallbackInfo;
+        }
+
+        /** A message being passed between adapter instances */
+        interface Message extends SendableMessage {
+            /** ID of this message */
+            _id: number;
+        }
+
+        type Log = any; // TODO: define this https://github.com/ioBroker/ioBroker.js-controller/blob/master/lib/states/statesInMemServer.js#L873
+
+        type EnumList = string | string[];
+
+        type Plugin = Record<string, any>; // TODO: Add definition
+
+        interface DirectoryEntry {
+            file: string;
+            stats: FsStats;
+            isDir: boolean;
+            acl: any; // access control list object
+            modifiedAt: number;
+            createdAt: number;
+        }
+
+        interface GetHistoryOptions {
+            instance?: string;
+            /** Start time in ms */
+            start?: number;
+            /** End time in ms. If not defined, it is "now" */
+            end?: number;
+            /** Step in ms of intervals. Used in aggregate (max, min, average, total, ...)  */
+            step?: number;
+            /** number of values if aggregate is 'onchange' or number of intervals if other aggregate method. Count will be ignored if step is set, else default is 500 if not set */
+            count?: number;
+            /** if `from` field should be included in answer */
+            from?: boolean;
+            /** if `ack` field should be included in answer */
+            ack?: boolean;
+            /** if `q` field should be included in answer */
+            q?: boolean;
+            /** if `id` field should be included in answer */
+            addId?: boolean;
+            /** do not return more entries than limit */
+            limit?: number;
+            /** round result to number of digits after decimal point */
+            round?: number;
+            /** if null values should be included (false), replaced by last not null value (true) or replaced with 0 (0) */
+            ignoreNull?: boolean | 0;
+            /** This number will be returned in answer, so the client can assign the request for it */
+            sessionId?: number;
+            /** aggregate method (Default: 'average') */
+            aggregate?:
+                | 'onchange'
+                | 'minmax'
+                | 'min'
+                | 'max'
+                | 'average'
+                | 'total'
+                | 'count'
+                | 'none'
+                | 'percentile'
+                | 'quantile'
+                | 'integral'
+                | 'integralTotal';
+            /** Returned data is normally sorted ascending by date, this option lets you return the newest instead of the oldest values if the number of returned points is limited */
+            returnNewestEntries?: boolean;
+            /** By default, the additional border values are returned to optimize charting. Set this option to true if this is not wanted (e.g., for script data processing) */
+            removeBorderValues?: boolean;
+            /** when using aggregate method `percentile` defines the percentile level (0..100)(defaults to 50) */
+            percentile?: number;
+            /** when using aggregate method `quantile` defines the quantile level (0..1)(defaults to 0.5) */
+            quantile?: number;
+            /** when using aggregate method `integral` defines the unit in seconds (defaults to 60 seconds). E.g., to get integral in hours for Wh or such, set to 3600. */
+            integralUnit?: number;
+            /** when using aggregate method `integral` defines the interpolation method (defaults to `none`). */
+            integralInterpolation?: 'none' | 'linear';
+            /** If user is set, it will be checked if this user may read the variable */
+            user?: `system.user.${string}`;
+        }
+
+        interface DelObjectOptions {
+            /** Whether all child objects should be deleted as well */
+            recursive?: boolean;
+            // Allow non-documented properties
+            [other: string]: unknown;
+        }
+
+        interface ExtendObjectOptionsPreserve {
+            [prop: string]: ExtendObjectOptionsPreserve | boolean | string[];
+        }
+
+        interface ExtendObjectOptions {
+            /** Which properties of the original object should be preserved */
+            preserve?: ExtendObjectOptionsPreserve;
+            // Allow non-documented properties
+            [other: string]: unknown;
+        }
+
+        /** Predefined notification scopes and their categories */
+        interface NotificationScopes {
+            system:
+                | 'memIssues'
+                | 'fsIoErrors'
+                | 'noDiskSpace'
+                | 'accessErrors'
+                | 'nonExistingFileErrors'
+                | 'remoteHostErrors'
+                | 'restartLoop'
+                | 'fileToJsonl';
+            [other: string]: string;
+        }
+
+        /** Additional context for the notification which can be used by notification processing adapters */
+        interface NotificationContextData {
+            /** Use a `key` specific to the adapter or if a feature is supported by all adapters of a type, the type (e.g. `messaging`) is also fine. */
+            [adapterNameOrAdapterType: string]: unknown;
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+        interface AdapterConfig {
+            // This is a stub to be augmented in every adapter
+        }
+
+        type ReadyHandler = () => void | Promise<void>;
+        type ObjectChangeHandler = (id: string, obj: iobJS.Object | null | undefined) => void | Promise<void>;
+        type OriginalStateChangeHandler = (id: string, obj: State | null | undefined) => void | Promise<void>;
+        type OriginalFileChangeHandler = (id: string, fileName: string, size: number | null) => void;
+        type MessageHandler = (obj: Message) => void | Promise<void>;
+        type UnloadHandler = (callback: EmptyCallback) => void | Promise<void>;
+        type ErrorHandler = (err: Error) => boolean;
+
+        type EmptyCallback = () => void;
+        type ErrorCallback = (err?: Error | null) => void;
+        /** Special variant of ErrorCallback for methods where Node.js returns an ErrnoException */
+        type ErrnoCallback = (err?: NodeJS.ErrnoException | null) => void;
+        // TODO: Redefine callbacks as subclass of GenericCallback
+        type GenericCallback<T> = (err?: Error | null, result?: T) => void;
+
+        /** Due to backward compatibility first param can be result or error */
+        type OriginalMessageCallback = (response?: Message | Error) => void;
+
+        type OriginalSetObjectCallback = (err?: Error | null, obj?: { id: string }) => void;
+        type OriginalSetObjectPromise = Promise<NonNullCallbackReturnTypeOf<OriginalSetObjectCallback>>;
+
+        type GetEnumCallback = (err?: Error | null, enums?: Record<string, EnumObject>, requestedEnum?: string) => void;
+        type GetEnumsCallback = (
+            err?: Error | null,
+            result?: {
+                [groupName: string]: Record<string, EnumObject>;
+            },
+        ) => void;
+        type GetEnumsPromise = Promise<NonNullCallbackReturnTypeOf<GetEnumsCallback>>;
+
+        type GetObjectsCallback = (err?: Error | null, objects?: Record<string, iobJS.Object>) => void;
+        type GetObjectsPromise = Promise<NonNullCallbackReturnTypeOf<GetObjectsCallback>>;
+
+        type GetObjectsCallbackTyped<T extends ObjectType> = (
+            err?: Error | null,
+            objects?: Record<string, iobJS.AnyObject & { type: T }>,
+        ) => void;
+        type GetObjectsPromiseTyped<T extends ObjectType> = Promise<
+            NonNullCallbackReturnTypeOf<GetObjectsCallbackTyped<T>>
+        >;
+
+        type FindObjectCallback = (
+            /** If an error happened, this contains the message */
+            err?: Error | null,
+            /** If an object was found, this contains the ID */
+            id?: string,
+            /** If an object was found, this contains the common.name */
+            name?: StringOrTranslated,
+        ) => void;
+
+        // This is a version used by GetDevices/GetChannelsOf/GetStatesOf
+        type GetObjectsCallback3<T extends BaseObject> = (err?: Error | null, result?: T[]) => void;
+
+        type SecondParameterOf<T extends (...args: any[]) => any> = T extends (
+            arg0: any,
+            arg1: infer R,
+            ...args: any[]
+        ) => any
+            ? R
+            : never;
+        /** Infers the return type from a callback-style API and strips out null and undefined */
+        type NonNullCallbackReturnTypeOf<T extends (...args: any[]) => any> = Exclude<
+            SecondParameterOf<T>,
+            null | undefined
+        >;
+        /** Infers the return type from a callback-style API and leaves null and undefined in */
+        type CallbackReturnTypeOf<T extends (...args: any[]) => any> = SecondParameterOf<T>;
+
+        type OriginalGetStateCallback = (err?: Error | null, state?: State | null) => void;
+        type GetStatePromise = Promise<CallbackReturnTypeOf<OriginalGetStateCallback>>;
+
+        type GetStatesCallback = (err?: Error | null, states?: Record<string, State>) => void;
+        type GetStatesPromise = Promise<NonNullCallbackReturnTypeOf<GetStatesCallback>>;
+
+        type SetStateCallback = (err?: Error | null, id?: string) => void;
+        type SetStatePromise = Promise<NonNullCallbackReturnTypeOf<SetStateCallback>>;
+
+        type SetStateChangedCallback = (err?: Error | null, id?: string, notChanged?: boolean) => void;
+        type SetStateChangedPromise = Promise<NonNullCallbackReturnTypeOf<SetStateChangedCallback>>;
+
+        type DeleteStateCallback = (err?: Error | null, id?: string) => void;
+
+        type GetHistoryResult = Array<State & { id?: string }>;
+        type GetHistoryCallback = (
+            err: Error | null,
+            result?: GetHistoryResult,
+            step?: number,
+            sessionId?: number,
+        ) => void;
+
+        /** Contains the return values of readDir */
+        interface ReadDirResult {
+            /** Name of the file or directory */
+            file: string;
+            /** File system stats */
+            stats: Partial<FsStats>;
+            /** Whether this is a directory or a file */
+            isDir: boolean;
+            /** Access rights */
+            acl?: EvaluatedFileACL;
+            /** Date of last modification */
+            modifiedAt?: number;
+            /** Date of creation */
+            createdAt?: number;
+        }
+        type ReadDirCallback = (err?: NodeJS.ErrnoException | null, entries?: ReadDirResult[]) => void;
+        type ReadDirPromise = Promise<ReadDirResult[]>;
+
+        type OriginalReadFileCallback = (
+            err?: NodeJS.ErrnoException | null,
+            data?: Buffer | string,
+            mimeType?: string,
+        ) => void;
+        type OriginalReadFilePromise = Promise<{ file: string | Buffer; mimeType?: string }>;
+
+        /** Contains the return values of chownFile */
+        interface ChownFileResult {
+            /** The parent directory of the processed file or directory */
+            path: string;
+            /** Name of the file or directory */
+            file: string;
+            /** File system stats */
+            stats: FsStats;
+            /** Whether this is a directory or a file */
+            isDir: boolean;
+            /** Access rights */
+            acl: FileACL;
+            /** Date of last modification */
+            modifiedAt: number;
+            /** Date of creation */
+            createdAt: number;
+        }
+        type ChownFileCallback = (err?: NodeJS.ErrnoException | null, processed?: ChownFileResult[]) => void;
+
+        /** Contains the return values of rm */
+        interface RmResult {
+            /** The parent directory of the deleted file or directory */
+            path: string;
+            /** The name of the deleted file or directory */
+            file: string;
+        }
+        type RmCallback = (err?: NodeJS.ErrnoException | null, entries?: RmResult[]) => void;
+
+        type ChownObjectCallback = (err?: NodeJS.ErrnoException | null, list?: iobJS.Object[]) => void;
+
+        type GetKeysCallback = (err?: Error | null, list?: string[]) => void;
+
+        interface GetObjectViewItem<T extends AnyObject> {
+            /** The ID of this object */
+            id: T['_id'];
+            /** A copy of the object from the DB */
+            value: T;
+        }
+        type GetObjectViewCallback<T extends AnyObject> = (
+            err?: Error | null,
+            result?: { rows: Array<GetObjectViewItem<T>> },
+        ) => void;
+        type GetObjectViewPromise<T extends AnyObject> = Promise<NonNullCallbackReturnTypeOf<GetObjectViewCallback<T>>>;
+
+        interface GetObjectListItem<T extends AnyObject> extends GetObjectViewItem<T> {
+            /** A copy of the object */
+            value: T;
+            /** The same as @link{value} */
+            doc: T;
+        }
+        type GetObjectListCallback<T extends iobJS.AnyObject> = (
+            err?: Error | null,
+            result?: { rows: GetObjectListItem<T>[] },
+        ) => void;
+        type GetObjectListPromise = Promise<NonNullCallbackReturnTypeOf<GetObjectListCallback<iobJS.Object>>>;
+
+        type ExtendObjectCallback = (
+            err?: Error | null,
+            result?: { id: string; value: iobJS.Object },
+            id?: string,
+        ) => void;
+
+        type GetSessionCallback = (session: Session) => void;
+
+        type Timeout = Branded<number, 'Timeout'> | null; // or null to not allow native clearTimeout
+        type Interval = Branded<number, 'Interval'> | null; // or null to not allow native clearInterval
+
+        /** Defines access rights for a single file */
+        interface FileACL {
+            /** Full name of the user who owns this file, e.g. "system.user.admin" */
+            owner: string;
+            /** Full name of the group who owns this file, e.g. "system.group.administrator" */
+            ownerGroup: string;
+            /** Linux-type permissions defining access to this file */
+            permissions: number;
+        }
+
+        /** Defines access rights for a single file, applied to a user or group */
+        interface EvaluatedFileACL extends FileACL {
+            /** Whether the user may read the file */
+            read: boolean;
+            /** Whether the user may write the file */
+            write: boolean;
+        }
+
+        /** Defines access rights for a single object */
         interface ObjectACL {
             /** Full name of the user who owns this object, e.g. "system.user.admin" */
             owner: string;
@@ -147,6 +681,7 @@ declare global {
             /** Linux-type permissions defining access to this object */
             object: number;
         }
+
         /** Defines access rights for a single state object */
         interface StateACL extends ObjectACL {
             /** Linux-type permissions defining access to this state */
@@ -168,7 +703,9 @@ declare global {
             | 'meta'
             | 'script'
             | 'user'
-            | 'chart';
+            | 'chart'
+            | 'schedule'
+            | 'design';
 
         // Define the naming schemes for objects, so we can provide more specific types for get/setObject
         namespace ObjectIDs {
@@ -194,15 +731,21 @@ declare global {
             // Guaranteed instance objects
             type Instance = `system.adapter.${string}.${number}`;
             // Guaranteed adapter objects
-            type Adapter = `system.adapter.${string}`;
+            type Adapter = `system.adapter.${string}` | `system.host.${string}.adapter.${string}`;
             // Guaranteed group objects
             type Group = `system.group.${string}`;
             // Guaranteed user objects
             type User = `system.user.${string}`;
             // Guaranteed host objects
             type Host = `system.host.${string}`;
+            // Guaranteed repository object
+            type Repository = 'system.repositories';
             // Guaranteed config objects
-            type Config = `system.${'certificates' | 'config' | 'repositories'}`;
+            type Config = 'system.certificates';
+            // Guaranteed system config objects
+            type SystemConfig = 'system.config';
+            // Guaranteed design objects
+            type Design = `_design/${string}`;
 
             // Unsure, can be folder, device, channel or state (or whatever an adapter does)
             type AdapterScoped = `${string}.${number}.${string}`;
@@ -224,10 +767,9 @@ declare global {
                 | AdapterScoped;
         }
 
-        type ObjectIdToObjectType<
-            T extends string,
-            Read extends 'read' | 'write' = 'read',
-            O = T extends ObjectIDs.State // State must come before Adapter or system.adapter.admin.0.foobar will resolve to AdapterObject
+        type ObjectIdToObjectType<T extends string, Read extends 'read' | 'write' = 'read'> =
+            // State must come before Adapter or system.adapter.admin.0.foobar will resolve to AdapterObject
+            T extends ObjectIDs.State
                 ? StateObject
                 : // Instance and Adapter must come before meta or `system.adapter.admin` will resolve to MetaObject
                   T extends ObjectIDs.Instance
@@ -250,23 +792,42 @@ declare global {
                                   ? UserObject
                                   : T extends ObjectIDs.Host
                                     ? HostObject
-                                    : T extends ObjectIDs.Config
-                                      ? OtherObject & { type: 'config' }
-                                      : T extends ObjectIDs.AdapterScoped
-                                        ? AdapterScopedObject
-                                        : iobJS.AnyObject,
-            // When reading objects, we should be less strict, so working with the return type is less of a pain to work with
-        > = Read extends 'read' ? AnyOf<O> : O;
+                                    : T extends ObjectIDs.Design
+                                      ? DesignObject
+                                      : T extends ObjectIDs.Repository
+                                        ? RepositoryObject
+                                        : T extends ObjectIDs.SystemConfig
+                                          ? SystemConfigObject
+                                          : T extends ObjectIDs.Config
+                                            ? OtherObject & { type: 'config' }
+                                            : T extends ObjectIDs.AdapterScoped
+                                              ? AdapterScopedObject
+                                              : Read extends 'read'
+                                                ? iobJS.Object
+                                                : AnyObject;
+
+        type Languages = 'en' | 'de' | 'ru' | 'pt' | 'nl' | 'fr' | 'it' | 'es' | 'pl' | 'uk' | 'zh-cn';
+        type Translated = { en: string } & { [lang in Languages]?: string };
+
+        /** For objects, we require the English language to be present */
+        type StringOrTranslated = string | Translated;
+
+        type CommonType = 'number' | 'string' | 'boolean' | 'array' | 'object' | 'mixed';
 
         interface ObjectCommon {
             /** The name of this object as a simple string or an object with translations */
             name: StringOrTranslated;
 
+            /** Description of this object */
+            desc?: StringOrTranslated;
+
             /** When set to true, this object may not be deleted */
             dontDelete?: true;
 
             /** When set to true, this object is only visible when expert mode is turned on in admin */
             expert?: true;
+            /** Color attribute used in UI */
+            color?: string;
 
             // Icon and role aren't defined in SCHEMA.md,
             // but they are being used by some adapters
@@ -276,18 +837,9 @@ declare global {
             role?: string;
         }
 
-        interface StateCommonAlias {
-            /** The target state id or two target states used for reading and writing values */
-            id: string | { read: string; write: string };
-            /** An optional conversion function when reading, e.g. `"(val − 32) * 5/9"` */
-            read?: string;
-            /** An optional conversion function when reading, e.g. `"(val * 9/5) + 32"` */
-            write?: string;
-        }
-
         interface StateCommon extends ObjectCommon {
             /** Type of this state. See https://github.com/ioBroker/ioBroker/blob/master/doc/SCHEMA.md#state-commonrole for a detailed description */
-            type?: CommonType;
+            type: CommonType;
             /** minimum value */
             min?: number;
             /** maximum value */
@@ -296,8 +848,6 @@ declare global {
             step?: number;
             /** unit of the value */
             unit?: string;
-            /** description of this state */
-            desc?: StringOrTranslated;
 
             /** if this state is readable */
             read: boolean;
@@ -307,62 +857,114 @@ declare global {
             role: string;
 
             /** the default value */
-            def?: ioBroker.StateValue;
+            def?: any;
             /** the default status of the ack flag */
             defAck?: boolean;
 
             /** Configures this state as an alias for another state */
-            alias?: StateCommonAlias;
+            alias?: {
+                /** The target state id */
+                id:
+                    | string
+                    | {
+                          read: string;
+                          write: string;
+                      };
+                /** An optional conversion function when reading, e.g. `"(val − 32) * 5/9"` */
+                read?: string;
+                /** An optional conversion function when reading, e.g. `"(val * 9/5) + 32"` */
+                write?: string;
+            };
 
             /**
              * Dictionary of possible values for this state in the form
-             * <pre>
+             * ```jsonc
              * {
              *     "internal value 1": "displayed value 1",
              *     "internal value 2": "displayed value 2",
-             *     ...
+             *     // ...
              * }
-             * </pre>
+             * ```
+             *
+             * or as an array:
+             * ```jsonc
+             * [ "value 1", "value 2", // ... ]
+             * ```
+             *
              * In old ioBroker versions, this could also be a string of the form
-             * "val1:text1;val2:text2" (now deprecated)
+             * `"val1:text1;val2:text2"` (now deprecated)
              */
-            states?: Record<string, string> | string;
+            states?: Record<string, string> | string[] | string;
 
             /** ID of a helper state indicating if the handler of this state is working */
             workingID?: string;
 
-            /** @deprecated moved to `custom.history´ - attached history information */
+            /** attached history information */
             history?: any;
 
             /** Custom settings for this state */
             custom?: Record<string, any>;
 
+            /** Custom defined properties for backward compatibility of material adapter */
+            material?: any;
+
+            /** Custom defined properties for backward compatibility of habpanel adapter */
+            habpanel?: any;
+
+            /** Custom defined properties for backward compatibility of habpanel adapter */
+            mobile?: any;
+
             /**
              * Settings for IOT adapters and how the state should be named in e.g., Alexa.
-             * The string "ignore" is a special case, causing the state to be ignored.
+             * The string "ignore" (deprecated please use boolean `false` instead) or boolean value `false` is a special case, causing the state to be ignored.
+             * A value of `null` means that the device should be removed by the IOT adapters
              */
             smartName?:
+                | null
+                | false
                 | string
                 | ({ [lang in Languages]?: string } & {
-                      /** Which kind of device this it is */
+                      /** Which kind of device it is */
                       smartType?: string | null;
                       /** Which value to set when the ON command is issued */
-                      byOn?: string | null;
+                      byON?: string | null;
                   });
         }
-        interface ChannelCommon extends ObjectCommon {
-            /** description of this channel */
-            desc?: string;
 
+        interface ChannelCommon extends ObjectCommon {
             // Make it possible to narrow the object type using the custom property
             custom?: undefined;
         }
+
         interface DeviceCommon extends ObjectCommon {
-            // TODO: any other definition for device?
+            statusStates?: {
+                /** State, which is truthy if a device is online */
+                onlineId?: string;
+                /** State, which is truthy if a device is offline */
+                offlineId?: string;
+                /** State, which is truthy if a device is in error state */
+                errorId?: string;
+            };
+            // Make it possible to narrow the object type using the custom property
+            custom?: undefined;
+        }
 
+        interface ScheduleCommon extends ObjectCommon {
+            enabled?: boolean;
             // Make it possible to narrow the object type using the custom property
             custom?: undefined;
         }
+
+        interface RepositoryCommon extends ObjectCommon {
+            custom?: undefined;
+        }
+
+        interface ChartCommon extends ObjectCommon {
+            enabled?: boolean;
+            // Make it possible to narrow the object type using the custom property
+            custom?: undefined;
+        }
+
         interface EnumCommon extends ObjectCommon {
             /** The IDs of the enum members */
             members?: string[];
@@ -372,21 +974,59 @@ declare global {
         }
 
         interface MetaCommon extends ObjectCommon {
-            // Meta-objects have to additional CommonTypes
-            type: CommonType | 'meta.user' | 'meta.folder';
+            // Can be of type `user` for folders, where a user can store files or `folder` for adapter internal structures
+            type: 'meta.user' | 'meta.folder';
 
             // Make it possible to narrow the object type using the custom property
             custom?: undefined;
         }
 
-        type InstanceMode = 'none' | 'daemon' | 'subscribe' | 'schedule' | 'once' | 'extension';
-        interface InstanceCommon extends ObjectCommon {
+        type InstanceMode = 'none' | 'daemon' | 'schedule' | 'once' | 'extension';
+
+        interface AdminUi {
+            /** UI type of config page inside admin UI */
+            config: 'html' | 'json' | 'materialize' | 'none';
+            /** UI type of custom tab inside admin UI */
+            custom?: 'json';
+            /** UI type of tab inside admin UI */
+            tab?: 'html' | 'json' | 'materialize';
+        }
+
+        /** Installed from attribute of instance/adapter object */
+        type InstalledFrom = Branded<string, 'InstalledFrom'>;
+
+        interface InstanceCommon extends AdapterCommon {
+            version: string;
             /** The name of the host where this instance is running */
             host: string;
             enabled: boolean;
             /** How and when this instance should be started */
             mode: InstanceMode;
-
+            /**
+             * The starting priority of this adapter:
+             * - **1:** Logic adapters
+             * - **2:** Data providers
+             * - **3:** All other adapters
+             */
+            tier?: 1 | 2 | 3;
+            /** Variables of this adapter must be subscribed with sendTo to enable updates */
+            subscribable?: boolean;
+            /** If compact mode is supported */
+            compact?: boolean;
+            /** If compact mode is active */
+            runAsCompactMode?: boolean;
+            /** Active compact group, instances in this group will be started in one process */
+            compactGroup?: number;
+            /** String (or array) with names of attributes in common of instance, which will not be deleted. */
+            preserveSettings?: string | string[];
+            /** Source, where this adapter has been installed from, to enable reinstalling on e.g., backup restore */
+            installedFrom?: InstalledFrom;
+            /** Arguments passed to the adapter process, this disables compact mode */
+            nodeProcessParams?: string[];
+            /** If adapter can consume log messages, like admin, javascript or logparser */
+            logTransporter?: boolean;
+            /** Optional memory limit for this instance */
+            memoryLimitMB?: number;
             // Make it possible to narrow the object type using the custom property
             custom?: undefined;
         }
@@ -394,7 +1034,10 @@ declare global {
         interface HostCommon extends ObjectCommon {
             /** The display name of this host */
             name: string;
+            /** Changeable name of the host */
             title: string;
+            /** base64 encoded icon */
+            icon?: string;
             installedVersion: string; // e.g. 1.2.3 (following semver)
             /** The command line of the executable */
             cmd: string;
@@ -413,7 +1056,7 @@ declare global {
             process: {
                 title: string;
                 versions: NodeJS.ProcessVersions;
-                env: Record<string, string>;
+                env: NodeJS.ProcessEnv;
             };
             os: {
                 hostname: string;
@@ -425,19 +1068,472 @@ declare global {
                 tmpdir: ReturnType<(typeof os)['tmpdir']>;
             };
             hardware: {
-                cpus: ReturnType<(typeof os)['cpus']>;
+                /** Return value of os.cpu but property `times` could be removed from every entry */
+                cpus: (Omit<ReturnType<(typeof os)['cpus']>[number], 'times'> &
+                    Partial<Pick<ReturnType<(typeof os)['cpus']>[number], 'times'>>)[];
                 totalmem: ReturnType<(typeof os)['totalmem']>;
                 networkInterfaces: ReturnType<(typeof os)['networkInterfaces']>;
             };
         }
 
-        type UserCommon = ioBroker.UserCommon;
+        interface UserCommon extends ObjectCommon {
+            /** The username */
+            name: StringOrTranslated;
+            /** The hashed password */
+            password: string;
+            /** Whether this user is enabled */
+            enabled: boolean;
+
+            // Make it possible to narrow the object type using the custom property
+            custom?: undefined;
+        }
+
+        interface GroupCommon extends ObjectCommon {
+            /** The name of this group */
+            name: StringOrTranslated;
+            /** The users of this group */
+            members: ObjectIDs.User[]; // system.user.name, ...
+            /** The default permissions of this group */
+            acl: Omit<PermissionSet, 'user' | 'groups'>;
+            /** A group can be disabled, if missing, a group is active */
+            enabled?: boolean;
+            // Make it possible to narrow the object type using the custom property
+            custom?: undefined;
+        }
 
-        type GroupCommon = ioBroker.GroupCommon;
+        interface ScriptCommon extends ObjectCommon {
+            name: string;
+            /** Defines the type of the script, e.g., TypeScript/ts, Javascript/js or Blockly */
+            engineType: 'TypeScript/ts' | 'Blockly' | 'Rules' | 'Javascript/js';
+            /** The instance id of the instance which executes this script */
+            engine: string;
+            /** The source code of this script */
+            source: string;
+            debug: boolean;
+            verbose: boolean;
+            /** Whether this script should be executed */
+            enabled: boolean;
+            /** Is used to determine whether a script has changed and needs to be recompiled */
+            sourceHash?: string;
+            /** If the script uses a compiled language like TypeScript, this contains the compilation output */
+            compiled?: string;
+            /** If the script uses a compiled language like TypeScript, this contains the generated declarations (global scripts only) */
+            declarations?: string;
 
-        type ScriptCommon = ioBroker.ScriptCommon;
+            // Make it possible to narrow the object type using the custom property
+            custom?: undefined;
+        }
+
+        type WelcomeScreenEntry =
+            | string
+            | {
+                  link: string;
+                  name: string;
+                  img: string;
+                  color: string;
+                  order?: number;
+              };
+
+        /**
+         * Object which defines if the adapter supports receiving messages via sendTo.
+         * Additionally, it defines if specific messages are supported.
+         * If one property is enabled, the object `system.adapter.<adapterName>.<adapterInstance>.messagebox will be created to send messages to the adapter (used for email, pushover, etc...)
+         */
+        interface SupportedMessages {
+            /** If custom messages are supported (same as legacy messagebox) */
+            custom?: boolean;
+            /** If notification handling is supported, for information, see https://github.com/foxriver76/ioBroker.notification-manager#requirements-for-messaging-adapters */
+            notifications?: boolean;
+            /** If adapter supports signal stopInstance. Use number if you need more than 1000 ms for stop routine. The signal will be sent before stop to the adapter. (used if problems occurred with SIGTERM). */
+            stopInstance?: boolean | number;
+            /** If adapter supports the device manager and thus responds to the corresponding messages */
+            deviceManager?: boolean;
+            /** If adapter supports getHistory message. */
+            getHistory?: boolean;
+        }
+
+        type AutoUpgradePolicy = 'none' | 'patch' | 'minor' | 'major';
+
+        interface VisWidget {
+            i18n: 'component' | true | Translated;
+            name: string;
+            url: string;
+            components: string[];
+            /** The vis widget does not support the listed major versions of vis */
+            ignoreInVersions: number[];
+        }
+
+        type PaidLicenseType = 'paid' | 'commercial' | 'limited';
+
+        interface LicenseInformationFree {
+            /** License of the software */
+            license?: string;
+            /** Use 'paid' for adapters which do not work without a paid license. Use 'commercial' for adapters which require a license for commercial use only. Use 'limited' if some functionalities are not available without a paid license. */
+            type: 'free';
+            /**
+             * Hyperlink, where information about the license can be found. For non-free licenses, the linked page should contain information about free features (if applicable), time of validity, link to shop and seller information.
+             * This is required if the license type is different from 'free'. For 'free' licenses, an optional link to the license file can be placed here.
+             */
+            link?: string;
+        }
+
+        interface LicenseInformationWithPayment {
+            /** License of the software */
+            license?: string;
+            /** Use 'paid' for adapters which do not work without a paid license. Use 'commercial' for adapters which require a license for commercial use only. Use 'limited' if some functionalities are not available without a paid license. */
+            type: PaidLicenseType;
+            /**
+             * Hyperlink, where information about the license can be found. For non-free licenses, the linked page should contain information about free features (if applicable), time of validity, link to shop and seller information.
+             * This is required if the license type is different from 'free'. For 'free' licenses, an optional link to the license file can be placed here.
+             */
+            link: string;
+        }
+
+        type LicenseInformation = LicenseInformationFree | LicenseInformationWithPayment;
+
+        interface MessageRule {
+            /** The message title */
+            title: iobJS.Translated;
+            /** The message content */
+            text: iobJS.Translated;
+            /** Optional link */
+            link?: string;
+            /** Text of the link */
+            linkText?: iobJS.Translated;
+            /** The severity level of the message */
+            level: 'warn' | 'error' | 'info';
+            /** The buttons which should be shown on the message dialog */
+            buttons?: ('agree' | 'cancel' | 'ok')[];
+            /** The condition which needs to be met to display the message */
+            condition: {
+                operand: 'and' | 'or';
+                rules: string[];
+            };
+        }
+
+        interface CustomAdminColumn {
+            path: string;
+            name?: iobJS.StringOrTranslated;
+            objTypes?: ObjectType | ObjectType[];
+            width?: number;
+            edit?: boolean;
+            type?: CommonType;
+            align?: 'left' | 'center' | 'right';
+        }
 
-        type AdapterCommon = ioBroker.AdapterCommon;
+        type ConnectionType = 'local' | 'cloud';
+
+        type LocalLink = {
+            /** Link to the web service of this adapter, like: "%web_protocol%://%ip%:%web_port%/vis-2/edit.html" */
+            link: string;
+            /** Name of the link. Could be multi-language */
+            name?: iobJS.StringOrTranslated;
+            /** Color */
+            color?: string;
+            /** Link to icon, like "vis-2/img/favicon.png" */
+            icon?: string;
+            /** Link to the adapter if it could be shown in the free cloud, like: vis-2/index.html according to "https://iobroker.net/" */
+            cloud?: string;
+            /** Link to the adapter if it could be shown in the pro-cloud, like: vis-2/edit.html according to "https://iobroker.pro/" */
+            pro?: string;
+            /** If this link should be shown on the intro tab in admin. false = do not show */
+            intro?: boolean;
+            /** Order of the card. Used on "intro" and cloud tabs to sort the links */
+            order?: number;
+            /** Description of the link. Could be multi-language */
+            description?: iobJS.StringOrTranslated;
+        };
+
+        /** Format for local and global dependencies */
+        type Dependencies = { [adapterName: string]: string }[] | string[];
+
+        interface AdapterCommon extends ObjectCommon {
+            /** Custom attributes to be shown in admin in the object browser */
+            adminColumns?: string | (string | CustomAdminColumn)[];
+            /** Type of the admin UI */
+            adminUI?: AdminUi;
+            /** Settings for custom Admin Tabs */
+            adminTab?: {
+                name?: StringOrTranslated;
+                /** Base 64 icon for the tab */
+                icon?: string;
+                /** @deprecated icon name for FontAwesome (works only in admin 4)*/
+                'fa-icon'?: string;
+                /** If true, the Tab is not reloaded when the configuration changes */
+                ignoreConfigUpdate?: boolean;
+                /** Describes which URL should be loaded in the tab. Supports placeholders like http://%ip%:%port% or JSON(5) configs. If empty `adapter/ADAPTERNAME/tab(_m).html` will be taken. JSON config file must be defined relative to "admin" folder, like "jsonTab.json"  */
+                link?: string;
+                /** If true, only one instance of this tab will be created for all instances */
+                singleton?: boolean;
+                /** Order number in admin tabs */
+                order?: number;
+            };
+            /** If the mode is `schedule`, start one time adapter by ioBroker start, or by the configuration changes */
+            allowInit?: boolean;
+            /** If the adapter should be automatically upgraded and which version ranges are supported */
+            automaticUpgrade?: AutoUpgradePolicy;
+            /** Possible values for the instance mode (if more than one is possible) */
+            availableModes?: InstanceMode[];
+            /** Array which lists all blocked versions. Blocked versions will not be started. Use semver notation to specify the version ranges. The information is always used from the io-package.json in the GitHub repository. */
+            blockedVersions?: string[];
+            /** Whether this adapter includes custom blocks for Blockly. If true, `admin/blockly.js` must exist. */
+            blockly?: boolean;
+            /** Where the adapter will get its data from. Set this together with @see dataSource */
+            connectionType?: ConnectionType;
+            /** If true, this adapter can be started in compact mode (in the same process as other adapters) */
+            compact?: boolean;
+            /** The directory relative to iobroker-data where the adapter stores the data. Supports the placeholder `%INSTANCE%`. This folder will be backed up and restored automatically. */
+            dataFolder?: string;
+            /** How the adapter will mainly receive its data. Set this together with @see connectionType */
+            dataSource?: 'poll' | 'push' | 'assumption';
+            /** A record of ioBroker adapters (including "js-controller") and version ranges which are required for this adapter on the same host. */
+            dependencies?: Dependencies;
+            /** A record of ioBroker adapters (including "js-controller") and version ranges which are required for this adapter in the whole system. */
+            globalDependencies?: Dependencies;
+            /** Similar to `dependencies`, but only checked if the specified adapter is already installed. If the adapter is not installed, the version check will pass */
+            ifInstalledDependencies?: { [adapterName: string]: string };
+            /** Which files outside the README.md have documentation for the adapter */
+            docs?: Partial<Record<Languages, string | string[]>>;
+            /** Whether new instances should be enabled by default. *Should* be `false`! */
+            enabled: boolean;
+            /** If true, all previous data in the target directory (web) should be deleted before uploading */
+            eraseOnUpload?: boolean;
+            /** URL of an external icon that is shown for adapters that are not installed */
+            extIcon?: string;
+            /** Whether this adapter responds to `getHistory` messages */
+            getHistory?: boolean;
+            /** Filename of the local icon which is shown for installed adapters. Should be located in the `admin` directory */
+            icon?: string;
+            /** The adapter will be executed once additionally after installation, and the `install` event will be emitted during this run. This allows for executing one time installation code. */
+            install?: boolean;
+            /** Source, where this adapter has been installed from, to enable reinstalling on e.g., backup restore */
+            installedFrom?: InstalledFrom;
+            /** Shows which version of this adapter is installed */
+            installedVersion: string;
+            /** Keywords are used by search in admin. Do not write ioBroker here */
+            keywords?: string[];
+            /** A dictionary of links to web services this adapter provides */
+            localLinks?: Record<string, string | LocalLink>;
+            /** @deprecated Use @see localLinks */
+            localLink?: string;
+            /** Default log level for this adapter. It can be changed for every instance separately */
+            loglevel?: LogLevel;
+            /** Whether this adapter receives logs from other hosts and adapters (e.g., to store them somewhere) */
+            logTransporter?: boolean;
+            /** Path to the start file of the adapter. Should be the same as in `package.json` */
+            main?: string;
+            /** Whether the admin tab is written in materialized style. Required for Admin 3+ */
+            materializeTab?: boolean;
+            /** Whether the admin configuration dialog is written in materialized style. Required for Admin 3+ */
+            materialize: boolean;
+            /** @deprecated Use @see supportedMessages up from controller v5 */
+            messagebox?: true;
+            /** Messages which are supported by the adapter, supportedMessages.custom: true is the equivalent to messagebox: true */
+            supportedMessages?: SupportedMessages;
+            /** Running mode: `none`, `daemon`, `schedule`, `once`, `extension` */
+            mode: InstanceMode;
+            /** Name of the adapter (without leading `ioBroker.`) */
+            name: string;
+            /** News per version in i18n */
+            news?: { [version: string]: Translated };
+            /** If `true`, no configuration dialog will be shown */
+            noConfig?: true;
+            /** If `true`, this adapter's instances will not be shown in the admin overview screen. Useful for icon sets and widgets... */
+            noIntro?: true;
+            /** Set to `true` if the adapter is not available in the official ioBroker repositories. */
+            noRepository?: true;
+            /** If `true`, manual installation from GitHub is not possible */
+            nogit?: true;
+            /** If `true`, this adapter cannot be deleted or updated manually. */
+            nondeletable?: true;
+            /** If `true`, this "adapter" only contains HTML files and no main executable */
+            onlyWWW?: boolean;
+            /** Used to configure native (OS) dependencies of this adapter that need to be installed with system package manager before installing the adapter */
+            osDependencies?: {
+                /** For OSX */
+                darwin: string[];
+                /** For Linux */
+                linux: string[];
+                /** For Windows */
+                win32: string[];
+            };
+            /** Which OSes this adapter supports */
+            os?: 'linux' | 'darwin' | 'win32' | Array<'linux' | 'darwin' | 'win32'>;
+            /** Constant */
+            platform: 'Javascript/Node.js';
+            /** The keys of common attributes (e.g. `history`) which are not deleted in a `setObject` call even if they are not present. Deletion must be done explicitly by setting them to `null`. */
+            preserveSettings?: string | string[];
+            /** Url of the ReadMe file */
+            readme?: string;
+            /** Which adapters must be restarted after installing or updating this adapter. */
+            restartAdapters?: string[];
+            /** CRON schedule to restart mode `daemon` adapters */
+            restartSchedule?: string;
+            /** If the adapter runs in `schedule` mode, this contains the CRON */
+            schedule?: string;
+            /** Whether this adapter may only be installed once per host */
+            singletonHost?: boolean;
+            /** Whether this adapter may only be installed once in the whole system */
+            singleton?: boolean;
+            /** Whether the adapter must be stopped before an update */
+            stopBeforeUpdate?: boolean;
+            /** Overrides the default timeout that ioBroker will wait before force-stopping the adapter */
+            stopTimeout?: number;
+            /** This adapter supports a special mode: if someone subscribes on its states, it starts to read them. It is done to save the bandwidth or load of the slave device */
+            subscribable?: boolean;
+            /** If `true`, this adapter provides custom per-state settings. Requires a `custom_m.html` file in the `admin` directory. */
+            supportCustoms?: boolean;
+            /** @deprecated Use @see supportedMessages up from controller v5 */
+            supportStopInstance?: boolean;
+            /** The translated names of this adapter to be shown in the admin UI */
+            titleLang?: StringOrTranslated;
+            /** @deprecated The name of this adapter to be shown in the admin UI. Use @see titleLang instead. */
+            title?: string;
+            /** The type of this adapter */
+            type?:
+                | 'alarm'
+                | 'climate-control'
+                | 'communication'
+                | 'date-and-time'
+                | 'energy'
+                | 'garden'
+                | 'general'
+                | 'geoposition'
+                | 'hardware'
+                | 'health'
+                | 'household'
+                | 'infrastructure'
+                | 'iot-systems'
+                | 'lighting'
+                | 'logic'
+                | 'messaging'
+                | 'metering'
+                | 'misc-data'
+                | 'multimedia'
+                | 'network'
+                | 'protocols'
+                | 'storage'
+                | 'utility'
+                | 'vehicle'
+                | 'visualization'
+                | 'visualization-icons'
+                | 'visualization-widgets'
+                | 'weather';
+            /** If `true`, the `npm` package must be installed with the `--unsafe-perm` flag */
+            unsafePerm?: true;
+            /** The available version in the ioBroker repo. */
+            version: string;
+            /** Definition of the vis-2 widgets */
+            visWidgets?: Record<string, VisWidget>;
+            /** Include the adapter version in the URL of the web adapter, e.g. `http://ip:port/1.2.3/material` instead of `http://ip:port/material` */
+            webByVersion?: boolean;
+            /** Whether the web server in this adapter can be extended with plugin/extensions */
+            webExtendable?: boolean;
+            /** Relative path to a module that contains an extension for the web adapter. Use together with @see native.webInstance to configure which instances this affects */
+            webExtension?: string;
+            /** List of parameters that must be included in info.js by webServer adapter. (Example material: `"webPreSettings": { "materialBackground": "native.loadingBackground" }`). Web adapter uses this setting to create a customized info.js file to provide some essential settings for index.html file before the socket connection is established to provide e.g., background color of the loading screen. */
+            webPreSettings?: Record<string, any>;
+            /** @deprecated (where is it necessary?) Array of web server's instances that should serve content from the adapter's www folder */
+            webservers?: string[];
+            /** @deprecated (use localLinks) A list of pages that should be shown on the "web" index page */
+            welcomeScreen?: WelcomeScreenEntry[];
+            /** @deprecated (use localLinks) A list of pages that should be shown on the ioBroker cloud index page */
+            welcomeScreenPro?: WelcomeScreenEntry[];
+            /** @deprecated (rename the `www` folder in e.g. `adminWww`) If true, the `www` folder will be not uploaded into DB */
+            wwwDontUpload?: boolean;
+            /** @deprecated Use 'common.licenseInformation' instead */
+            license?: string;
+            /** An object representing information with the license details */
+            licenseInformation?: LicenseInformation;
+            /** Messages, that will be shown (if condition evaluates to true) by upgrade or installation */
+            messages?: MessageRule[];
+            /** If a specific update of this adapter should be ignored, specifies version number to be ignored */
+            ignoreVersion?: string;
+            /** Sentry and other plugins */
+            plugins?: { [pluginName: string]: Record<string, any> };
+            /** Rules blocks for JavaScript rules */
+            javascriptRules?: {
+                /** Translations */
+                i18n?: boolean | Record<string, Record<iobJS.Languages, string>> | Record<string, string>;
+                /** Where to load the blocks, like "rules/customRuleBlocks.js" */
+                url: string;
+                /** Rules block name, like "ActionTelegram" */
+                name: string;
+                /** Load it as TypeScript module */
+                type?: 'module';
+            };
+
+            // Make it possible to narrow the object type using the custom property
+            custom?: undefined;
+        }
+
+        interface SystemConfigCommon extends ObjectCommon {
+            /** Name of all active repositories */
+            activeRepo: string[];
+            /** Current configured language */
+            language: Languages;
+            /** If floating comma is used instead of dot */
+            isFloatComma: boolean;
+            /** Configured longitude */
+            longitude?: number;
+            /** Configured latitude */
+            latitude?: number;
+            /** Optional user's city (only for diagnostics) */
+            city?: string;
+            /** Optional user's country (only for diagnostics) */
+            country?: string;
+            /** User-defined temperature unit */
+            tempUnit?: '°C' | '°F';
+            /** User-defined currency */
+            currency?: string;
+            /** User-defined first day of the week */
+            firstDayOfWeek?: 'monday' | 'sunday';
+            /** Default history instance */
+            defaultHistory: string;
+            /** Which diag data is allowed to be sent */
+            diag: 'none' | 'extended' | 'no-city';
+            /** If license has already been confirmed */
+            licenseConfirmed: boolean;
+            /** System wide default log level */
+            defaultLogLevel?: LogLevel;
+            /** Used date format for formatting */
+            dateFormat: string;
+            /** This name will be shown in admin's header. Just to identify the whole installation */
+            siteName?: string;
+            /** Default acl for new objects */
+            defaultNewAcl: {
+                object: number;
+                state: number;
+                file: number;
+                owner: ObjectIDs.User;
+                ownerGroup: ObjectIDs.Group;
+            };
+            /** Configured auto upgrade policy */
+            adapterAutoUpgrade?: {
+                /** Configuration for each repository */
+                repositories: {
+                    [repoName: string]: boolean;
+                };
+                /** Default policy, if none has been set explicit for the adapter */
+                defaultPolicy: AutoUpgradePolicy;
+            };
+            /** Deactivated instances, that should not be shown in admin/Intro page */
+            intro?: string[];
+            /** Defines which tabs are visible in the left menu of the admin */
+            tabsVisible?: {
+                /** Name of the tab */
+                name: string;
+                /** If the tab should be visible */
+                visible: boolean;
+                /** Optional color of the tab */
+                color?: string;
+            }[];
+            /** Global saved expert mode for admin */
+            expertMode?: boolean;
+
+            // Make it possible to narrow the object type using the custom property
+            custom?: undefined;
+        }
 
         interface OtherCommon extends ObjectCommon {
             [propName: string]: any;
@@ -446,6 +1542,24 @@ declare global {
             custom?: undefined;
         }
 
+        /**
+         * ioBroker has built-in protection for specific attributes of objects. If this protection is installed in the object, then the protected attributes of an object cannot be changed by the user without a valid password.
+         * To protect the properties from change, the special attribute "nonEdit" must be added to the object. This attribute contains the password, which is required to change the object.
+         * If an object does not have "nonEdit" attribute, so the hash will be saved into "nonEdit.passHash". After that, if someone changes the object, he must provide the password in "nonEdit.password".
+         * If the password is correct, the object attributes will be updated. If the password is wrong, the object will not be changed.
+         * Note, that all properties outside "nonEdit" can be updated without providing the password. Furthermore, do not confuse e.g. "nonEdit.common" with "obj.common" they are not linked in any way.
+         */
+        interface NonEditable {
+            /** Password needed to edit non-editable information */
+            password?: string;
+            /** Hashed version of current password */
+            passHash?: string;
+            /** These properties can only be changed by providing the password, else they stay on the initial value */
+            common?: Record<string, any>;
+            /** These properties can only be changed by providing the password, else they stay on the initial value */
+            native?: Record<string, any>;
+        }
+
         /* Base type for Objects. Should not be used directly */
         interface BaseObject {
             /** The ID of this object */
@@ -455,12 +1569,14 @@ declare global {
             // without bugging users to change their code --> https://github.com/microsoft/TypeScript/issues/15300
             native: Record<string, any>;
             common: Record<string, any>;
-            enums?: Record<string, string>;
+            enums?: Record<string, string | Translated>;
             acl?: ObjectACL;
             from?: string;
             /** The user who created or updated this object */
             user?: string;
             ts?: number;
+            /** These properties can only be edited if the correct password is provided */
+            nonEdit?: NonEditable;
         }
 
         interface StateObject extends BaseObject {
@@ -472,6 +1588,7 @@ declare global {
             /** The names of enums this state is assigned to. For example ["Licht","Garten"] */
             enumNames?: Array<iobJS.StringOrTranslated>;
         }
+
         interface PartialStateObject extends Partial<Omit<StateObject, 'common' | 'acl'>> {
             common?: Partial<StateCommon>;
             acl?: Partial<StateACL>;
@@ -481,6 +1598,7 @@ declare global {
             type: 'channel';
             common: ChannelCommon;
         }
+
         interface PartialChannelObject extends Partial<Omit<ChannelObject, 'common'>> {
             common?: Partial<ChannelCommon>;
         }
@@ -489,6 +1607,7 @@ declare global {
             type: 'device';
             common: DeviceCommon;
         }
+
         interface PartialDeviceObject extends Partial<Omit<DeviceObject, 'common'>> {
             common?: Partial<DeviceCommon>;
         }
@@ -498,6 +1617,7 @@ declare global {
             // Nothing is set in stone here, so start with allowing every property
             common: OtherCommon;
         }
+
         interface PartialFolderObject extends Partial<Omit<FolderObject, 'common'>> {
             common?: Partial<OtherCommon>;
         }
@@ -506,6 +1626,7 @@ declare global {
             type: 'enum';
             common: EnumCommon;
         }
+
         interface PartialEnumObject extends Partial<Omit<EnumObject, 'common'>> {
             common?: Partial<EnumCommon>;
         }
@@ -514,52 +1635,190 @@ declare global {
             type: 'meta';
             common: MetaCommon;
         }
+
         interface PartialMetaObject extends Partial<Omit<MetaObject, 'common'>> {
             common?: Partial<MetaCommon>;
         }
 
-        interface InstanceObject extends BaseObject {
+        interface ChartObject extends BaseObject {
+            type: 'chart';
+            common: ChartCommon;
+        }
+
+        type PartialChartObject = ChartObject;
+
+        interface ScheduleObject extends BaseObject {
+            type: 'schedule';
+            common: ScheduleCommon;
+        }
+
+        interface PartialScheduleObject extends Partial<Omit<ScheduleObject, 'common'>> {
+            common?: Partial<ScheduleCommon>;
+        }
+
+        interface PartialRepositoryObject extends Partial<Omit<RepositoryObject, 'common'>> {
+            common?: Partial<RepositoryCommon>;
+        }
+
+        interface RepositoryJsonAdapterContent {
+            /** Adapter name */
+            name: string;
+            /** Newest available version */
+            version: string;
+            /** Array of blocked versions, each entry represents a semver range */
+            blockedVersions: string[];
+            /** If true, the unsafe perm flag is needed on install */
+            unsafePerm?: boolean;
+            /** If given, the packet name differs from the adapter name, e.g. because it is a scoped package */
+            packetName?: string;
+
+            /** Other Adapter related properties, not important for this implementation */
+            [other: string]: unknown;
+        }
+
+        interface RepoInfo {
+            /** If it is the official stable repository */
+            stable?: boolean;
+            /** i18n name of the repository */
+            name: Required<iobJS.Translated>;
+            /** Time of repository update */
+            repoTime: string;
+        }
+
+        interface RepositoryJson {
+            /** Information about the repository: creation time, name, is it stable */
+            _repoInfo: RepoInfo;
+
+            /** Information about each adapter */
+            [adapter: string]: RepositoryJsonAdapterContent | RepoInfo;
+        }
+
+        interface RepositoryInformation {
+            /** Url to the repository */
+            link: string;
+            json: RepositoryJson | null;
+            hash?: string;
+            time?: string;
+            /** If this repository stable */
+            stable?: boolean;
+        }
+
+        interface RepositoryObject extends BaseObject {
+            _id: ObjectIDs.Repository;
+            type: 'config';
+            native: {
+                repositories: {
+                    [repoName: string]: RepositoryInformation;
+                };
+                oldRepositories?: {
+                    [repoName: string]: RepositoryInformation;
+                };
+            };
+            common: RepositoryCommon;
+        }
+
+        interface InstanceObject extends Omit<AdapterObject, 'type'>, BaseObject {
+            _id: ObjectIDs.Instance;
             type: 'instance';
             common: InstanceCommon;
         }
+
         interface PartialInstanceObject extends Partial<Omit<InstanceObject, 'common'>> {
             common?: Partial<InstanceCommon>;
         }
 
+        // it is defined in notificationHandler.ts
+        type NotificationCategory = {
+            /** The unique category identifier */
+            category:
+                | 'memIssues'
+                | 'fsIoErrors'
+                | 'noDiskSpace'
+                | 'accessErrors'
+                | 'nonExistingFileErrors'
+                | 'remoteHostErrors'
+                | 'restartLoop'
+                | 'fileToJsonl'
+                | 'automaticAdapterUpgradeFailed'
+                | 'automaticAdapterUpgradeSuccessful'
+                | 'blockedVersions'
+                | 'databaseErrors'
+                | 'securityIssues'
+                | 'packageUpdates'
+                | 'systemRebootRequired'
+                | 'diskSpaceIssues'
+                | (string & {});
+            /** The human-readable category name */
+            name: Translated;
+            /** The human-readable category description */
+            description: Translated;
+            /** Allows to define the severity of the notification with `info` being the lowest `notify` representing middle priority, `alert` representing high priority and often containing critical information */
+            severity: 'info' | 'notify' | 'alert';
+            /** If a regex is specified, the js-controller will check error messages on adapter crashes against this regex and will generate a notification of this category */
+            regex: string[];
+            /** Deletes older messages if more than the specified amount is present for this category */
+            limit: number;
+        };
+
+        interface Notification {
+            /** E.g., `system`. Each adapter can define its own "scopes" for own notifications with its own categories which then will be available in the system. Adapters should only register one scope which matches the name of the adapter. */
+            scope: string;
+            /** The human-readable name of this scope */
+            name: Translated;
+            /** The human-readable description of this scope */
+            description: Translated;
+            /** All notification categories of this scope */
+            categories: NotificationCategory[];
+        }
+
         interface AdapterObject extends BaseObject {
+            _id: ObjectIDs.Adapter;
             type: 'adapter';
             common: AdapterCommon;
             /** An array of `native` properties which cannot be accessed from outside the defining adapter */
             protectedNative?: string[];
             /** Like protectedNative, but the properties are also encrypted and decrypted automatically */
             encryptedNative?: string[];
+            /** Register notifications for the built-in notification system */
+            notifications?: Notification[];
+            /** Objects created for each instance, inside the namespace of this adapter */
+            instanceObjects: (StateObject | DeviceObject | ChannelObject | FolderObject | MetaObject)[];
+            /** Objects created for the adapter, anywhere in the global namespace */
+            objects: iobJS.AnyObject[];
         }
+
         interface PartialAdapterObject extends Partial<Omit<AdapterObject, 'common'>> {
             common?: Partial<AdapterCommon>;
         }
 
         interface HostObject extends BaseObject {
+            _id: ObjectIDs.Host;
             type: 'host';
             common: HostCommon;
             native: HostNative;
         }
+
         interface PartialHostObject extends Partial<Omit<HostObject, 'common' | 'native'>> {
             common?: Partial<HostCommon>;
             native?: Partial<HostNative>;
         }
 
         interface UserObject extends BaseObject {
+            _id: ObjectIDs.User;
             type: 'user';
             common: UserCommon;
         }
+
         interface PartialUserObject extends Partial<Omit<UserObject, 'common'>> {
             common?: Partial<UserCommon>;
         }
 
         interface GroupObject extends BaseObject {
+            _id: ObjectIDs.Group;
             type: 'group';
             common: GroupCommon;
         }
+
         interface PartialGroupObject extends Partial<Omit<GroupObject, 'common'>> {
             common?: Partial<GroupCommon>;
         }
@@ -568,18 +1827,42 @@ declare global {
             type: 'script';
             common: ScriptCommon;
         }
+
         interface PartialScriptObject extends Partial<Omit<ScriptObject, 'common'>> {
             common?: Partial<ScriptCommon>;
         }
 
+        interface SystemConfigObject extends BaseObject {
+            type: 'config';
+            common: SystemConfigCommon;
+        }
+
+        interface PartialSystemConfigObject extends Partial<Omit<SystemConfigObject, 'common'>> {
+            common?: Partial<SystemConfigCommon>;
+        }
+
         interface OtherObject extends BaseObject {
             type: 'config' | 'chart';
             common: OtherCommon;
         }
+
         interface PartialOtherObject extends Partial<Omit<OtherObject, 'common'>> {
             common?: Partial<OtherCommon>;
         }
 
+        interface DesignObject extends Omit<BaseObject, 'common'> {
+            // allow narrowing the type without making it a pain
+            type: 'design';
+            _id: ObjectIDs.Design;
+            language: 'javascript';
+            common?: OtherCommon;
+            views: Record<string, { map: string }>;
+        }
+
+        interface PartialDesignObject extends Partial<Omit<DesignObject, 'common'>> {
+            common?: Partial<OtherCommon>;
+        }
+
         type AnyObject =
             | StateObject
             | ChannelObject
@@ -593,7 +1876,11 @@ declare global {
             | UserObject
             | GroupObject
             | ScriptObject
-            | OtherObject;
+            | ChartObject
+            | ScheduleObject
+            | RepositoryObject
+            | OtherObject
+            | DesignObject;
 
         type AnyPartialObject =
             | PartialStateObject
@@ -608,14 +1895,22 @@ declare global {
             | PartialUserObject
             | PartialGroupObject
             | PartialScriptObject
-            | PartialOtherObject;
+            | PartialChartObject
+            | PartialScheduleObject
+            | PartialRepositoryObject
+            | PartialSystemConfigObject
+            | PartialOtherObject
+            | PartialDesignObject;
 
         /** All objects that usually appear in an adapter scope */
         type AdapterScopedObject = FolderObject | DeviceObject | ChannelObject | StateObject;
 
-        // For all objects that are exposed to the user we need to tone the strictness down.
+        // For all objects that are exposed to the user, we need to tone the strictness down.
         // Otherwise, every operation on objects becomes a pain to work with
-        type Object = AnyObject;
+        type Object = AnyObject & {
+            common: Record<string, any>;
+            native: Record<string, any>;
+        };
 
         // In set[Foreign]Object[NotExists] methods, the ID and acl of the object is optional
         type SettableObjectWorker<T> = T extends AnyObject
@@ -629,6 +1924,86 @@ declare global {
 
         type PartialObject<T extends AnyObject = AnyObject> = PartialObjectWorker<T>;
 
+        // Used to infer the return type of GetObjectView
+        type InferGetObjectViewItemType<Design extends string, View extends string> = Design extends 'system'
+            ? View extends 'host'
+                ? HostObject
+                : View extends 'adapter'
+                  ? AdapterObject
+                  : View extends 'instance'
+                    ? InstanceObject
+                    : View extends 'meta'
+                      ? MetaObject
+                      : View extends 'device'
+                        ? DeviceObject
+                        : View extends 'channel'
+                          ? ChannelObject
+                          : View extends 'state'
+                            ? StateObject
+                            : View extends 'folder'
+                              ? FolderObject
+                              : View extends 'enum'
+                                ? EnumObject
+                                : View extends 'script'
+                                  ? ScriptObject
+                                  : View extends 'group'
+                                    ? GroupObject
+                                    : View extends 'user'
+                                      ? UserObject
+                                      : View extends 'chart'
+                                        ? ChartObject
+                                        : View extends 'schedule'
+                                          ? ScheduleObject
+                                          : View extends 'config'
+                                            ?
+                                                  | RepositoryObject
+                                                  | SystemConfigObject
+                                                  | (OtherObject & {
+                                                        type: 'config';
+                                                    })
+                                            : View extends 'custom'
+                                              ? NonNullable<StateObject['common']['custom']>
+                                              : iobJS.Object
+            : any;
+
+        enum StateQuality {
+            good = 0x00, // or undefined or null
+            bad = 0x01,
+            general_device_problem = 0x41,
+            general_sensor_problem = 0x81,
+            device_not_connected = 0x42,
+            sensor_not_connected = 0x82,
+            device_reports_error = 0x44,
+            sensor_reports_error = 0x84,
+        }
+
+        interface TypedState<T extends iobJS.StateValue = any> extends iobJS.State {
+            val: T;
+            notExist?: true;
+        }
+
+        interface AbsentState extends Omit<iobJS.State, 'ack' | 'from' | 'ts' | 'lc'> {
+            val: null;
+            notExist: true;
+
+            ack: undefined;
+            ts: undefined;
+            lc: undefined;
+            from: undefined;
+            expire: undefined;
+            q: undefined;
+            c: undefined;
+        }
+
+        interface StateCommonAlias {
+            /** The target state id or two target states used for reading and writing values */
+            id: string | { read: string; write: string };
+            /** An optional conversion function when reading, e.g. `"(val − 32) * 5/9"` */
+            read?: string;
+            /** An optional conversion function when reading, e.g. `"(val * 9/5) + 32"` */
+            write?: string;
+        }
+
         // Convenient definitions for manually specifying settable object types
         type SettableObject<T extends AnyObject = AnyObject> = SettableObjectWorker<T>;
         type SettableStateObject = SettableObject<StateObject>;
@@ -646,7 +2021,7 @@ declare global {
         type SettableOtherObject = SettableObject<OtherObject>;
 
         /** Represents the change of a state */
-        interface ChangedStateObject<TOld extends ioBroker.StateValue = any, TNew extends ioBroker.StateValue = TOld>
+        interface ChangedStateObject<TOld extends iobJS.StateValue = any, TNew extends iobJS.StateValue = TOld>
             extends StateObject {
             common: StateCommon;
             native: Record<string, any>;
@@ -682,13 +2057,9 @@ declare global {
         ) => void | Promise<void>;
         type ExistsStateCallback = (err?: Error | null, exists?: boolean) => void | Promise<void>;
 
-        type SetStateCallback = (err?: Error | null, id?: string) => void | Promise<void>;
-        type SetStatePromise = Promise<NonNullCallbackReturnTypeOf<SetStateCallback>>;
-
         type StateChangeHandler<TOld extends ioBroker.StateValue = any, TNew extends TOld = any> = (
             obj: ChangedStateObject<TOld, TNew>,
         ) => void | Promise<void>;
-        type ObjectChangeHandler = (id: string, obj: iobJS.Object) => void | Promise<void>;
 
         type FileChangeHandler<WithFile extends boolean> =
             // Variant 1: WithFile is false, data/mimeType is definitely not there
@@ -732,17 +2103,6 @@ declare global {
         type ReadFileCallback = (err?: Error | null, file?: Buffer | string, mimeType?: string) => void | Promise<void>;
         type ReadFilePromise = Promise<NonNullCallbackReturnTypeOf<ReadFileCallback>>;
 
-        /** Callback information for a passed message */
-        interface MessageCallbackInfo {
-            /** The original message payload */
-            message: string | object;
-            /** ID of this callback */
-            id: number;
-            // ???
-            ack: boolean;
-            /** Timestamp of this message */
-            time: number;
-        }
         type MessageCallback = (result?: any) => void | Promise<void>;
 
         interface SendToOptions {
@@ -763,10 +2123,10 @@ declare global {
             /** name is equal or matches to given one */
             name?: string | string[] | RegExp;
             /** type of change */
-            change?: 'eq' | 'ne' | 'gt' | 'ge' | 'lt' | 'le' | 'any';
-            val?: ioBroker.StateValue;
+            change?: 'eq' | 'ne' | 'gt' | 'ge' | 'lt' | 'le' | 'any' | '*';
+            val?: iobJS.StateValue;
             /** New value must not be equal to given one */
-            valNe?: ioBroker.StateValue;
+            valNe?: iobJS.StateValue;
             /** New value must be greater than given one */
             valGt?: number;
             /** New value must be greater or equal to given one */
@@ -778,9 +2138,9 @@ declare global {
             /** The acknowledged state of new value is equal to given one */
             ack?: boolean;
             /** Previous value must be equal to given one */
-            oldVal?: ioBroker.StateValue;
+            oldVal?: iobJS.StateValue;
             /** Previous value must be not equal to given one */
-            oldValNe?: ioBroker.StateValue;
+            oldValNe?: iobJS.StateValue;
             /** The previous value must be greater than given one */
             oldValGt?: number;
             /** Previous value must be greater or equal given one */
@@ -878,9 +2238,9 @@ declare global {
              * this can be called synchronously and immediately returns the state.
              * Otherwise, you need to provide a callback.
              */
-            getState<T extends ioBroker.StateValue = any>(callback: GetStateCallback<T>): void;
-            getState<T extends ioBroker.StateValue = any>(): TypedState<T> | null | undefined;
-            getStateAsync<T extends ioBroker.StateValue = any>(): Promise<
+            getState<T extends iobJS.StateValue = any>(callback: GetStateCallback<T>): void;
+            getState<T extends iobJS.StateValue = any>(): TypedState<T> | iobJS.AbsentState | null | undefined;
+            getStateAsync<T extends iobJS.StateValue = any>(): Promise<
                 TypedState<T> | iobJS.AbsentState | null | undefined
             >;
 
@@ -888,16 +2248,16 @@ declare global {
              * Sets all queried states to the given value.
              */
             setState(
-                state: ioBroker.StateValue | ioBroker.SettableState,
+                state: iobJS.StateValue | iobJS.SettableState,
                 ack?: boolean | 'true' | 'false' | SetStateCallback,
                 callback?: SetStateCallback,
             ): this;
             setStateAsync(
-                state: ioBroker.StateValue | ioBroker.SettableState,
+                state: iobJS.StateValue | iobJS.SettableState,
                 ack?: boolean | 'true' | 'false',
             ): Promise<void>;
             setStateDelayed(
-                state: ioBroker.StateValue | ioBroker.SettableState,
+                state: iobJS.StateValue | iobJS.SettableState,
                 isAck: boolean | number | undefined,
                 delay?: number | boolean,
                 clearRunning?: boolean | (() => void),
@@ -908,11 +2268,11 @@ declare global {
              * Sets all queried states to the given value only if the value really changed.
              */
             setStateChanged(
-                state: ioBroker.StateValue | ioBroker.SettableState,
+                state: iobJS.StateValue | iobJS.SettableState,
                 ack?: boolean,
                 callback?: SetStateCallback,
             ): this;
-            setStateChangedAsync(state: ioBroker.StateValue | ioBroker.SettableState, ack?: boolean): Promise<void>;
+            setStateChangedAsync(state: iobJS.StateValue | iobJS.SettableState, ack?: boolean): Promise<void>;
 
             /**
              * Subscribes the given callback to changes of the matched states.
@@ -1046,13 +2406,6 @@ declare global {
             id: string;
         }
 
-        interface LogMessage {
-            severity: LogLevel; // severity
-            ts: number; // timestamp as Date.now()
-            message: string; // message
-            from: string; // origin of the message
-        }
-
         type SchedulePattern = ScheduleRule | ScheduleRuleConditional | Date | string | number;
 
         interface SubscribeTime {
@@ -1359,19 +2712,19 @@ declare global {
      */
     function setState(
         id: string,
-        state: ioBroker.StateValue | ioBroker.SettableState,
+        state: iobJS.StateValue | iobJS.SettableState,
         callback?: iobJS.SetStateCallback,
     ): void;
     function setState(
         id: string,
-        state: ioBroker.StateValue | ioBroker.SettableState,
+        state: iobJS.StateValue | iobJS.SettableState,
         ack: boolean,
         callback?: iobJS.SetStateCallback,
     ): void;
 
     function setStateAsync(
         id: string,
-        state: ioBroker.StateValue | ioBroker.SettableState,
+        state: iobJS.StateValue | iobJS.SettableState,
         ack?: boolean,
     ): iobJS.SetStatePromise;
 
@@ -1384,19 +2737,19 @@ declare global {
      */
     function setStateChanged(
         id: string,
-        state: ioBroker.StateValue | ioBroker.SettableState,
+        state: iobJS.StateValue | iobJS.SettableState,
         callback?: iobJS.SetStateCallback,
     ): void;
     function setStateChanged(
         id: string,
-        state: ioBroker.StateValue | ioBroker.SettableState,
+        state: iobJS.StateValue | iobJS.SettableState,
         ack: boolean,
         callback?: iobJS.SetStateCallback,
     ): void;
 
     function setStateChangedAsync(
         id: string,
-        state: ioBroker.StateValue | ioBroker.SettableState,
+        state: iobJS.StateValue | iobJS.SettableState,
         ack?: boolean,
     ): iobJS.SetStatePromise;
 
@@ -1413,39 +2766,39 @@ declare global {
      */
     function setStateDelayed(
         id: string,
-        state: ioBroker.StateValue | ioBroker.SettableState,
+        state: iobJS.StateValue | iobJS.SettableState,
         delay: number,
         clearRunning: boolean,
         callback?: iobJS.SetStateCallback,
     ): number | null;
     function setStateDelayed(
         id: string,
-        state: ioBroker.StateValue | ioBroker.SettableState,
+        state: iobJS.StateValue | iobJS.SettableState,
         ack: boolean,
         clearRunning: boolean,
         callback?: iobJS.SetStateCallback,
     ): number | null;
     function setStateDelayed(
         id: string,
-        state: ioBroker.StateValue | ioBroker.SettableState,
+        state: iobJS.StateValue | iobJS.SettableState,
         ack: boolean,
         delay: number,
         callback?: iobJS.SetStateCallback,
     ): number | null;
     function setStateDelayed(
         id: string,
-        state: ioBroker.StateValue | ioBroker.SettableState,
+        state: iobJS.StateValue | iobJS.SettableState,
         delay: number,
         callback?: iobJS.SetStateCallback,
     ): number | null;
     function setStateDelayed(
         id: string,
-        state: ioBroker.StateValue | ioBroker.SettableState,
+        state: iobJS.StateValue | iobJS.SettableState,
         callback?: iobJS.SetStateCallback,
     ): number | null;
     function setStateDelayed(
         id: string,
-        state: ioBroker.StateValue | ioBroker.SettableState,
+        state: iobJS.StateValue | iobJS.SettableState,
         ack: boolean,
         delay: number,
         clearRunning: boolean,
@@ -1479,9 +2832,9 @@ declare global {
      * this can be called synchronously and immediately returns the state.
      * Otherwise, you need to provide a callback.
      */
-    function getState<T extends ioBroker.StateValue = any>(id: string, callback: iobJS.GetStateCallback<T>): void;
-    function getState<T extends ioBroker.StateValue = any>(id: string): iobJS.TypedState<T> | iobJS.AbsentState;
-    function getStateAsync<T extends ioBroker.StateValue = any>(id: string): Promise<iobJS.TypedState<T>>;
+    function getState<T extends iobJS.StateValue = any>(id: string, callback: iobJS.GetStateCallback<T>): void;
+    function getState<T extends iobJS.StateValue = any>(id: string): iobJS.TypedState<T> | iobJS.AbsentState;
+    function getStateAsync<T extends iobJS.StateValue = any>(id: string): Promise<iobJS.TypedState<T>>;
 
     /**
      * Checks if the state with the given ID exists
@@ -1509,7 +2862,7 @@ declare global {
      * @param id Object ID
      * @param enumName Which enum should be included in the returned object. `true` to return all enums.
      */
-    function getObject<T extends string>(id: T, enumName?: string | true): iobJS.ObjectIdToObjectType<T, 'read'>;
+    function getObject<T extends string>(id: T, enumName?: string | true): iobJS.ObjectIdToObjectType<T>;
     function getObject<T extends string>(id: T, callback: iobJS.GetObjectCallback<T>): void;
     function getObject<T extends string>(id: T, enumName: string | true, callback: iobJS.GetObjectCallback<T>): void;
     function getObjectAsync<T extends string>(id: T, enumName?: string | true): iobJS.GetObjectPromise<T>;
@@ -1526,7 +2879,7 @@ declare global {
     function deleteObject(id: string, recursive: boolean, callback?: ErrorCallback): void;
     function deleteObjectAsync(id: string, recursive?: boolean): Promise<void>;
 
-    function getEnums(enumName?: string): { id: string; members: string[]; name: ioBroker.StringOrTranslated }[];
+    function getEnums(enumName?: string): { id: string; members: string[]; name: iobJS.StringOrTranslated }[];
 
     /**
      * Creates a state and the corresponding object under the JavaScript namespace.
@@ -1540,7 +2893,7 @@ declare global {
      */
     function createState(
         name: string,
-        initValue: ioBroker.StateValue,
+        initValue: iobJS.StateValue,
         forceCreation: boolean,
         common: Partial<iobJS.StateCommon>,
         native: any,
@@ -1548,24 +2901,24 @@ declare global {
     ): void;
     function createState(
         name: string,
-        initValue: ioBroker.StateValue,
+        initValue: iobJS.StateValue,
         forceCreation: boolean,
         common: Partial<iobJS.StateCommon>,
         callback?: iobJS.SetStateCallback,
     ): void;
     function createState(
         name: string,
-        initValue: ioBroker.StateValue,
+        initValue: iobJS.StateValue,
         forceCreation: boolean,
         callback?: iobJS.SetStateCallback,
     ): void;
     function createState(name: string, callback?: iobJS.SetStateCallback): void;
-    function createState(name: string, initValue: ioBroker.StateValue, callback?: iobJS.SetStateCallback): void;
+    function createState(name: string, initValue: iobJS.StateValue, callback?: iobJS.SetStateCallback): void;
 
     function createState(name: string, common: Partial<iobJS.StateCommon>, callback?: iobJS.SetStateCallback): void;
     function createState(
         name: string,
-        initValue: ioBroker.StateValue,
+        initValue: iobJS.StateValue,
         common: Partial<iobJS.StateCommon>,
         callback?: iobJS.SetStateCallback,
     ): void;
@@ -1577,7 +2930,7 @@ declare global {
     ): void;
     function createState(
         name: string,
-        initValue: ioBroker.StateValue,
+        initValue: iobJS.StateValue,
         common: Partial<iobJS.StateCommon>,
         native: any,
         callback?: iobJS.SetStateCallback,
@@ -1585,7 +2938,7 @@ declare global {
 
     function createStateAsync(
         name: string,
-        initValue?: ioBroker.StateValue,
+        initValue?: iobJS.StateValue,
         forceCreation?: boolean,
         common?: Partial<iobJS.StateCommon>,
         native?: any,
@@ -1594,12 +2947,12 @@ declare global {
     function createStateAsync(name: string, common: Partial<iobJS.StateCommon>, native?: any): iobJS.SetStatePromise;
     function createStateAsync(
         name: string,
-        initValue: ioBroker.StateValue,
+        initValue: iobJS.StateValue,
         common: Partial<iobJS.StateCommon>,
     ): iobJS.SetStatePromise;
     function createStateAsync(
         name: string,
-        initValue: ioBroker.StateValue,
+        initValue: iobJS.StateValue,
         common: Partial<iobJS.StateCommon>,
         native?: any,
     ): iobJS.SetStatePromise;
@@ -1662,6 +3015,7 @@ declare global {
     /**
      * Deletes the state with the given ID
      *
+     * @param id The ID of the state to be deleted
      * @param callback (optional) Is called after the state was deleted (or not).
      */
     function deleteState(id: string, callback?: GenericCallback<boolean>): void;
@@ -1748,6 +3102,9 @@ declare global {
     /**
      * Compares two or more times
      *
+     * @param startTime - The start time to compare with
+     * @param endTime - The end time to compare with
+     * @param operation - The operation to use for comparison. Possible values:
      * @param timeToCompare - The time to compare with startTime and/or endTime. If none is given, the current time is used
      */
     function compareTime(