@mwater/visualization 5.0.0

package/lib/datagrids/EditExprCellComponent.js

@@ -0,0 +1,212 @@
+"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 lodash_1 = __importDefault(require("lodash"));
+const react_1 = __importStar(require("react"));
+const R = react_1.default.createElement;
+const expressions_1 = require("@mwater/expressions");
+const moment_1 = __importDefault(require("moment"));
+// Cell allows editing an expression column cell
+// Store edited value here to prevent slow re-render of entire datagrid
+class EditExprCellComponent extends react_1.default.Component {
+    constructor(props) {
+        super(props);
+        this.state = { value: props.value };
+    }
+    getValue() {
+        return this.state.value;
+    }
+    // Check if edit value has changed
+    hasChanged() {
+        return !lodash_1.default.isEqual(this.props.value, this.state.value);
+    }
+    handleChange = (value) => {
+        this.setState({ value });
+    };
+    render() {
+        const exprUtils = new expressions_1.ExprUtils(this.props.schema);
+        // Get expression type
+        const exprType = exprUtils.getExprType(this.props.expr);
+        switch (exprType) {
+            case "text":
+                return R(TextEditComponent, {
+                    value: this.state.value,
+                    onChange: this.handleChange,
+                    onSave: this.props.onSave,
+                    onCancel: this.props.onCancel
+                });
+            case "number":
+                return R(NumberEditComponent, {
+                    value: this.state.value,
+                    onChange: this.handleChange,
+                    onSave: this.props.onSave,
+                    onCancel: this.props.onCancel
+                });
+            case "enum":
+                return R(EnumEditComponent, {
+                    value: this.state.value,
+                    onChange: this.handleChange,
+                    enumValues: exprUtils.getExprEnumValues(this.props.expr),
+                    onSave: this.props.onSave,
+                    onCancel: this.props.onCancel,
+                    locale: this.props.locale
+                });
+            case "date":
+            case "datetime":
+                return R(DateEditComponent, {
+                    value: this.state.value,
+                    onChange: this.handleChange,
+                    onSave: this.props.onSave,
+                    onCancel: this.props.onCancel,
+                    datetime: exprType === "datetime"
+                });
+        }
+        throw new Error(`Unsupported type ${exprType} for editing`);
+    }
+}
+exports.default = EditExprCellComponent;
+// Simple text box
+class TextEditComponent extends react_1.default.Component {
+    input;
+    componentDidMount() {
+        // Focus when created
+        return this.input?.focus();
+    }
+    render() {
+        return R("div", { style: { paddingTop: 3 } }, R("input", {
+            ref: (c) => {
+                this.input = c;
+            },
+            type: "text",
+            className: "form-control",
+            value: this.props.value || "",
+            onChange: (ev) => this.props.onChange(ev.target.value || null),
+            onKeyUp: (ev) => {
+                if (ev.keyCode === 27) {
+                    this.props.onCancel();
+                }
+                if (ev.keyCode === 13) {
+                    return this.props.onSave();
+                }
+            }
+        }));
+    }
+}
+// Simple number box
+class NumberEditComponent extends react_1.default.Component {
+    input;
+    componentDidMount() {
+        // Focus when created
+        return this.input?.focus();
+    }
+    handleChange = (ev) => {
+        if (ev.target.value) {
+            return this.props.onChange(parseFloat(ev.target.value));
+        }
+        else {
+            return this.props.onChange(null);
+        }
+    };
+    render() {
+        return R("div", { style: { paddingTop: 3 } }, R("input", {
+            ref: (c) => {
+                return (this.input = c);
+            },
+            type: "number",
+            step: "any",
+            className: "form-control",
+            value: this.props.value != null ? this.props.value : "",
+            onChange: this.handleChange,
+            onKeyUp: (ev) => {
+                if (ev.keyCode === 27) {
+                    this.props.onCancel();
+                }
+                if (ev.keyCode === 13) {
+                    return this.props.onSave();
+                }
+            }
+        }));
+    }
+}
+// Simple enum box
+class EnumEditComponent extends react_1.default.Component {
+    render() {
+        return R("div", { style: { paddingTop: 3 } }, R("select", {
+            value: this.props.value || "",
+            onChange: (ev) => this.props.onChange(ev.target.value || null),
+            className: "form-select"
+        }, R("option", { key: "", value: "" }, ""), lodash_1.default.map(this.props.enumValues, (ev) => {
+            return R("option", { key: ev.id, value: ev.id }, expressions_1.ExprUtils.localizeString(ev.name, this.props.locale));
+        })));
+    }
+}
+/** Simple date editor */
+function DateEditComponent(props) {
+    // // Focus when created
+    // return this.input?.focus()
+    // Format date
+    const [valueStr, setValueStr] = (0, react_1.useState)(props.datetime ?
+        (props.value ? (0, moment_1.default)(props.value, moment_1.default.ISO_8601).format("YYYY-MM-DD HH:mm") : "")
+        : props.value || "");
+    const [isValid, setIsValid] = (0, react_1.useState)(true);
+    // Parse date
+    function parseDate(value) {
+        if (!value) {
+            setIsValid(true);
+            return null;
+        }
+        const m = (0, moment_1.default)(value, props.datetime ? "YYYY-MM-DD HH:mm" : "YYYY-MM-DD");
+        if (!m.isValid()) {
+            setIsValid(false);
+            return null;
+        }
+        setIsValid(true);
+        if (props.datetime) {
+            return m.toISOString();
+        }
+        else {
+            return m.format("YYYY-MM-DD");
+        }
+    }
+    return react_1.default.createElement("div", { style: { paddingTop: 3 } },
+        react_1.default.createElement("input", { type: "text", className: "form-control", value: valueStr, style: { backgroundColor: isValid ? "white" : "pink" }, onChange: ev => {
+                setValueStr(ev.target.value);
+                props.onChange(parseDate(ev.target.value));
+            }, ref: c => {
+                if (c) {
+                    c.focus();
+                }
+            }, onKeyUp: (ev) => {
+                if (ev.keyCode === 27) {
+                    props.onCancel();
+                }
+                if (ev.keyCode === 13) {
+                    return props.onSave();
+                }
+            } }));
+}

package/lib/datagrids/ExprCellComponent.d.ts

@@ -0,0 +1,34 @@
+import React from "react";
+import { DataSource, LiteralType, Schema } from "@mwater/expressions";
+import { Cell } from "fixed-data-table-2";
+export interface ExprCellComponentProps {
+    /** schema to use */
+    schema: Schema;
+    /** dataSource to use */
+    dataSource: DataSource;
+    /** Locale to use */
+    locale?: string;
+    exprType: LiteralType;
+    /** Optional format */
+    format?: string;
+    width: number;
+    height: number;
+    value?: any;
+    expr?: any;
+    /** True to show muted */
+    muted?: boolean;
+    onClick?: any;
+}
+export default class ExprCellComponent extends React.Component<ExprCellComponentProps> {
+    handleClick: () => void;
+    renderImage(id: any): React.DetailedReactHTMLElement<{
+        href: string;
+        key: any;
+        target: string;
+        style: {
+            paddingLeft: number;
+            paddingRight: number;
+        };
+    }, HTMLElement>;
+    render(): React.CElement<import("fixed-data-table-2").CellProps, Cell>;
+}

package/lib/datagrids/ExprCellComponent.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = __importDefault(require("lodash"));
+const react_1 = __importDefault(require("react"));
+const R = react_1.default.createElement;
+const moment_1 = __importDefault(require("moment"));
+const expressions_1 = require("@mwater/expressions");
+const react_linkify_1 = __importDefault(require("react-linkify"));
+const fixed_data_table_2_1 = require("fixed-data-table-2");
+const valueFormatter_1 = require("../valueFormatter");
+const valueFormatter_2 = require("../valueFormatter");
+// Cell that displays an expression column cell
+class ExprCellComponent extends react_1.default.Component {
+    handleClick = () => {
+        return this.setState({ editing: true });
+    };
+    renderImage(id) {
+        const url = this.props.dataSource.getImageUrl(id);
+        return R("a", { href: url, key: id, target: "_blank", style: { paddingLeft: 5, paddingRight: 5 } }, "Image");
+    }
+    render() {
+        let node;
+        const exprUtils = new expressions_1.ExprUtils(this.props.schema);
+        let { value } = this.props;
+        if (value == null || !this.props.expr) {
+            node = null;
+        }
+        else {
+            // Parse if should be JSON
+            if (["image", "imagelist", "geometry", "text[]"].includes(this.props.exprType) && lodash_1.default.isString(value)) {
+                value = JSON.parse(value);
+            }
+            // Format if possible
+            if ((0, valueFormatter_1.canFormatType)(this.props.exprType)) {
+                node = (0, valueFormatter_2.formatValue)(this.props.exprType, value, this.props.format);
+            }
+            else {
+                // Convert to node based on type
+                switch (this.props.exprType) {
+                    case "text":
+                        node = R(react_linkify_1.default, { properties: { target: "_blank" } }, value);
+                        break;
+                    case "boolean":
+                    case "enum":
+                    case "enumset":
+                    case "text[]":
+                        node = exprUtils.stringifyExprLiteral(this.props.expr, value, this.props.locale);
+                        break;
+                    case "date":
+                        node = (0, moment_1.default)(value, "YYYY-MM-DD").format("ll");
+                        break;
+                    case "datetime":
+                        node = (0, moment_1.default)(value, moment_1.default.ISO_8601).format("lll");
+                        break;
+                    case "image":
+                        node = this.renderImage(value.id);
+                        break;
+                    case "imagelist":
+                        node = lodash_1.default.map(value, (v) => this.renderImage(v.id));
+                        break;
+                    default:
+                        node = "" + value;
+                }
+            }
+        }
+        return R(fixed_data_table_2_1.Cell, {
+            width: this.props.width,
+            height: this.props.height,
+            onClick: this.props.onClick,
+            style: {
+                whiteSpace: "nowrap",
+                textAlign: ["number"].includes(this.props.exprType) ? "right" : "left",
+                opacity: this.props.muted ? 0.4 : undefined
+            }
+        }, node);
+    }
+}
+exports.default = ExprCellComponent;

package/lib/datagrids/FindReplaceModalComponent.d.ts

@@ -0,0 +1,52 @@
+import React from "react";
+import { RowUpdate } from "./DatagridViewComponent";
+import { DataSource, Expr, Schema } from "@mwater/expressions";
+import { DatagridDesign, JsonQLFilter } from "..";
+export interface FindReplaceModalComponentProps {
+    schema: Schema;
+    dataSource: DataSource;
+    design: DatagridDesign;
+    filters?: JsonQLFilter[];
+    /** Update cell values by updating set of expressions and values */
+    updateExprValues: (tableId: string, rowUpdates: RowUpdate[]) => Promise<void>;
+    onUpdate: () => void;
+}
+interface FindReplaceModalComponentState {
+    /** True if modal is open */
+    open: boolean;
+    /** Column id to replace */
+    replaceColumn: string | null;
+    /** Replace with expression */
+    withExpr: Expr;
+    /** Condition expr */
+    conditionExpr: Expr;
+    /** True when working */
+    busy: boolean;
+}
+export default class FindReplaceModalComponent extends React.Component<FindReplaceModalComponentProps, FindReplaceModalComponentState> {
+    constructor(props: any);
+    show(): void;
+    performReplace(): Promise<void>;
+    renderPreview(): React.CElement<any, React.Component<any, any, any>>;
+    renderContents(): React.DetailedReactHTMLElement<React.HTMLAttributes<HTMLElement>, HTMLElement>;
+    render(): React.CElement<{
+        size: string;
+        header: string;
+        footer: React.DetailedReactHTMLElement<{
+            key: string;
+            type: string;
+            onClick: () => void;
+            className: string;
+        }, HTMLElement>[];
+    }, React.Component<{
+        size: string;
+        header: string;
+        footer: React.DetailedReactHTMLElement<{
+            key: string;
+            type: string;
+            onClick: () => void;
+            className: string;
+        }, HTMLElement>[];
+    }, any, any>> | null;
+}
+export {};

package/lib/datagrids/FindReplaceModalComponent.js

@@ -0,0 +1,248 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = __importDefault(require("lodash"));
+const react_1 = __importDefault(require("react"));
+const R = react_1.default.createElement;
+const react_select_1 = __importDefault(require("react-select"));
+const AutoSizeComponent_1 = __importDefault(require("@mwater/react-library/lib/AutoSizeComponent"));
+const DatagridViewComponent_1 = __importDefault(require("./DatagridViewComponent"));
+const DirectDatagridDataSource_1 = __importDefault(require("./DirectDatagridDataSource"));
+const ModalPopupComponent_1 = __importDefault(require("@mwater/react-library/lib/ModalPopupComponent"));
+const expressions_ui_1 = require("@mwater/expressions-ui");
+const expressions_1 = require("@mwater/expressions");
+const expressions_2 = require("@mwater/expressions");
+const expressions_3 = require("@mwater/expressions");
+const immer_1 = __importDefault(require("immer"));
+// Modal to perform find/replace on datagrid
+class FindReplaceModalComponent extends react_1.default.Component {
+    constructor(props) {
+        super(props);
+        this.state = {
+            open: false,
+            replaceColumn: null,
+            withExpr: null,
+            conditionExpr: null,
+            busy: false
+        };
+    }
+    show() {
+        return this.setState({ open: true, busy: false });
+    }
+    async performReplace() {
+        const exprUtils = new expressions_1.ExprUtils(this.props.schema);
+        const exprCompiler = new expressions_2.ExprCompiler(this.props.schema);
+        const exprCleaner = new expressions_1.ExprCleaner(this.props.schema);
+        const design = this.props.design;
+        // Get expr of replace column
+        const replaceExpr = lodash_1.default.findWhere(this.props.design.columns, { id: this.state.replaceColumn }).expr;
+        // Get ids and with value, filtered by filters, design.filter and conditionExpr (if present)
+        const query = {
+            type: "query",
+            selects: [
+                {
+                    type: "select",
+                    expr: {
+                        type: "field",
+                        tableAlias: "main",
+                        column: this.props.schema.getTable(this.props.design.table).primaryKey
+                    },
+                    alias: "id"
+                },
+                {
+                    type: "select",
+                    expr: exprCompiler.compileExpr({ expr: this.state.withExpr, tableAlias: "main" }),
+                    alias: "withValue"
+                }
+            ],
+            from: { type: "table", table: this.props.design.table, alias: "main" }
+        };
+        // Filter by filter
+        const wheres = [];
+        if (this.props.design.filter) {
+            wheres.push(exprCompiler.compileExpr({ expr: this.props.design.filter, tableAlias: "main" }));
+        }
+        // Filter by conditionExpr
+        if (this.state.conditionExpr) {
+            wheres.push(exprCompiler.compileExpr({ expr: this.state.conditionExpr, tableAlias: "main" }));
+        }
+        // Add global filters
+        for (let filter of design.globalFilters || []) {
+            // Check if exists and is correct type
+            const column = this.props.schema.getColumn(design.table, filter.columnId);
+            if (!column) {
+                continue;
+            }
+            const columnExpr = { type: "field", table: design.table, column: column.id };
+            if (exprUtils.getExprType(columnExpr) !== filter.columnType) {
+                continue;
+            }
+            // Create expr
+            let expr = { type: "op", op: filter.op, table: design.table, exprs: [columnExpr].concat(filter.exprs) };
+            // Clean expr
+            expr = exprCleaner.cleanExpr(expr, { table: design.table });
+            wheres.push(exprCompiler.compileExpr({ expr, tableAlias: "main" }));
+        }
+        // Add extra filters
+        for (let extraFilter of this.props.filters || []) {
+            if (extraFilter.table === this.props.design.table) {
+                wheres.push((0, expressions_3.injectTableAlias)(extraFilter.jsonql, "main"));
+            }
+        }
+        query.where = { type: "op", op: "and", exprs: lodash_1.default.compact(wheres) };
+        this.setState({ busy: true });
+        try {
+            const rows = await this.props.dataSource.performQuery(query);
+            // Confirm
+            if (!confirm(T("Replace {0} values? This cannot be undone.", rows.length))) {
+                return;
+            }
+            // Perform updates
+            await this.props.updateExprValues(this.props.design.table, rows.map(row => ({
+                primaryKey: row.id,
+                expr: replaceExpr,
+                value: row.withValue
+            })));
+            alert(T("Successfully replaced {0} values", rows.length));
+            this.setState({ open: false });
+            this.props.onUpdate();
+        }
+        catch (error) {
+            alert(`Error: ${error.message}`);
+        }
+        finally {
+            this.setState({ busy: false });
+        }
+    }
+    renderPreview() {
+        const exprUtils = new expressions_1.ExprUtils(this.props.schema);
+        // Replace "replace" column with fake case statement to simulate change
+        const design = (0, immer_1.default)(this.props.design, draft => {
+            const replaceColumn = draft.columns.find(column => column.id == this.state.replaceColumn);
+            if (replaceColumn) {
+                replaceColumn.expr = {
+                    type: "case",
+                    table: this.props.design.table,
+                    cases: [
+                        {
+                            when: this.state.conditionExpr || { type: "literal", valueType: "boolean", value: true },
+                            then: this.state.withExpr
+                        }
+                    ],
+                    // Unchanged
+                    else: replaceColumn.expr
+                };
+                replaceColumn.label = replaceColumn.label || exprUtils.summarizeExpr(replaceColumn.expr, this.props.design.locale);
+            }
+            // Add filter
+            if (this.state.conditionExpr) {
+                if (draft.filter) {
+                    draft.filter = {
+                        type: "op",
+                        op: "and",
+                        table: this.props.design.table,
+                        exprs: [
+                            draft.filter,
+                            this.state.conditionExpr
+                        ]
+                    };
+                }
+                else {
+                    draft.filter = this.state.conditionExpr;
+                }
+            }
+        });
+        return R(AutoSizeComponent_1.default, { injectWidth: true }, (size) => {
+            return R(DatagridViewComponent_1.default, {
+                width: size.width,
+                height: 400,
+                schema: this.props.schema,
+                dataSource: this.props.dataSource,
+                datagridDataSource: new DirectDatagridDataSource_1.default({
+                    schema: this.props.schema,
+                    dataSource: this.props.dataSource
+                }),
+                design,
+                filters: this.props.filters
+            });
+        });
+    }
+    renderContents() {
+        let value;
+        const exprUtils = new expressions_1.ExprUtils(this.props.schema);
+        // Determine which columns are replace-able. Excludes subtables and aggregates
+        const replaceColumns = lodash_1.default.filter(this.props.design.columns, (column) => !column.subtable && exprUtils.getExprAggrStatus(column.expr) === "individual");
+        const replaceColumnOptions = lodash_1.default.map(replaceColumns, (column) => ({
+            value: column.id,
+            label: column.label || exprUtils.summarizeExpr(column.expr, this.props.design.locale)
+        }));
+        // Show progress
+        if (this.state.busy) {
+            return R("div", null, R("h3", null, T("Working...")), R("div", { className: "progress" }, R("div", { className: "progress-bar progress-bar-striped progress-bar-animated", style: { width: `100%` } })));
+        }
+        return R("div", null, R("div", { key: "replace", className: "mb-3" }, R("label", null, T("Column with data to replace") + ": "), R(react_select_1.default, {
+            options: replaceColumnOptions,
+            value: lodash_1.default.findWhere(replaceColumnOptions, { value: this.state.replaceColumn }) || null,
+            onChange: (opt) => this.setState({ replaceColumn: opt.value }),
+            placeholder: T("Select Column..."),
+            styles: {
+                // Keep menu above fixed data table headers
+                menu: (style) => lodash_1.default.extend({}, style, { zIndex: 2 })
+            }
+        })), (() => {
+            if (this.state.replaceColumn) {
+                // Get expr of replace column
+                const replaceExpr = lodash_1.default.findWhere(this.props.design.columns, { id: this.state.replaceColumn }).expr;
+                return R("div", { key: "with", className: "mb-3" }, R("label", null, T("Value to replace data with") + ": "), R(expressions_ui_1.ExprComponent, {
+                    schema: this.props.schema,
+                    dataSource: this.props.dataSource,
+                    table: this.props.design.table,
+                    value: this.state.withExpr,
+                    onChange: (value) => this.setState({ withExpr: value }),
+                    types: [exprUtils.getExprType(replaceExpr)],
+                    enumValues: exprUtils.getExprEnumValues(replaceExpr) || undefined,
+                    idTable: exprUtils.getExprIdTable(replaceExpr) || undefined,
+                    preferLiteral: true,
+                    placeholder: T("(Blank)"),
+                    refExpr: replaceExpr
+                }));
+            }
+            return null;
+        })(), R("div", { key: "condition", className: "mb-3" }, R("label", null, T("Only in rows that (optional)") + ":"), R(expressions_ui_1.ExprComponent, {
+            schema: this.props.schema,
+            dataSource: this.props.dataSource,
+            table: this.props.design.table,
+            value: this.state.conditionExpr,
+            onChange: (value) => this.setState({ conditionExpr: value }),
+            types: ["boolean"],
+            placeholder: T("All Rows")
+        })), R("div", { key: "preview" }, R("h4", null, T("Preview")), this.renderPreview()));
+    }
+    render() {
+        if (!this.state.open) {
+            return null;
+        }
+        return R(ModalPopupComponent_1.default, {
+            size: "large",
+            header: T("Find/Replace"),
+            footer: [
+                R("button", {
+                    key: "cancel",
+                    type: "button",
+                    onClick: () => this.setState({ open: false }),
+                    className: "btn btn-secondary"
+                }, T("Cancel")),
+                R("button", {
+                    key: "apply",
+                    type: "button",
+                    disabled: !this.state.replaceColumn || this.state.busy,
+                    onClick: () => this.performReplace(),
+                    className: "btn btn-primary"
+                }, T("Apply"))
+            ]
+        }, this.renderContents());
+    }
+}
+exports.default = FindReplaceModalComponent;

package/lib/datagrids/LabeledExprGenerator.d.ts

@@ -0,0 +1,40 @@
+import { Column, Expr, Schema } from "@mwater/expressions";
+/** Expression with a label attached */
+export interface LabeledExpr {
+    expr: Expr;
+    label: string;
+    /** Which joins from the originating table to get to expression. Used for 1-n joins
+     * which are included (they are not by default). In most cases will be []
+     */
+    joins: string[];
+}
+export interface LabeledExprGeneratorOptions {
+    /** e.g. "en". Uses _base by default, then en [null] */
+    locale?: string | null;
+    /** "text", "code" or "both" ["code"] */
+    headerFormat?: "text" | "code" | "both";
+    /** "name" or "code" ["name"] */
+    enumFormat?: "name" | "code";
+    /** split geometry into lat/lng [false] */
+    splitLatLng?: boolean;
+    /** split enumset into true/false expressions [false] */
+    splitEnumset?: boolean;
+    /** use ids of n-1 joins, not the code/name/etc [false] */
+    useJoinIds?: boolean;
+    /** optional boolean predicate to filter columns included. Called with table id, column object */
+    columnFilter?: (tableId: string, column: Column) => boolean;
+    /** optional boolean predicate to filter 1-n/n-n joins to include. Called with table id, join column object. Default is to not include those joins */
+    multipleJoinCondition?: (tableId: string, column: Column) => boolean;
+    /** optional boolean to replace redacted columns with unredacted ones */
+    useConfidential?: boolean;
+    /** number duplicate label columns with " (1)", " (2)" , etc. */
+    numberDuplicatesLabels?: boolean;
+    /** Override how a column is processed. Return array if processed, null to pass through */
+    overrideColumn?: (tableId: string, column: Column, joins: string[], label: string) => null | LabeledExpr[];
+}
+/** Generates labeled expressions (expr, label and joins) for a table. Used to make a datagrid, do export or import. */
+export default class LabeledExprGenerator {
+    schema: Schema;
+    constructor(schema: Schema);
+    generate(table: string, options?: LabeledExprGeneratorOptions): LabeledExpr[];
+}