@devtable/dashboard 14.23.1 → 14.25.0

package/dist/index.d.ts

@@ -26,5 +26,7 @@ export interface IDashboardConfig {
     monacoPath: string;
     renderSearchButton?: (props: RenderSearchButtonProps) => ReactNode;
 }
-export { notifyVizRendered, onVizRendered, pluginManager } from './components/plugins';
+export { notifyVizRendered, onVizRendered, pluginManager, tokens as pluginServices, useServiceLocator, } from './components/plugins';
+export type * from './components/plugins';
+export type { IServiceLocator } from './components/plugins';
 export { type IPanelAddon, type IPanelAddonRenderProps } from './types/plugin';

package/dist/model/meta-model/dashboard/content/filter/filter.d.ts

@@ -1,5 +1,13 @@
+import { type IObservableArray } from 'mobx';
 import { Instance, SnapshotOut } from 'mobx-state-tree';
 import { DashboardFilterType } from './types';
+import { type IFilterCheckboxConfig } from './widgets/checkbox';
+import { type IFilterDateRangeConfig } from './widgets/date-range';
+import { type IFilterMultiSelectConfig } from './widgets/multi-select';
+import { type IFilterSelectConfig } from './widgets/select';
+import { type IFilterTextInputConfig } from './widgets/text-input';
+import { type IFilterTreeSelectConfig } from './widgets/tree-select';
+import { type IFilterTreeSingleSelectConfig } from './widgets';
 export declare const FilterMeta: import("mobx-state-tree").IModelType<{
     id: import("mobx-state-tree").ISimpleType<string>;
     key: import("mobx-state-tree").ISimpleType<string>;
@@ -130,3 +138,44 @@ export declare const FilterMeta: import("mobx-state-tree").IModelType<{
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export type FilterMetaInstance = Instance<typeof FilterMeta>;
 export type FilterMetaSnapshotOut = SnapshotOut<FilterMetaInstance>;
+export interface IFilterMeta {
+    id: string;
+    key: string;
+    label: string;
+    order: number;
+    visibleInViewsIDs: IObservableArray<string>;
+    auto_submit: boolean;
+    default_value_func: string;
+    type: DashboardFilterType;
+    config: IFilterSelectConfig | IFilterMultiSelectConfig | IFilterTreeSelectConfig | IFilterTreeSingleSelectConfig | IFilterTextInputConfig | IFilterCheckboxConfig | IFilterDateRangeConfig;
+    readonly contentModel: Record<string, unknown>;
+    readonly filters: Record<string, unknown>;
+    readonly value: unknown;
+    readonly plainDefaultValue: unknown;
+    readonly usingDefaultValue: boolean;
+    readonly usingDefaultValueFunc: boolean;
+    readonly formattedDefaultValue: unknown;
+    readonly auto_submit_supported: boolean;
+    readonly json: {
+        id: string;
+        key: string;
+        type: DashboardFilterType;
+        label: string;
+        order: number;
+        config: Record<string, unknown>;
+        auto_submit: boolean;
+        visibleInViewsIDs: IObservableArray<string>;
+        default_value_func: string;
+    };
+    readonly visibleInViewsIDSet: Set<string>;
+    readonly should_auto_submit: boolean;
+    requiredAndPass(value: unknown): boolean;
+    setKey(key: string): void;
+    setValue(value: unknown): void;
+    setLabel(label: string): void;
+    setOrder(order: number | string): void;
+    setType(type: string | null): void;
+    setVisibleInViewsIDs(ids: string[]): void;
+    setAutoSubmit(v: boolean): void;
+    setDefaultValueFunc(v: string): void;
+}

package/dist/model/meta-model/dashboard/content/filter/widgets/checkbox.d.ts

@@ -15,6 +15,19 @@ export declare const FilterCheckboxConfigMeta: import("mobx-state-tree").IModelT
     setDescription(v: string): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export type FilterCheckboxConfigInstance = Instance<typeof FilterCheckboxConfigMeta>;
+export interface IFilterCheckboxConfig {
+    _name: 'checkbox';
+    description: string;
+    default_value: boolean;
+    readonly json: {
+        _name: 'checkbox';
+        description: string;
+        default_value: boolean;
+    };
+    readonly isDescriptionEmpty: boolean;
+    setDefaultValue(default_value: boolean): void;
+    setDescription(v: string): void;
+}
 export declare const createFilterCheckboxConfig: () => {
     _name: "checkbox";
     description: string;

package/dist/model/meta-model/dashboard/content/filter/widgets/date-range.d.ts

@@ -1,3 +1,4 @@
+import { type IObservableArray } from 'mobx';
 import { Instance, SnapshotOut } from 'mobx-state-tree';
 export type DateRangeValue_Value = [Date | null, Date | null];
 export type DateRangeValue = {
@@ -49,6 +50,37 @@ export declare const FilterDateRangeConfigMeta: import("mobx-state-tree").ISnaps
     allowSingleDateInRange: boolean;
 }>;
 export type FilterDateRangeConfigInstance = Instance<typeof FilterDateRangeConfigMeta>;
+export interface IFilterDateRangeConfig {
+    _name: 'date-range';
+    required: boolean;
+    inputFormat: 'YYYY' | 'YYYYMM' | 'YYYYMMDD' | 'YYYY-MM' | 'YYYY-MM-DD';
+    default_value: IObservableArray<Date | null>;
+    default_shortcut: string;
+    clearable: boolean;
+    max_days: number;
+    allowSingleDateInRange: boolean;
+    readonly json: {
+        _name: 'date-range';
+        max_days: number;
+        required: boolean;
+        clearable: boolean;
+        inputFormat: 'YYYY' | 'YYYYMM' | 'YYYYMMDD' | 'YYYY-MM' | 'YYYY-MM-DD';
+        default_value: string[];
+        default_shortcut: string;
+        allowSingleDateInRange: boolean;
+    };
+    truthy(fullValue: DateRangeValue): boolean;
+    readonly filter: Record<string, unknown>;
+    readonly dateStringsValue: [string, string];
+    setFilterValue(v: DateRangeValue): void;
+    setRequired(required: boolean): void;
+    setClearable(clearable: boolean): void;
+    setInputFormat(inputFormat: string | null): void;
+    setDefaultValue(v: DateRangeValue): void;
+    setDefaultShortcut(v: string | null): void;
+    setMaxDays(v: number | string): void;
+    setAllowSingleDateInRange(v: boolean): void;
+}
 export type FilterDateRangeConfigSnapshotOut = SnapshotOut<typeof FilterDateRangeConfigMeta>;
 export declare const createFilterDateRangeConfig: () => {
     _name: "date-range";

package/dist/model/meta-model/dashboard/content/filter/widgets/multi-select.d.ts

@@ -1,9 +1,12 @@
+import { type IObservableArray } from 'mobx';
 import { Instance } from 'mobx-state-tree';
+import { type IFilterBaseSelectConfigInstance, type IFilterConfigModel_SelectOption } from './select-base';
+import { type DefaultValueMode } from '../types';
 export declare const FilterMultiSelectConfigMeta: import("mobx-state-tree").IModelType<{
     _name: import("mobx-state-tree").ISimpleType<"multi-select">;
     min_width: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
     default_value: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").ISimpleType<string>>, [undefined]>;
-    default_value_mode: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<import("../types").DefaultValueMode>, [undefined]>;
+    default_value_mode: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<DefaultValueMode>, [undefined]>;
 } & {
     static_options: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IModelType<{
         label: import("mobx-state-tree").ISimpleType<string>;
@@ -50,7 +53,7 @@ export declare const FilterMultiSelectConfigMeta: import("mobx-state-tree").IMod
             setValue(value: string): void;
         }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>, [undefined]>>;
         options_query_id: string;
-        default_value_mode: import("../types").DefaultValueMode;
+        default_value_mode: DefaultValueMode;
         default_selection_count: number;
     };
     readonly defaultSelection: any;
@@ -65,11 +68,35 @@ export declare const FilterMultiSelectConfigMeta: import("mobx-state-tree").IMod
     afterCreate(): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export type FilterMultiSelectConfigInstance = Instance<typeof FilterMultiSelectConfigMeta>;
+export interface IFilterMultiSelectConfig extends IFilterBaseSelectConfigInstance {
+    _name: 'multi-select';
+    default_value: IObservableArray<string>;
+    default_value_mode: 'intersect' | 'reset';
+    min_width: string;
+    readonly json: {
+        _name: 'multi-select';
+        required: boolean;
+        min_width: string;
+        default_value: IObservableArray<string>;
+        static_options: IObservableArray<IFilterConfigModel_SelectOption>;
+        options_query_id: string;
+        default_value_mode: DefaultValueMode;
+        default_selection_count: number;
+    };
+    readonly defaultSelection: string[];
+    initialSelection(value: string[] | null): string[];
+    truthy(value: unknown): boolean;
+    setDefaultValue(default_value: string[]): void;
+    setDefaultValueMode(v: string | null): void;
+    setMinWidth(v: string): void;
+    applyDefaultSelection(): void;
+    afterCreate(): void;
+}
 export declare const createFilterMultiSelectConfig: () => {
     _name: "multi-select";
     min_width: string;
     default_value: import("mobx-state-tree").IMSTArray<import("mobx-state-tree").ISimpleType<string>> & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").ISimpleType<string>>, [undefined]>>;
-    default_value_mode: import("../types").DefaultValueMode;
+    default_value_mode: DefaultValueMode;
     static_options: import("mobx-state-tree").IMSTArray<import("mobx-state-tree").IModelType<{
         label: import("mobx-state-tree").ISimpleType<string>;
         value: import("mobx-state-tree").ISimpleType<string>;
@@ -121,7 +148,7 @@ export declare const createFilterMultiSelectConfig: () => {
             setValue(value: string): void;
         }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>, [undefined]>>;
         options_query_id: string;
-        default_value_mode: import("../types").DefaultValueMode;
+        default_value_mode: DefaultValueMode;
         default_selection_count: number;
     };
     readonly defaultSelection: any;
@@ -138,7 +165,7 @@ export declare const createFilterMultiSelectConfig: () => {
     _name: import("mobx-state-tree").ISimpleType<"multi-select">;
     min_width: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
     default_value: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").ISimpleType<string>>, [undefined]>;
-    default_value_mode: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<import("../types").DefaultValueMode>, [undefined]>;
+    default_value_mode: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<DefaultValueMode>, [undefined]>;
 } & {
     static_options: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IModelType<{
         label: import("mobx-state-tree").ISimpleType<string>;
@@ -185,7 +212,7 @@ export declare const createFilterMultiSelectConfig: () => {
             setValue(value: string): void;
         }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>, [undefined]>>;
         options_query_id: string;
-        default_value_mode: import("../types").DefaultValueMode;
+        default_value_mode: DefaultValueMode;
         default_selection_count: number;
     };
     readonly defaultSelection: any;

package/dist/model/meta-model/dashboard/content/filter/widgets/select-base.d.ts

@@ -1,4 +1,5 @@
 import { ComboboxItem } from '@mantine/core';
+import type { IObservableArray } from 'mobx';
 import { Instance } from 'mobx-state-tree';
 export type TSelectOption = {
     label: string;
@@ -14,6 +15,12 @@ export declare const FilterConfigModel_SelectOption: import("mobx-state-tree").I
     setValue(value: string): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export type IFilterSelectConfigMetaOption = Instance<typeof FilterConfigModel_SelectOption>;
+export interface IFilterConfigModel_SelectOption {
+    label: string;
+    value: string;
+    setLabel(label: string): void;
+    setValue(value: string): void;
+}
 export declare const FilterBaseSelectConfigMeta: import("mobx-state-tree").IModelType<{
     static_options: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IModelType<{
         label: import("mobx-state-tree").ISimpleType<string>;
@@ -42,3 +49,26 @@ export declare const FilterBaseSelectConfigMeta: import("mobx-state-tree").IMode
     setOptionsQueryID(id: string | null): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export type FilterBaseSelectConfigInstance = Instance<typeof FilterBaseSelectConfigMeta>;
+export interface IFilterBaseSelectConfigInstance {
+    static_options: IObservableArray<IFilterConfigModel_SelectOption>;
+    options_query_id: string;
+    default_selection_count: number;
+    required: boolean;
+    readonly contentModel: {
+        getDataStuffByID(id: string): {
+            state: 'loading' | 'error' | 'done';
+            data: TSelectOption[];
+        };
+    };
+    readonly filter: Record<string, unknown>;
+    readonly usingQuery: boolean;
+    readonly optionsLoading: boolean;
+    readonly options: TSelectOption[];
+    readonly optionValuesSet: Set<string>;
+    setRequired(required: boolean): void;
+    addStaticOption(option: StaticOption): void;
+    removeStaticOption(index: number): void;
+    replaceStaticOptions(options: StaticOption[]): void;
+    setDefaultSelectionCount(v: string | number): void;
+    setOptionsQueryID(id: string | null): void;
+}

package/dist/model/meta-model/dashboard/content/filter/widgets/select.d.ts

@@ -1,4 +1,6 @@
+import { type IObservableArray } from 'mobx';
 import { Instance } from 'mobx-state-tree';
+import { type IFilterBaseSelectConfigInstance, type IFilterConfigModel_SelectOption, type TSelectOption } from './select-base';
 export declare const FilterSelectConfigMeta: import("mobx-state-tree").IModelType<{
     _name: import("mobx-state-tree").ISimpleType<"select">;
     default_value: import("mobx-state-tree").ISimpleType<string>;
@@ -21,7 +23,7 @@ export declare const FilterSelectConfigMeta: import("mobx-state-tree").IModelTyp
     readonly usingQuery: boolean;
 } & {
     readonly optionsLoading: boolean;
-    readonly options: import("./select-base").TSelectOption[];
+    readonly options: TSelectOption[];
     readonly optionValuesSet: Set<string>;
 } & {
     setRequired(required: boolean): void;
@@ -54,7 +56,7 @@ export declare const FilterSelectConfigMeta: import("mobx-state-tree").IModelTyp
         default_selection_count: number;
     };
     truthy(value: any): boolean;
-    getSelectOption(value: string): import("./select-base").TSelectOption | undefined;
+    getSelectOption(value: string): TSelectOption | undefined;
     readonly default_selection: any;
 } & {
     setDefaultValue(default_value: string | null): void;
@@ -65,6 +67,30 @@ export declare const FilterSelectConfigMeta: import("mobx-state-tree").IModelTyp
     afterCreate(): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export type FilterSelectConfigInstance = Instance<typeof FilterSelectConfigMeta>;
+export interface IFilterSelectConfig extends IFilterBaseSelectConfigInstance {
+    _name: 'select';
+    default_value: string;
+    width: string;
+    clearable: boolean;
+    readonly json: {
+        _name: 'select';
+        width: string;
+        required: boolean;
+        clearable: boolean;
+        default_value: string;
+        static_options: IObservableArray<IFilterConfigModel_SelectOption>;
+        options_query_id: string;
+        default_selection_count: number;
+    };
+    readonly default_selection: string | undefined;
+    truthy(value: unknown): boolean;
+    getSelectOption(value: string): TSelectOption | undefined;
+    setDefaultValue(default_value: string | null): void;
+    setWidth(v: string): void;
+    setClearable(v: boolean): void;
+    setDefaultSelection(): void;
+    afterCreate(): void;
+}
 export declare const createFilterSelectConfig: () => {
     _name: "select";
     default_value: string;
@@ -92,7 +118,7 @@ export declare const createFilterSelectConfig: () => {
     readonly usingQuery: boolean;
 } & {
     readonly optionsLoading: boolean;
-    readonly options: import("./select-base").TSelectOption[];
+    readonly options: TSelectOption[];
     readonly optionValuesSet: Set<string>;
 } & {
     setRequired(required: boolean): void;
@@ -125,7 +151,7 @@ export declare const createFilterSelectConfig: () => {
         default_selection_count: number;
     };
     truthy(value: any): boolean;
-    getSelectOption(value: string): import("./select-base").TSelectOption | undefined;
+    getSelectOption(value: string): TSelectOption | undefined;
     readonly default_selection: any;
 } & {
     setDefaultValue(default_value: string | null): void;
@@ -156,7 +182,7 @@ export declare const createFilterSelectConfig: () => {
     readonly usingQuery: boolean;
 } & {
     readonly optionsLoading: boolean;
-    readonly options: import("./select-base").TSelectOption[];
+    readonly options: TSelectOption[];
     readonly optionValuesSet: Set<string>;
 } & {
     setRequired(required: boolean): void;
@@ -189,7 +215,7 @@ export declare const createFilterSelectConfig: () => {
         default_selection_count: number;
     };
     truthy(value: any): boolean;
-    getSelectOption(value: string): import("./select-base").TSelectOption | undefined;
+    getSelectOption(value: string): TSelectOption | undefined;
     readonly default_selection: any;
 } & {
     setDefaultValue(default_value: string | null): void;

package/dist/model/meta-model/dashboard/content/filter/widgets/text-input.d.ts

@@ -15,6 +15,19 @@ export declare const FilterTextInputConfigMeta: import("mobx-state-tree").IModel
     setDefaultValue(default_value: string): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export type FilterTextInputConfigInstance = Instance<typeof FilterTextInputConfigMeta>;
+export interface IFilterTextInputConfig {
+    _name: 'text-input';
+    required: boolean;
+    default_value: string;
+    readonly json: {
+        _name: 'text-input';
+        required: boolean;
+        default_value: string;
+    };
+    truthy(value: unknown): boolean;
+    setRequired(required: boolean): void;
+    setDefaultValue(default_value: string): void;
+}
 export declare const createFilterTextInputConfig: () => {
     _name: "text-input";
     required: boolean;

package/dist/model/meta-model/dashboard/content/filter/widgets/tree-select-base.d.ts

@@ -1,4 +1,6 @@
 import { Instance } from 'mobx-state-tree';
+import { ITreeDataQueryOption, ITreeDataRenderItem } from '../../../../../../components/filter/filter-tree';
+import { type IFilterBaseSelectConfigInstance } from './select-base';
 export declare const FilterBaseTreeSelectConfigMeta: import("mobx-state-tree").IModelType<{
     min_width: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
     default_value_mode: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<import("../types").DefaultValueMode>, [undefined]>;
@@ -37,3 +39,12 @@ export declare const FilterBaseTreeSelectConfigMeta: import("mobx-state-tree").I
     setMinWidth(v: string): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export type FilterBaseTreeSelectConfigMetaInstance = Instance<typeof FilterBaseTreeSelectConfigMeta>;
+export interface IFilterBaseTreeSelectConfigInstance extends IFilterBaseSelectConfigInstance {
+    min_width: string;
+    default_value_mode: 'intersect' | 'reset';
+    readonly plainData: ITreeDataQueryOption[];
+    readonly treeData: ITreeDataRenderItem[];
+    readonly errorMessage: string | undefined;
+    readonly treeDataLoading: boolean;
+    setMinWidth(v: string): void;
+}

package/dist/model/meta-model/dashboard/content/filter/widgets/tree-select.d.ts

@@ -1,4 +1,7 @@
+import { type IObservableArray } from 'mobx';
 import { Instance } from 'mobx-state-tree';
+import { type IFilterBaseTreeSelectConfigInstance } from './tree-select-base';
+import type { IFilterConfigModel_SelectOption } from './select-base';
 export declare const FilterTreeSelectConfigMeta: import("mobx-state-tree").IModelType<{
     _name: import("mobx-state-tree").ISimpleType<"tree-select">;
     default_value: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").ISimpleType<string>>, [undefined]>;
@@ -75,6 +78,32 @@ export declare const FilterTreeSelectConfigMeta: import("mobx-state-tree").IMode
     afterCreate(): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export type FilterTreeSelectConfigInstance = Instance<typeof FilterTreeSelectConfigMeta>;
+export interface IFilterTreeSelectConfigJson {
+    _name: 'tree-select';
+    required: boolean;
+    min_width: string;
+    default_value: IObservableArray<string>;
+    static_options: IObservableArray<IFilterConfigModel_SelectOption>;
+    options_query_id: string;
+    treeCheckStrictly: boolean;
+    default_value_mode: 'intersect' | 'reset';
+    default_selection_count: number;
+}
+export interface IFilterTreeSelectConfig extends IFilterBaseTreeSelectConfigInstance {
+    _name: 'tree-select';
+    default_value: IObservableArray<string>;
+    treeCheckStrictly: boolean;
+    readonly json: IFilterTreeSelectConfigJson;
+    readonly defaultSelection: string[];
+    valueObjects(value: string[]): unknown[];
+    initialSelection(value: string[] | null): string[];
+    truthy(value: unknown): boolean;
+    setDefaultValue(default_value: string[]): void;
+    setDefaultValueMode(v: string | null): void;
+    setTreeCheckStrictly(v: boolean): void;
+    applyDefaultSelection(): void;
+    afterCreate(): void;
+}
 export declare const createFilterTreeSelectConfig: () => {
     _name: "tree-select";
     default_value: import("mobx-state-tree").IMSTArray<import("mobx-state-tree").ISimpleType<string>> & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").ISimpleType<string>>, [undefined]>>;

package/dist/model/meta-model/dashboard/content/filter/widgets/tree-single-select.d.ts

@@ -1,4 +1,7 @@
+import { type IObservableArray } from 'mobx';
 import { Instance } from 'mobx-state-tree';
+import { type IFilterBaseTreeSelectConfigInstance } from './tree-select-base';
+import type { IFilterConfigModel_SelectOption } from './select-base';
 export declare const FilterTreeSingleSelectConfigMeta: import("mobx-state-tree").IModelType<{
     _name: import("mobx-state-tree").ISimpleType<"tree-single-select">;
     default_value: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
@@ -73,6 +76,29 @@ export declare const FilterTreeSingleSelectConfigMeta: import("mobx-state-tree")
     afterCreate(): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export type FilterTreeSingleSelectConfigInstance = Instance<typeof FilterTreeSingleSelectConfigMeta>;
+export interface IFilterTreeSingleSelectConfig extends IFilterBaseTreeSelectConfigInstance {
+    _name: 'tree-single-select';
+    default_value: string;
+    readonly json: {
+        _name: 'tree-single-select';
+        required: boolean;
+        min_width: string;
+        default_value: string;
+        static_options: IObservableArray<IFilterConfigModel_SelectOption>;
+        options_query_id: string;
+        default_value_mode: 'intersect' | 'reset';
+        default_selection_count: number;
+    };
+    readonly selectFirstByDefault: boolean;
+    readonly defaultSelection: string;
+    valueObject(value: string | null): unknown;
+    initialSelection(value: string | null): string;
+    truthy(value: unknown): boolean;
+    setDefaultValue(default_value: string): void;
+    setDefaultValueMode(v: string | null): void;
+    applyDefaultSelection(): void;
+    afterCreate(): void;
+}
 export declare const createFilterTreeSingleSelectConfig: () => {
     _name: "tree-single-select";
     default_value: string;

package/dist/model/meta-model/dashboard/content/layout/layout-item.d.ts

@@ -1,5 +1,7 @@
 import { Instance } from 'mobx-state-tree';
 import { Layout } from 'react-grid-layout';
+import type { IPanelRenderModel } from '../../../../../model/render-model';
+import { IContentRenderModel } from '../../../../../dashboard-render';
 export declare const LayoutItemMeta: import("mobx-state-tree").IModelType<{
     id: import("mobx-state-tree").ISimpleType<string>;
     panelID: import("mobx-state-tree").ISimpleType<string>;
@@ -29,6 +31,32 @@ export declare const LayoutItemMeta: import("mobx-state-tree").IModelType<{
     setHeight(h: number): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export type LayoutItemMetaInstance = Instance<typeof LayoutItemMeta>;
+export interface ILayoutItemMeta {
+    id: string;
+    panelID: string;
+    x: number;
+    y: number | null;
+    w: number;
+    h: number;
+    moved: boolean;
+    static: boolean;
+    readonly json: {
+        h: number;
+        w: number;
+        x: number;
+        y: number;
+        id: string;
+        moved: boolean;
+        static: boolean;
+        panelID: string;
+    };
+    readonly contentModel: IContentRenderModel;
+    readonly panel: IPanelRenderModel;
+    readonly layoutProperies: Layout;
+    set(layout: Omit<Layout, 'i'>): void;
+    setWidth(w: number): void;
+    setHeight(h: number): void;
+}
 export type LayoutItem = {
     id: string;
     panelID: string;

package/dist/model/meta-model/dashboard/content/layout/layout-set.d.ts

@@ -1,5 +1,7 @@
 import { Instance, SnapshotIn, SnapshotOut } from 'mobx-state-tree';
-import { LayoutItem } from './layout-item';
+import { IObservableArray } from 'mobx';
+import { IContentRenderModel } from '../../../../../dashboard-render';
+import { LayoutItem, ILayoutItemMeta } from './layout-item';
 import { Layout } from 'react-grid-layout';
 export type LayoutSetInfo = {
     id: string;
@@ -194,3 +196,32 @@ export declare const LayoutSetMeta: import("mobx-state-tree").IModelType<{
 export type LayoutSetMetaInstance = Instance<typeof LayoutSetMeta>;
 export type LayoutSetMetaSnapshotIn = SnapshotIn<LayoutSetMetaInstance>;
 export type LayoutSetMetaSnapshotOut = SnapshotOut<LayoutSetMetaInstance>;
+export interface ILayoutSetMeta {
+    id: string;
+    name: string;
+    breakpoint: number;
+    list: IObservableArray<ILayoutItemMeta>;
+    readonly contentModel: IContentRenderModel;
+    readonly json: {
+        id: string;
+        name: string;
+        breakpoint: number;
+        list: Array<ILayoutItemMeta['json']>;
+    };
+    jsonByPanelIDSet(panelIDSet: Set<string>): {
+        id: string;
+        name: string;
+        breakpoint: number;
+        list: Array<ILayoutItemMeta['json']>;
+    };
+    findByID(id: string): ILayoutItemMeta | undefined;
+    findByPanelID(panelID: string): ILayoutItemMeta | undefined;
+    setName(v: string): void;
+    setBreakpoint(v: number): void;
+    addLayout(layoutItem: LayoutItem): void;
+    addNewLayout(panelID: string): void;
+    removeByPanelID(panelID: string): void;
+    removeByPanelIDs(panelIDs: string[]): void;
+    updateLayoutItem(item: Layout): void;
+    afterCreate(): void;
+}

package/dist/model/meta-model/dashboard/content/mock-context/mock-context.d.ts

@@ -14,3 +14,13 @@ export declare const MockContextMeta: import("mobx-state-tree").IModelType<{
 export declare function getInitialMockContextMeta(context: ContextRecordType): {
     current: ContextRecordType;
 };
+export interface IMockContextMeta {
+    current: ContextRecordType;
+    readonly keys: string[];
+    readonly keySet: Set<string>;
+    readonly entries: Array<[string, ContextRecordType]>;
+    replace(record: ContextRecordType): void;
+    defaults(record: ContextRecordType): void;
+    get<T = any>(key: string): T;
+    set<T = any>(key: string, value: T): void;
+}

package/dist/model/meta-model/dashboard/content/panel/panel.d.ts

@@ -1,4 +1,8 @@
-import { VariableMetaInstance, VariableMetaSnapshotIn } from './variable';
+import { type IObservableArray } from 'mobx';
+import { type IPanelStyleMeta } from './style';
+import { type IPanelTitleMeta } from './title';
+import { VariableMetaInstance, VariableMetaSnapshotIn, type IVariableMeta } from './variable';
+import { type IPanelVizMeta } from './viz';
 export declare const PanelMeta: import("mobx-state-tree").IModelType<{
     id: import("mobx-state-tree").ISimpleType<string>;
     name: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
@@ -15,15 +19,15 @@ export declare const PanelMeta: import("mobx-state-tree").IModelType<{
     queryIDs: import("mobx-state-tree").IArrayType<import("mobx-state-tree").ISimpleType<string>>;
     viz: import("mobx-state-tree").IModelType<{
         type: import("mobx-state-tree").ISimpleType<string>;
-        conf: import("mobx-state-tree").IType<import("../../../../..").AnyObject, import("../../../../..").AnyObject, import("../../../../..").AnyObject>;
+        conf: import("mobx-state-tree").IType<import('../../../../../types/utils').AnyObject, import('../../../../../types/utils').AnyObject, import('../../../../../types/utils').AnyObject>;
     }, {
         readonly json: {
-            conf: import("../../../../..").AnyObject & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IType<import("../../../../..").AnyObject, import("../../../../..").AnyObject, import("../../../../..").AnyObject>>;
+            conf: import('../../../../../types/utils').AnyObject & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IType<import('../../../../../types/utils').AnyObject, import('../../../../../types/utils').AnyObject, import('../../../../../types/utils').AnyObject>>;
             type: string;
         };
     } & {
         setType(type: string): void;
-        setConf(conf: import("../../../../..").AnyObject): void;
+        setConf(conf: import('../../../../../types/utils').AnyObject): void;
     }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
     style: import("mobx-state-tree").IModelType<{
         border: import("mobx-state-tree").IModelType<{
@@ -558,7 +562,7 @@ export declare const PanelMeta: import("mobx-state-tree").IModelType<{
     readonly json: {
         id: string;
         viz: {
-            conf: import("../../../../..").AnyObject & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IType<import("../../../../..").AnyObject, import("../../../../..").AnyObject, import("../../../../..").AnyObject>>;
+            conf: import('../../../../../types/utils').AnyObject & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IType<import('../../../../../types/utils').AnyObject, import('../../../../../types/utils').AnyObject, import('../../../../../types/utils').AnyObject>>;
             type: string;
         };
         name: string;
@@ -987,3 +991,32 @@ export declare const PanelMeta: import("mobx-state-tree").IModelType<{
     addVariable(variable: VariableMetaSnapshotIn): void;
     removeVariable(variable: VariableMetaInstance): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+export interface IPanelMeta {
+    id: string;
+    name: string;
+    title: IPanelTitleMeta;
+    description: string;
+    queryIDs: IObservableArray<string>;
+    viz: IPanelVizMeta;
+    style: IPanelStyleMeta;
+    variables: IObservableArray<IVariableMeta>;
+    readonly json: {
+        id: string;
+        viz: IPanelVizMeta['json'];
+        name: string;
+        style: IPanelStyleMeta['json'];
+        title: IPanelTitleMeta['json'];
+        queryIDs: string[];
+        variables: Array<IVariableMeta['json']>;
+        description: string;
+    };
+    readonly queryIDSet: Set<string>;
+    setID(id: string): void;
+    setName(name: string): void;
+    setDescription(description: string): void;
+    addQueryID(queryID: string): void;
+    removeQueryID(queryID: string): void;
+    setQueryIDs(queryIDs: string[]): void;
+    addVariable(variable: VariableMetaSnapshotIn): void;
+    removeVariable(variable: VariableMetaInstance): void;
+}