@iobroker/gui-components 8.0.2 → 10.0.1

package/build/Components/objectBrowser.types.d.ts

@@ -0,0 +1,496 @@
+import type React from 'react';
+import type { IobTheme, ThemeName, ThemeType, Translate } from '../types';
+import type { Connection } from '../Connection';
+import type { Router } from './Router';
+import type { ObjectBrowserClass } from './ObjectBrowser';
+import type { AdapterColumn, ObjectBrowserCustomFilter } from './objectBrowserUtils';
+
+type ObjectEventType = 'new' | 'changed' | 'deleted';
+
+interface ObjectEvent {
+    id: string;
+    obj?: ioBroker.Object;
+    type: ObjectEventType;
+    oldObj?: ioBroker.Object;
+}
+
+interface ObjectsWorker {
+    getObjects(update?: boolean): Promise<void | Record<string, ioBroker.Object>>;
+    registerHandler(cb: (events: ObjectEvent[]) => void): void;
+    unregisterHandler(cb: (events: ObjectEvent[]) => void, doNotUnsubscribe?: boolean): void;
+}
+
+interface CustomAdminColumnStored {
+    path: string;
+    name: string;
+    objTypes?: ioBroker.ObjectType[];
+    width?: number;
+    edit?: boolean;
+    type?: ioBroker.CommonType;
+}
+
+export interface ContextMenuItem {
+    /** hotkey */
+    key?: string;
+    visibility: boolean;
+    icon: React.JSX.Element | string;
+    label: string;
+    onClick?: () => void;
+    listItemIconStyle?: React.CSSProperties;
+    style?: React.CSSProperties;
+    subMenu?: {
+        label: string;
+        visibility: boolean;
+        icon: React.JSX.Element;
+        onClick: () => void;
+        iconStyle?: React.CSSProperties;
+        style?: React.CSSProperties;
+        listItemIconStyle?: React.CSSProperties;
+    }[];
+    iconStyle?: React.CSSProperties;
+}
+
+export type ioBrokerObjectForExport = ioBroker.Object & Partial<ioBroker.State>;
+
+export interface ObjectBrowserEditRoleProps {
+    roleArray: { role: string; type: ioBroker.CommonType }[];
+    id: string;
+    socket: Connection;
+    onClose: (obj?: ioBroker.Object | null) => void;
+    t: Translate;
+    commonType: ioBroker.CommonType;
+}
+
+export interface ObjectViewFileDialogProps {
+    t: Translate;
+    socket: Connection;
+    obj: ioBroker.AnyObject;
+    onClose: () => void;
+}
+
+export interface InsertJsonObjectsDialogProps {
+    t: Translate;
+    onClose: (json?: string) => void;
+    themeType: ThemeType;
+    themeName: ThemeName;
+}
+
+export interface TreeItemData {
+    id: string;
+    name: string;
+    obj?: ioBroker.Object;
+    /** Object ID in lower case for filtering */
+    fID?: string;
+    /** translated common.name in lower case for filtering */
+    fName?: string;
+    /** Link to parent item */
+    parent?: TreeItem;
+    level?: number;
+    icon?: string | React.JSX.Element | null;
+    /** If the item existing object or generated folder */
+    generated?: boolean;
+    title?: string;
+    /** if the item has "write" button (value=true, ack=false) */
+    button?: boolean;
+    /** If the item has read and write and is boolean */
+    switch?: boolean;
+    /** If the item is url linke */
+    url?: boolean;
+    /** if the item has custom settings in `common.custom` */
+    hasCustoms?: boolean;
+    /** If this item is visible */
+    visible?: boolean;
+    /** Is any of the children visible (not only directly children) */
+    hasVisibleChildren?: boolean;
+    /** Is any of the parents visible (not only directly parent) */
+    hasVisibleParent?: boolean;
+    /** Combination of `visible || hasVisibleChildren` */
+    sumVisibility?: boolean;
+    /** translated names of enumerations (functions) where this object is the member (or the parent), divided by comma */
+    funcs?: string;
+    /** is if the enums are from parent */
+    pef?: boolean;
+    /** translated names of enumerations (rooms) where this object is the member (or the parent), divided by comma */
+    rooms?: string;
+    /** is if the enums are from parent */
+    per?: boolean;
+    // language in what the rooms and functions where translated
+    lang?: ioBroker.Languages;
+    state?: {
+        valTextRx?: React.JSX.Element[] | null;
+        style?: React.CSSProperties;
+    };
+    aclTooltip?: null | React.JSX.Element;
+}
+
+export interface TreeItem {
+    id?: string;
+    data: TreeItemData;
+    children?: TreeItem[];
+}
+
+interface DragWrapperProps {
+    item: TreeItem;
+    className?: string;
+    style?: React.CSSProperties;
+    children: React.JSX.Element | null;
+}
+
+export interface ObjectCustomDialogProps {
+    allVisibleObjects: boolean;
+    customsInstances: string[];
+    expertMode?: boolean;
+    isFloatComma: boolean;
+    lang: ioBroker.Languages;
+    objectIDs: string[];
+    objects: Record<string, ioBroker.Object>;
+    onClose: () => void;
+    reportChangedIds: (ids: string[]) => void;
+    socket: Connection;
+    systemConfig: ioBroker.SystemConfigObject;
+    t: Translate;
+    theme: IobTheme;
+    themeName: ThemeName;
+    themeType: ThemeType;
+}
+
+export interface ObjectMoveRenameDialogProps {
+    childrenIds: string[];
+    expertMode: boolean;
+    id: string;
+    objectType: ioBroker.ObjectType | undefined;
+    onClose: () => void;
+    socket: Connection;
+    t: Translate;
+    theme: IobTheme;
+}
+
+export interface ObjectBrowserValueProps {
+    /** State type */
+    type: 'states' | 'string' | 'number' | 'boolean' | 'json';
+    /** State role */
+    role: string;
+    /** common.states */
+    states: Record<string, string> | null;
+    /** The state value */
+    value: string | number | boolean | null;
+    /** If expert mode is enabled */
+    expertMode: boolean;
+    onClose: (newValue?: {
+        val: ioBroker.StateValue;
+        ack: boolean;
+        q: ioBroker.STATE_QUALITY[keyof ioBroker.STATE_QUALITY];
+        expire: number | undefined;
+    }) => void;
+    /** Configured theme */
+    themeType: ThemeType;
+    theme: IobTheme;
+    socket: Connection;
+    defaultHistory: string;
+    dateFormat: string;
+    object: ioBroker.StateObject;
+    isFloatComma: boolean;
+    t: Translate;
+    lang: ioBroker.Languages;
+    width?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+}
+
+export interface ObjectBrowserEditObjectProps {
+    socket: Connection;
+    obj: ioBroker.AnyObject;
+    roleArray: { role: string; type: ioBroker.CommonType }[];
+    expertMode: boolean;
+    themeType: ThemeType;
+    theme: IobTheme;
+    aliasTab: boolean;
+    onClose: (obj?: ioBroker.AnyObject) => void;
+    dialogName?: string;
+    objects: Record<string, ioBroker.AnyObject>;
+    dateFormat: string;
+    isFloatComma: boolean;
+    onNewObject: (obj: ioBroker.AnyObject) => void;
+    t: Translate;
+    width?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+}
+
+export interface ObjectAliasEditorProps {
+    t: Translate;
+    roleArray: { role: string; type: ioBroker.CommonType }[];
+    socket: Connection;
+    objects: Record<string, ioBroker.AnyObject>;
+    onRedirect: (id: string, delay?: number) => void;
+    obj: ioBroker.AnyObject;
+    onClose: () => void;
+}
+
+export type ObjectBrowserColumn = 'name' | 'type' | 'role' | 'room' | 'func' | 'val' | 'buttons';
+
+export type ObjectBrowserPossibleColumns =
+    | 'name'
+    | 'type'
+    | 'role'
+    | 'room'
+    | 'func'
+    | 'val'
+    | 'buttons'
+    | 'changedFrom'
+    | 'qualityCode'
+    | 'timestamp'
+    | 'lastChange'
+    | 'id';
+
+export interface FormatValueOptions {
+    state: ioBroker.State;
+    obj: ioBroker.StateObject;
+    texts: Record<string, string>;
+    dateFormat: string;
+    isFloatComma: boolean;
+    full?: boolean;
+}
+
+export interface TreeInfo {
+    funcEnums: string[];
+    roomEnums: string[];
+    roles: { role: string; type: ioBroker.CommonType }[];
+    ids: string[];
+    types: string[];
+    objects: Record<string, ioBroker.Object>;
+    customs: string[];
+    enums: string[];
+    hasSomeCustoms: boolean;
+    // List of all aliases that shows to this state
+    aliasesMap: { [stateId: string]: string[] };
+}
+
+export interface GetValueStyleOptions {
+    state: ioBroker.State;
+    isExpertMode?: boolean;
+    isButton?: boolean;
+    nonAckColor?: string;
+}
+
+export interface ObjectBrowserCustomFilter {
+    type?: ioBroker.ObjectType | ioBroker.ObjectType[];
+    common?: {
+        type?: ioBroker.CommonType | ioBroker.CommonType[];
+        role?: string | string[];
+        // If "_" - no custom set
+        // If "_dataSources" - only data sources (history, sql, influxdb, ...)
+        // Else "telegram." or something like this
+        // `true` - If common.custom not empty
+        // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+        custom?: '_' | '_dataSources' | true | string | string[];
+    };
+}
+
+export interface InputSelectItem {
+    value: string;
+    name: string;
+    icon?: null | React.JSX.Element;
+}
+
+export interface AdapterColumn {
+    adapter: string;
+    id: string;
+    name: string;
+    path: string[];
+    pathText: string;
+    edit?: boolean;
+    type?: 'boolean' | 'string' | 'number';
+    objTypes?: ioBroker.ObjectType[];
+    align?: 'center' | 'left' | 'right';
+}
+
+export interface ObjectBrowserFilter {
+    id?: string;
+    name?: string;
+    room?: string[];
+    func?: string[];
+    role?: string[];
+    type?: string[];
+    custom?: string[];
+    expertMode?: boolean;
+}
+
+/**
+ * A navigation target the parent can use to drive the browser (and that the browser reports back).
+ * Maps cleanly to a route like `#tab-objects/<mode>/<id>`. The browser reacts to {@link
+ * ObjectBrowserProps.navigateTo} and emits {@link ObjectBrowserProps.onNavigateTo}, but never reads
+ * the URL itself — the URL parsing/writing stays in the parent component.
+ */
+export interface ObjectBrowserNavigation {
+    /** `select` = just highlight the item; `edit`/`settings` = open the edit/custom dialog; `viewFile` = open the file viewer. */
+    mode: 'select' | 'edit' | 'settings' | 'viewFile';
+    /** The object ID (or the file path for `viewFile`). */
+    id: string;
+}
+
+export interface ObjectBrowserProps {
+    /** where to store settings in localStorage */
+    dialogName?: string;
+    defaultFilters?: ObjectBrowserFilter;
+    selected?: string | string[];
+    onSelect?: (selected: string | string[], name: string | null, isDouble?: boolean) => void;
+    /**
+     * Drive selection and dialogs from the parent (e.g. from the URL). When this prop changes the
+     * browser selects the object and opens the requested dialog. The browser does NOT read the URL.
+     */
+    navigateTo?: ObjectBrowserNavigation | null;
+    /**
+     * Called when the user navigates inside the browser (selects an object, opens or closes a
+     * dialog) so the parent can reflect it in the URL. The browser never touches the URL itself.
+     */
+    onNavigateTo?: (navigation: ObjectBrowserNavigation | null) => void;
+    onFilterChanged?: (newFilter: ObjectBrowserFilter) => void;
+    socket: Connection;
+    showExpertButton?: boolean;
+    expertMode?: boolean;
+    imagePrefix?: string;
+    themeName: ThemeName;
+    themeType: ThemeType;
+    /** will be filled by withWidth */
+    width?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    theme: IobTheme;
+    t: Translate;
+    lang: ioBroker.Languages;
+    multiSelect?: boolean;
+    notEditable?: boolean;
+    foldersFirst?: boolean;
+    disableColumnSelector?: boolean;
+    isFloatComma?: boolean;
+    dateFormat?: string;
+    levelPadding?: number;
+    /** Allow selection of non-objects (virtual branches) */
+    allowNonObjects?: boolean;
+    /** Called when all objects are loaded */
+    onAllLoaded?: () => void;
+
+    // components
+    objectCustomDialog?: React.FC<ObjectCustomDialogProps>;
+    objectMoveRenameDialog?: React.FC<ObjectMoveRenameDialogProps>;
+    objectAddBoolean?: boolean; // optional toolbar button
+    objectEditBoolean?: boolean; // optional toolbar button
+    objectStatesView?: boolean; // optional toolbar button
+    objectImportExport?: boolean; // optional toolbar button
+    objectEditOfAccessControl?: boolean; // Access Control
+    /** modal add object */
+    modalNewObject?: (oBrowser: ObjectBrowserClass) => React.JSX.Element;
+    /** modal Edit Of Access Control */
+    modalEditOfAccessControl: (oBrowser: ObjectBrowserClass, data: TreeItemData) => React.JSX.Element;
+    onObjectDelete?: (id: string, hasChildren: boolean, objectExists: boolean, childrenCount: number) => void;
+
+    /**
+     * Optional filter
+     *   `{common: {custom: true}}` - show only objects with some custom settings
+     *   `{common: {custom: 'sql.0'}}` - show only objects with `sql.0` custom settings (only of the specific instance)
+     *   `{common: {custom: '_dataSources'}}` - show only objects of adapters `influxdb' or 'sql' or 'history'
+     *   `{common: {custom: 'adapterName.'}}` - show only objects of custom settings of specific adapter (all instances)
+     *   `{type: 'channel'}` - show only channels
+     *   `{type: ['channel', 'device']}` - show only channels and devices
+     *   `{common: {type: 'number'}` - show only states of type 'number
+     *   `{common: {type: ['number', 'string']}` - show only states of type 'number and string
+     *   `{common: {role: ['switch']}` - show only states with roles starting from switch
+     *   `{common: {role: ['switch', 'button']}` - show only states with roles starting from `switch` and `button`
+     */
+    customFilter: ObjectBrowserCustomFilter;
+    objectBrowserValue?: React.FC<ObjectBrowserValueProps>;
+    objectBrowserEditObject?: React.FC<ObjectBrowserEditObjectProps>;
+    /** on edit alias */
+    objectBrowserAliasEditor?: React.FC<ObjectAliasEditorProps>;
+    /** on Edit role */
+    objectBrowserEditRole?: React.FC<ObjectBrowserEditRoleProps>;
+    /** on view file state */
+    objectBrowserViewFile?: React.FC<ObjectViewFileDialogProps>;
+    objectBrowserInsertJsonObjects?: React.FC<InsertJsonObjectsDialogProps>;
+    router?: typeof Router;
+    types?: ioBroker.ObjectType[];
+    /** Possible columns: ['name', 'type', 'role', 'room', 'func', 'val', 'buttons'] */
+    columns?: ObjectBrowserColumn[];
+    /** Shows only elements of this root */
+    root?: string;
+
+    /** cache of objects */
+    objectsWorker?: ObjectsWorker;
+    /**
+     * function to filter out all unnecessary objects. It cannot be used together with "types"
+     * Example for function: `obj => obj.common?.type === 'boolean'` to show only boolean states
+     */
+    filterFunc?: (obj: ioBroker.Object) => boolean;
+    /** Used for enums dragging */
+    DragWrapper?: React.FC<DragWrapperProps>;
+    /** let DragWrapper know about objects to get the icons */
+    setObjectsReference?: (objects: Record<string, ioBroker.Object>) => void;
+    dragEnabled?: boolean;
+}
+
+export interface ObjectBrowserState {
+    loaded: boolean;
+    foldersFirst: boolean;
+    selected: string[];
+    focused: string;
+    selectedNonObject: string;
+    filter: ObjectBrowserFilter;
+    filterKey: number;
+    depth: number;
+    expandAllVisible: boolean;
+    expanded: string[];
+    toast: string;
+    scrollBarWidth: number;
+    customDialog: null | string[];
+    customDialogAll?: boolean;
+    editObjectDialog: string;
+    editObjectAlias: boolean; // open the edit object dialog on alias tab
+    viewFileDialog: string;
+    showAliasEditor: string;
+    enumDialog: null | {
+        item: TreeItem;
+        type: 'room' | 'func';
+        enumsOriginal: string;
+    };
+    enumDialogEnums?: null | string[];
+    roleDialog: null | string;
+    statesView: boolean;
+    /** ['name', 'type', 'role', 'room', 'func', 'val', 'buttons'] */
+    columns: ObjectBrowserPossibleColumns[] | null;
+    columnsForAdmin: Record<string, CustomAdminColumnStored[]> | null;
+    columnsSelectorShow: boolean;
+    columnsAuto: boolean;
+    columnsWidths: Record<string, number>;
+    columnsDialogTransparent: number;
+    columnsEditCustomDialog: null | {
+        obj: ioBroker.Object;
+        item: TreeItem;
+        it: AdapterColumn;
+    };
+    customColumnDialogValueChanged: boolean;
+    showExportDialog: false | number;
+    showImportDialog: boolean;
+    showAllExportOptions: boolean;
+    linesEnabled: boolean;
+    showDescription: boolean;
+    showContextMenu: {
+        item: TreeItem;
+        position: { left: number; top: number };
+        subItem?: string;
+        subAnchor?: HTMLLIElement;
+    } | null;
+    noStatesByExportImport: boolean;
+    beautifyJsonExport: boolean;
+    excludeSystemRepositoriesFromExport: boolean;
+    excludeTranslations: boolean;
+    updating?: boolean;
+    modalNewObj?: null | { id: string; initialType?: ioBroker.ObjectType; initialStateType?: ioBroker.CommonType };
+    error?: any;
+    modalEditOfAccess?: boolean;
+    modalEditOfAccessObjData?: TreeItemData;
+    updateOpened?: boolean;
+    tooltipInfo: null | { el: React.JSX.Element[]; id: string };
+    /** Show the menu with aliases for state */
+    aliasMenu: string;
+    /** Show rename dialog */
+    showRenameDialog: {
+        id: string;
+        childrenIds: string[];
+    } | null;
+    showImportMenu: HTMLButtonElement | null;
+}

package/build/Components/objectBrowserUtils.d.ts

@@ -0,0 +1,170 @@
+import React, { Component, type JSX } from 'react';
+import type { ThemeType } from '../types';
+import type { FormatValueOptions, InputSelectItem, TreeItem, ObjectBrowserCustomFilter, TreeInfo, GetValueStyleOptions, AdapterColumn, ObjectBrowserFilter, TreeItemData } from './objectBrowser.types';
+export declare const ICON_SIZE = 24;
+export declare const ROW_HEIGHT = 32;
+export declare const COLOR_NAME_USERDATA: (themeType: ThemeType) => string;
+export declare const COLOR_NAME_ALIAS: (themeType: ThemeType) => string;
+export declare const COLOR_NAME_JAVASCRIPT: (themeType: ThemeType) => string;
+export declare const COLOR_NAME_SYSTEM: (themeType: ThemeType) => string;
+export declare const COLOR_NAME_SYSTEM_ADAPTER: (themeType: ThemeType) => string;
+export declare const styles: Record<string, any>;
+export declare function ButtonIcon(props?: {
+    style?: React.CSSProperties;
+}): JSX.Element;
+/** Converts ioB pattern into regex */
+export declare function pattern2RegEx(pattern: string): string;
+/**
+ * Function that walks through all keys of an object or array and applies a function to each key.
+ */
+export declare function walkThroughArray(object: any[], iteratee: (result: any[], value: any, key: number) => void): any[];
+/**
+ * Function that walks through all keys of an object or array and applies a function to each key.
+ */
+export declare function walkThroughObject(object: Record<string, any>, iteratee: (result: Record<string, any>, value: any, key: string) => void): Record<string, any>;
+/**
+ * Function to reduce an object primarily by a given list of keys
+ */
+export declare function filterObject(
+/** The objects which should be filtered */
+obj: Record<string, any> | any[], 
+/** The keys which should be excluded */
+filterKeys: string[], 
+/** Whether translations should be reduced to only the english value */
+excludeTranslations?: boolean): Record<string, any> | any[];
+export declare function filterRoles(roleArray: {
+    role: string;
+    type: ioBroker.CommonType;
+}[], type: ioBroker.CommonType, defaultRoles?: {
+    role: string;
+    type: ioBroker.CommonType;
+}[]): string[];
+/**
+ * Function to generate a json-file for an object and trigger download it
+ */
+export declare function generateFile(
+/** The desired filename */
+fileName: string, 
+/** The objects which should be downloaded */
+obj: Record<string, ioBroker.Object>, 
+/** Options to filter/reduce the output */
+options: {
+    /**  Whether the output should be beautified */
+    beautify?: boolean;
+    /** Whether "system.repositories" should be excluded */
+    excludeSystemRepositories?: boolean;
+    /** Whether translations should be reduced to only the english value */
+    excludeTranslations?: boolean;
+}): void;
+interface CustomFilterSelectProps {
+    name: 'room' | 'func' | 'type' | 'role' | 'custom';
+    texts: Record<string, string>;
+    initialValue: string[] | undefined;
+    onChange: (name: 'room' | 'func' | 'type' | 'role' | 'custom', value: string[] | undefined) => void;
+    values: (string | InputSelectItem)[];
+}
+interface CustomFilterSelectState {
+    value: string[];
+}
+export declare class CustomFilterSelect extends Component<CustomFilterSelectProps, CustomFilterSelectState> {
+    private readonly hasIcons;
+    private timer;
+    constructor(props: CustomFilterSelectProps);
+    componentWillUnmount(): void;
+    render(): React.JSX.Element;
+}
+interface CustomFilterInputProps {
+    name: 'name' | 'id';
+    texts: Record<string, string>;
+    initialValue: string | undefined;
+    onChange: (name: 'name' | 'id', value: string | undefined) => void;
+    t: (text: string) => string;
+    styles?: React.CSSProperties;
+}
+interface CustomFilterInputState {
+    value: string;
+}
+export declare class CustomFilterInput extends Component<CustomFilterInputProps, CustomFilterInputState> {
+    private timer;
+    constructor(props: CustomFilterInputProps);
+    componentWillUnmount(): void;
+    render(): React.JSX.Element;
+}
+export declare function binarySearch(list: string[], find: string, _start?: number, _end?: number): boolean;
+export declare function getName(name: ioBroker.StringOrTranslated, lang: ioBroker.Languages): string;
+export declare function getSelectIdIconFromObjects(objects: Record<string, ioBroker.Object>, id: string, lang: ioBroker.Languages, imagePrefix?: string): string | JSX.Element | null;
+export declare function applyFilter(item: TreeItem, filters: ObjectBrowserFilter, lang: ioBroker.Languages, objects: Record<string, ioBroker.Object>, context?: {
+    id?: string;
+    idRx?: RegExp;
+    name?: string;
+    nameRx?: RegExp;
+    type?: string[];
+    custom?: string[];
+    role?: string[];
+    room?: string[];
+    func?: string[];
+}, counter?: {
+    count: number;
+}, customFilter?: ObjectBrowserCustomFilter, selectedTypes?: string[], _depth?: number): boolean;
+export declare function getVisibleItems(item: TreeItem, type: ioBroker.ObjectType, objects: Record<string, ioBroker.Object>, _result?: string[]): string[];
+export declare function getObjectTooltip(data: TreeItemData, lang: ioBroker.Languages): string | null;
+export declare function getIdFieldTooltip(data: TreeItemData, lang: ioBroker.Languages): JSX.Element;
+export declare function buildTree(objects: Record<string, ioBroker.Object>, options: {
+    imagePrefix?: string;
+    root?: string;
+    lang: ioBroker.Languages;
+    themeType: ThemeType;
+}): {
+    root: TreeItem;
+    info: TreeInfo;
+};
+export declare function findNode(root: TreeItem, id: string, _parts?: string[], _path?: string, _level?: number): TreeItem | null;
+export declare function findRoomsForObject(info: TreeInfo, id: string, lang: ioBroker.Languages, rooms?: string[]): {
+    rooms: string[];
+    per: boolean;
+};
+export declare function findEnumsForObjectAsIds(info: TreeInfo, id: string, enumName: 'roomEnums' | 'funcEnums', funcs?: string[]): string[];
+export declare function findFunctionsForObject(info: TreeInfo, id: string, lang: ioBroker.Languages, funcs?: string[]): {
+    funcs: string[];
+    pef: boolean;
+};
+/**
+ * Format a state value for visualization
+ */
+export declare function formatValue(options: FormatValueOptions): {
+    valText: {
+        /** value as string */
+        v: string;
+        /** value unit */
+        u?: string;
+        /** value isn't replaced by `common.states` */
+        s?: string;
+        /** Text for copy to clipboard */
+        c?: string;
+    };
+    valFull: {
+        /** label */
+        t: string;
+        /** value */
+        v: string;
+        /** no break */
+        nbr?: boolean;
+    }[] | undefined;
+    fileViewer: 'image' | 'text' | 'json' | 'html' | 'pdf' | 'audio' | 'video' | undefined;
+};
+/**
+ * Get CSS style for given state value
+ */
+export declare function getValueStyle(options: GetValueStyleOptions): {
+    color: string;
+};
+export declare function prepareSparkData(values: ioBroker.GetHistoryResult, from: number): number[];
+export declare function getCustomValue(obj: ioBroker.Object, it: AdapterColumn): string | number | boolean | null;
+export declare function setCustomValue(obj: ioBroker.Object, it: AdapterColumn, value: string | number | boolean): boolean;
+/**
+ * Check if it is a non-expert id
+ *
+ * @param id id to test
+ */
+export declare function isNonExpertId(id: string): boolean;
+export {};