@mwater/visualization 5.0.0

package/lib/datagrids/DatagridDesignerComponent.d.ts

@@ -0,0 +1,114 @@
+import PropTypes from "prop-types";
+import React from "react";
+import { DataSource, Schema } from "@mwater/expressions";
+import { DatagridDesignColumn } from "./DatagridDesign";
+import { DatagridDesign } from "..";
+export interface DatagridDesignerComponentProps {
+    /** schema to use */
+    schema: Schema;
+    /** dataSource to use */
+    dataSource: DataSource;
+    /** Design of datagrid. See README.md of this folder */
+    design: DatagridDesign;
+    /** Called when design changes */
+    onDesignChange: (design: DatagridDesign) => void;
+}
+export default class DatagridDesignerComponent extends React.Component<DatagridDesignerComponentProps> {
+    static contextTypes: {
+        globalFiltersElementFactory: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    handleTableChange: (table: any) => void;
+    handleColumnsChange: (columns: any) => void;
+    handleFilterChange: (filter: any) => void;
+    handleGlobalFiltersChange: (globalFilters: any) => void;
+    handleOrderBysChange: (orderBys: any) => void;
+    renderTabs(): React.CElement<{
+        initialTabId: string;
+        tabs: ({
+            id: string;
+            label: string;
+            elem: React.CElement<ColumnsDesignerComponentProps, ColumnsDesignerComponent>;
+        } | {
+            id: string;
+            label: string;
+            elem: React.DetailedReactHTMLElement<{
+                style: {
+                    marginBottom: number;
+                };
+            }, HTMLElement>;
+        })[];
+    }, React.Component<{
+        initialTabId: string;
+        tabs: ({
+            id: string;
+            label: string;
+            elem: React.CElement<ColumnsDesignerComponentProps, ColumnsDesignerComponent>;
+        } | {
+            id: string;
+            label: string;
+            elem: React.DetailedReactHTMLElement<{
+                style: {
+                    marginBottom: number;
+                };
+            }, HTMLElement>;
+        })[];
+    }, any, any>>;
+    render(): React.DetailedReactHTMLElement<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+}
+interface ColumnsDesignerComponentProps {
+    /** schema to use */
+    schema: Schema;
+    /** dataSource to use */
+    dataSource: DataSource;
+    table: string;
+    /** Columns list See README.md of this folder */
+    columns: any;
+    onColumnsChange: any;
+}
+declare class ColumnsDesignerComponent extends React.Component<ColumnsDesignerComponentProps> {
+    handleColumnChange: (columnIndex: any, column: any) => any;
+    handleAddColumn: () => any;
+    handleAddIdColumn: () => any;
+    handleAddDefaultColumns: () => any;
+    handleRemoveAllColumns: () => any;
+    renderColumn: (column: DatagridDesignColumn, columnIndex: any, connectDragSource: any, connectDragPreview: any, connectDropTarget: any) => React.CElement<ColumnDesignerComponentProps, ColumnDesignerComponent>;
+    render(): React.DetailedReactHTMLElement<{
+        style: {
+            height: string;
+            overflowY: "auto";
+            overflowX: "hidden";
+        };
+    }, HTMLElement>;
+}
+interface ColumnDesignerComponentProps {
+    /** schema to use */
+    schema: Schema;
+    /** dataSource to use */
+    dataSource: DataSource;
+    table: string;
+    /** Column See README.md of this folder */
+    column: DatagridDesignColumn;
+    /** Called when column changes. Null to remove. Array to replace with multiple entries */
+    onColumnChange: (column: DatagridDesignColumn | null | DatagridDesignColumn[]) => void;
+    /** Connect drag source (handle) here */
+    connectDragSource: any;
+    /** Connect drag preview here */
+    connectDragPreview: any;
+    connectDropTarget: any;
+}
+declare class ColumnDesignerComponent extends React.Component<ColumnDesignerComponentProps> {
+    handleExprChange: (expr: any) => void;
+    handleLabelChange: (label: any) => void;
+    handleFormatChange: (ev: any) => void;
+    handleSplitEnumset: () => void;
+    handleSplitGeometry: () => void;
+    renderSplit(): React.DetailedReactHTMLElement<{
+        className: string;
+        onClick: () => void;
+    }, HTMLElement> | null;
+    renderFormat(): React.DetailedReactHTMLElement<{
+        className: string;
+    }, HTMLElement> | null;
+    render: () => any;
+}
+export {};

package/lib/datagrids/DatagridDesignerComponent.js

@@ -0,0 +1,389 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const prop_types_1 = __importDefault(require("prop-types"));
+const lodash_1 = __importDefault(require("lodash"));
+const react_1 = __importStar(require("react"));
+const R = react_1.default.createElement;
+const react_select_1 = __importDefault(require("react-select"));
+const languages_1 = require("../languages");
+const expressions_1 = require("@mwater/expressions");
+const expressions_2 = require("@mwater/expressions");
+const TabbedComponent_1 = __importDefault(require("@mwater/react-library/lib/TabbedComponent"));
+const expressions_ui_1 = require("@mwater/expressions-ui");
+const expressions_ui_2 = require("@mwater/expressions-ui");
+const OrderBysDesignerComponent_1 = __importDefault(require("./OrderBysDesignerComponent"));
+const ReorderableListComponent_1 = __importDefault(require("@mwater/react-library/lib/reorderable/ReorderableListComponent"));
+const QuickfiltersDesignComponent_1 = __importDefault(require("../quickfilter/QuickfiltersDesignComponent"));
+const LabeledExprGenerator_1 = __importDefault(require("./LabeledExprGenerator"));
+const TableSelectComponent_1 = __importDefault(require("../TableSelectComponent"));
+const uuid_1 = __importDefault(require("uuid"));
+const update_object_1 = __importDefault(require("update-object"));
+const ui = __importStar(require("@mwater/react-library/lib/bootstrap"));
+const valueFormatter_1 = require("../valueFormatter");
+const valueFormatter_2 = require("../valueFormatter");
+// Designer for the datagrid. Currenly allows only single-table designs (no subtable rows)
+class DatagridDesignerComponent extends react_1.default.Component {
+    static contextTypes = { globalFiltersElementFactory: prop_types_1.default.func };
+    handleTableChange = (table) => {
+        const design = {
+            table,
+            columns: []
+        };
+        return this.props.onDesignChange(design);
+    };
+    handleColumnsChange = (columns) => {
+        return this.props.onDesignChange((0, update_object_1.default)(this.props.design, { columns: { $set: columns } }));
+    };
+    handleFilterChange = (filter) => {
+        return this.props.onDesignChange((0, update_object_1.default)(this.props.design, { filter: { $set: filter } }));
+    };
+    handleGlobalFiltersChange = (globalFilters) => {
+        return this.props.onDesignChange((0, update_object_1.default)(this.props.design, { globalFilters: { $set: globalFilters } }));
+    };
+    handleOrderBysChange = (orderBys) => {
+        return this.props.onDesignChange((0, update_object_1.default)(this.props.design, { orderBys: { $set: orderBys } }));
+    };
+    // Render the tabs of the designer
+    renderTabs() {
+        return R(TabbedComponent_1.default, {
+            initialTabId: "columns",
+            tabs: [
+                {
+                    id: "columns",
+                    label: T("Columns"),
+                    elem: R(ColumnsDesignerComponent, {
+                        schema: this.props.schema,
+                        dataSource: this.props.dataSource,
+                        table: this.props.design.table,
+                        columns: this.props.design.columns,
+                        onColumnsChange: this.handleColumnsChange
+                    })
+                },
+                {
+                    id: "filter",
+                    label: T("Filter"),
+                    // Here because of modal scroll issue
+                    elem: R("div", { style: { marginBottom: 200 } }, R(expressions_ui_2.FilterExprComponent, {
+                        schema: this.props.schema,
+                        dataSource: this.props.dataSource,
+                        table: this.props.design.table,
+                        value: this.props.design.filter,
+                        onChange: this.handleFilterChange
+                    }), this.context.globalFiltersElementFactory
+                        ? R("div", { style: { marginTop: 20 } }, this.context.globalFiltersElementFactory({
+                            schema: this.props.schema,
+                            dataSource: this.props.dataSource,
+                            filterableTables: [this.props.design.table],
+                            globalFilters: this.props.design.globalFilters,
+                            onChange: this.handleGlobalFiltersChange,
+                            nullIfIrrelevant: true
+                        }))
+                        : undefined)
+                },
+                {
+                    id: "order",
+                    label: T("Sorting"),
+                    elem: R("div", { style: { marginBottom: 200 } }, R(OrderBysDesignerComponent_1.default, {
+                        schema: this.props.schema,
+                        dataSource: this.props.dataSource,
+                        table: this.props.design.table,
+                        orderBys: this.props.design.orderBys,
+                        onChange: this.handleOrderBysChange
+                    }))
+                },
+                {
+                    id: "quickfilters",
+                    label: T("Quickfilters"),
+                    elem: R("div", { style: { marginBottom: 200 } }, R(QuickfiltersDesignComponent_1.default, {
+                        design: this.props.design.quickfilters || [],
+                        onDesignChange: (design) => this.props.onDesignChange((0, update_object_1.default)(this.props.design, { quickfilters: { $set: design } })),
+                        schema: this.props.schema,
+                        dataSource: this.props.dataSource,
+                        tables: [this.props.design.table]
+                    }))
+                },
+                {
+                    id: "options",
+                    label: T("Options"),
+                    elem: R("div", { style: { marginBottom: 200 } }, R(DatagridOptionsComponent, {
+                        design: this.props.design,
+                        onDesignChange: this.props.onDesignChange
+                    }))
+                }
+            ]
+        });
+    }
+    render() {
+        return R("div", null, R("label", null, T("Data Source:")), R(TableSelectComponent_1.default, {
+            schema: this.props.schema,
+            value: this.props.design.table,
+            onChange: this.handleTableChange
+        }), this.props.design.table ? this.renderTabs() : undefined);
+    }
+}
+exports.default = DatagridDesignerComponent;
+// Datagrid Options
+function DatagridOptionsComponent(props) {
+    const localeOptions = (0, react_1.useMemo)(() => {
+        return lodash_1.default.sortBy(languages_1.languages.map(language => ({
+            value: language.code,
+            label: language.en + " (" + language.name + ")"
+        })), "label");
+    }, []);
+    return react_1.default.createElement("div", null,
+        react_1.default.createElement(ui.Checkbox, { value: props.design.showRowNumbers, onChange: (showRowNumbers) => props.onDesignChange({ ...props.design, showRowNumbers }) }, T("Show row numbers")),
+        react_1.default.createElement(ui.FormGroup, { label: T("Language"), hint: T("Preferred language of the datagrid") },
+            react_1.default.createElement(react_select_1.default, { value: localeOptions.find(opt => opt.value == (props.design.locale || "en")) || null, options: localeOptions, onChange: (locale) => props.onDesignChange({ ...props.design, locale: locale.value }) })));
+}
+// Columns list
+class ColumnsDesignerComponent extends react_1.default.Component {
+    handleColumnChange = (columnIndex, column) => {
+        const columns = this.props.columns.slice();
+        // Handle remove
+        if (!column) {
+            columns.splice(columnIndex, 1);
+        }
+        else if (lodash_1.default.isArray(column)) {
+            // Handle array case
+            Array.prototype.splice.apply(columns, [columnIndex, 1].concat(column));
+        }
+        else {
+            columns[columnIndex] = column;
+        }
+        return this.props.onColumnsChange(columns);
+    };
+    handleAddColumn = () => {
+        const columns = this.props.columns.slice();
+        columns.push({ id: (0, uuid_1.default)(), type: "expr", width: 150 });
+        return this.props.onColumnsChange(columns);
+    };
+    handleAddIdColumn = () => {
+        const columns = this.props.columns.slice();
+        // TODO we should display label when available but without breaking Peter's id downloads. Need format field to indicate raw id.
+        columns.push({
+            id: (0, uuid_1.default)(),
+            type: "expr",
+            width: 150,
+            expr: { type: "id", table: this.props.table },
+            label: T("Unique Id")
+        });
+        return this.props.onColumnsChange(columns);
+    };
+    handleAddDefaultColumns = () => {
+        // Create labeled expressions
+        const labeledExprs = new LabeledExprGenerator_1.default(this.props.schema).generate(this.props.table, {
+            headerFormat: "text"
+        });
+        let columns = [];
+        for (let labeledExpr of labeledExprs) {
+            columns.push({
+                id: (0, uuid_1.default)(),
+                width: 150,
+                type: "expr",
+                label: null,
+                expr: labeledExpr.expr
+            });
+        }
+        columns = this.props.columns.concat(columns);
+        return this.props.onColumnsChange(columns);
+    };
+    handleRemoveAllColumns = () => {
+        return this.props.onColumnsChange([]);
+    };
+    renderColumn = (column, columnIndex, connectDragSource, connectDragPreview, connectDropTarget) => {
+        return R(ColumnDesignerComponent, {
+            key: columnIndex,
+            schema: this.props.schema,
+            table: this.props.table,
+            dataSource: this.props.dataSource,
+            column,
+            onColumnChange: this.handleColumnChange.bind(null, columnIndex),
+            connectDragSource,
+            connectDragPreview,
+            connectDropTarget
+        });
+    };
+    render() {
+        return R("div", { style: { height: "auto", overflowY: "auto", overflowX: "hidden" } }, R("div", { style: { textAlign: "right" }, key: "options" }, R("button", {
+            key: "addAll",
+            type: "button",
+            className: "btn btn-link btn-sm",
+            onClick: this.handleAddDefaultColumns
+        }, R("span", { className: "fas fa-plus" }), " " + T("Add Default Columns")), R("button", {
+            key: "removeAll",
+            type: "button",
+            className: "btn btn-link btn-sm",
+            onClick: this.handleRemoveAllColumns
+        }, R("span", { className: "fas fa-times" }), " " + T("Remove All Columns"))), R(ReorderableListComponent_1.default, {
+            items: this.props.columns,
+            onReorder: this.props.onColumnsChange,
+            renderItem: this.renderColumn,
+            getItemId: (item) => item.id
+        }), R("div", { className: "p-2" }, R("button", {
+            key: "add",
+            type: "button",
+            className: "btn btn-link",
+            onClick: this.handleAddColumn
+        }, R("span", { className: "fas fa-plus" }), " " + T("Add Column")), R("button", {
+            key: "add-id",
+            type: "button",
+            className: "btn btn-link",
+            onClick: this.handleAddIdColumn
+        }, R("span", { className: "fas fa-plus" }), " " + T("Add Unique Id (advanced)"))));
+    }
+}
+// Column item
+class ColumnDesignerComponent extends react_1.default.Component {
+    handleExprChange = (expr) => {
+        return this.props.onColumnChange((0, update_object_1.default)(this.props.column, { expr: { $set: expr } }));
+    };
+    handleLabelChange = (label) => {
+        return this.props.onColumnChange((0, update_object_1.default)(this.props.column, { label: { $set: label } }));
+    };
+    handleFormatChange = (ev) => {
+        return this.props.onColumnChange((0, update_object_1.default)(this.props.column, { format: { $set: ev.target.value } }));
+    };
+    handleSplitEnumset = () => {
+        const exprUtils = new expressions_1.ExprUtils(this.props.schema);
+        return this.props.onColumnChange(lodash_1.default.map(exprUtils.getExprEnumValues(this.props.column.expr), (enumVal) => {
+            return {
+                id: (0, uuid_1.default)(),
+                type: "expr",
+                width: 150,
+                expr: {
+                    type: "op",
+                    op: "contains",
+                    table: this.props.table,
+                    exprs: [this.props.column.expr, { type: "literal", valueType: "enumset", value: [enumVal.id] }]
+                }
+            };
+        }));
+    };
+    handleSplitGeometry = () => {
+        return this.props.onColumnChange([
+            {
+                id: (0, uuid_1.default)(),
+                type: "expr",
+                width: 150,
+                expr: {
+                    type: "op",
+                    op: "latitude",
+                    table: this.props.table,
+                    exprs: [this.props.column.expr]
+                }
+            },
+            {
+                id: (0, uuid_1.default)(),
+                type: "expr",
+                width: 150,
+                expr: {
+                    type: "op",
+                    op: "longitude",
+                    table: this.props.table,
+                    exprs: [this.props.column.expr]
+                }
+            }
+        ]);
+    };
+    // Render options to split a column, such as an enumset to booleans or geometry to lat/lng
+    renderSplit() {
+        const exprUtils = new expressions_1.ExprUtils(this.props.schema);
+        const exprType = exprUtils.getExprType(this.props.column.expr);
+        switch (exprType) {
+            case "enumset":
+                return R("a", { className: "btn btn-sm btn-link", onClick: this.handleSplitEnumset }, R("i", { className: "fa fa-chain-broken" }), " " + T("Split by options"));
+                break;
+            case "geometry":
+                return R("a", { className: "btn btn-sm btn-link", onClick: this.handleSplitGeometry }, R("i", { className: "fa fa-chain-broken" }), " " + T("Split by lat/lng"));
+                break;
+        }
+        return null;
+    }
+    renderFormat() {
+        const exprUtils = new expressions_1.ExprUtils(this.props.schema);
+        const exprType = exprUtils.getExprType(this.props.column.expr);
+        if (!exprType) {
+            return null;
+        }
+        const formats = (0, valueFormatter_1.getFormatOptions)(exprType);
+        if (!formats) {
+            return null;
+        }
+        return R("div", { className: "mb-3" }, R("label", { className: "text-muted" }, T("Format")), ": ", R("select", {
+            value: this.props.column.format != null ? this.props.column.format : (0, valueFormatter_2.getDefaultFormat)(exprType),
+            className: "form-select",
+            style: { width: "auto", display: "inline-block" },
+            onChange: this.handleFormatChange
+        }, lodash_1.default.map(formats, (format) => R("option", { key: format.value, value: format.value }, format.label))));
+    }
+    render = () => {
+        const exprUtils = new expressions_1.ExprUtils(this.props.schema);
+        const exprValidator = new expressions_2.ExprValidator(this.props.schema);
+        // Get type of current expression
+        const type = exprUtils.getExprType(this.props.column.expr);
+        // Determine allowed types
+        const allowedTypes = [
+            "text",
+            "number",
+            "enum",
+            "enumset",
+            "boolean",
+            "date",
+            "datetime",
+            "image",
+            "imagelist",
+            "text[]",
+            "geometry"
+        ];
+        // If type id, allow id (e.g. don't allow to be added directly, but keep if present)
+        if (type === "id") {
+            allowedTypes.push("id");
+        }
+        const error = exprValidator.validateExpr(this.props.column.expr, {
+            aggrStatuses: ["individual", "literal", "aggregate"]
+        });
+        const elem = R("div", { className: "row" }, R("div", { className: "col-1" }, this.props.connectDragSource(R("span", { className: "text-muted fa fa-bars _mviz-move" }))), R("div", { className: "col-6" }, // style: { border: "solid 1px #DDD", padding: 4 },
+        R(expressions_ui_1.ExprComponent, {
+            schema: this.props.schema,
+            dataSource: this.props.dataSource,
+            table: this.props.table,
+            value: this.props.column.expr,
+            aggrStatuses: ["literal", "individual", "aggregate"],
+            types: allowedTypes,
+            onChange: this.handleExprChange
+        }), this.renderSplit(), this.renderFormat(), error ? R("i", { className: "fa fa-exclamation-circle text-danger" }) : undefined), R("div", { className: "col-4" }, R("input", {
+            type: "text",
+            className: "form-control",
+            placeholder: exprUtils.summarizeExpr(this.props.column.expr),
+            value: this.props.column.label,
+            onChange: (ev) => this.handleLabelChange(ev.target.value)
+        })), R("div", { className: "col-1" }, R("a", { className: "link-plain", onClick: this.props.onColumnChange.bind(null, null) }, R("span", { className: "fas fa-times" }))));
+        return this.props.connectDropTarget(this.props.connectDragPreview(elem));
+    };
+}

package/lib/datagrids/DatagridQueryBuilder.d.ts

@@ -0,0 +1,68 @@
+import { JsonQLExpr, JsonQLQuery, JsonQLSelect } from "@mwater/jsonql";
+import { Schema } from "@mwater/expressions";
+import { JsonQLFilter } from "../JsonQLFilter";
+import { DatagridDesign, DatagridDesignColumn, DatagridDesignSubtable } from "./DatagridDesign";
+export default class DatagridQueryBuilder {
+    schema: Schema;
+    constructor(schema: Schema);
+    createQuery(design: DatagridDesign, options?: {
+        /** start at row offset */
+        offset?: number;
+        /** limit rows */
+        limit?: number;
+        /** array of additional filters to apply. Each is { table: table id, jsonql: jsonql condition with {alias} for tableAlias. } */
+        extraFilters?: JsonQLFilter[];
+        /** repeat main level values in subtable rows instead of leaving blank */
+        fillSubtableRows?: boolean;
+    }): JsonQLQuery;
+    createSimpleQuery(design: any, options?: {
+        /** start at row offset */
+        offset?: number;
+        /** limit rows */
+        limit?: number;
+        /** array of additional filters to apply. Each is { table: table id, jsonql: jsonql condition with {alias} for tableAlias. } */
+        extraFilters?: JsonQLFilter[];
+        /** repeat main level values in subtable rows instead of leaving blank */
+        fillSubtableRows?: boolean;
+    }): JsonQLQuery;
+    createComplexQuery(design: DatagridDesign, options?: {
+        /** start at row offset */
+        offset?: number;
+        /** limit rows */
+        limit?: number;
+        /** array of additional filters to apply. Each is { table: table id, jsonql: jsonql condition with {alias} for tableAlias. } */
+        extraFilters?: JsonQLFilter[];
+        /** repeat main level values in subtable rows instead of leaving blank */
+        fillSubtableRows?: boolean;
+    }): JsonQLQuery;
+    createComplexMainQuery(design: DatagridDesign, options?: {
+        /** start at row offset */
+        offset?: number;
+        /** limit rows */
+        limit?: number;
+        /** array of additional filters to apply. Each is { table: table id, jsonql: jsonql condition with {alias} for tableAlias. } */
+        extraFilters?: JsonQLFilter[];
+        /** repeat main level values in subtable rows instead of leaving blank */
+        fillSubtableRows?: boolean;
+    }): JsonQLQuery;
+    createComplexSubtableQuery(design: DatagridDesign, options: {
+        /** start at row offset */
+        offset?: number | undefined;
+        /** limit rows */
+        limit?: number | undefined;
+        /** array of additional filters to apply. Each is { table: table id, jsonql: jsonql condition with {alias} for tableAlias. } */
+        extraFilters?: JsonQLFilter[] | undefined;
+        /** repeat main level values in subtable rows instead of leaving blank */
+        fillSubtableRows?: boolean | undefined;
+    } | undefined, subtable: any, subtableIndex: any): JsonQLQuery;
+    getMainOrderByExprs(design: DatagridDesign, isAggr?: boolean): JsonQLExpr[];
+    getMainOrderByDirections(design: any, isAggr?: boolean): any[];
+    getSubtableOrderByExprs(design: DatagridDesign, subtable: DatagridDesignSubtable): JsonQLExpr[];
+    getSubtableOrderByDirections(design: any, subtable: any): any[];
+    getSubtableOrderByExprTypes(design: any, subtable: any): (string | null)[];
+    /** Create the select for a column in JsonQL format */
+    createColumnSelect(column: DatagridDesignColumn, columnIndex: any, subtable?: any, fillSubtableRows?: any): JsonQLSelect;
+    createSimpleSelects(design: DatagridDesign, isAggr: boolean): JsonQLSelect[];
+    createNullExpr(exprType: any): JsonQLExpr;
+    isMainAggr(design: any): boolean;
+}