@adaptabletools/adaptable-cjs 17.0.0-canary.1

package/src/Utilities/Defaults/DefaultAdaptableOptions.js

@@ -0,0 +1,331 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultAdaptableOptions = void 0;
+const tslib_1 = require("tslib");
+const GeneralConstants = tslib_1.__importStar(require("../Constants/GeneralConstants"));
+const GeneralConstants_1 = require("../Constants/GeneralConstants");
+const UIHelper_1 = tslib_1.__importStar(require("../../View/UIHelper"));
+const AdaptablePredicate_1 = require("../../PredefinedConfig/Common/AdaptablePredicate");
+const Enums_1 = require("../../PredefinedConfig/Common/Enums");
+const ModuleConstants = tslib_1.__importStar(require("../../Utilities/Constants/ModuleConstants"));
+// change type to DeepRequired<AdaptableOptions> to check which properties have no default values defined
+exports.DefaultAdaptableOptions = {
+    adaptableId: GeneralConstants.ADAPTABLE_ID,
+    adaptableStateKey: undefined,
+    primaryKey: '',
+    autogeneratePrimaryKey: false,
+    userName: GeneralConstants.USER_NAME,
+    predefinedConfig: undefined,
+    alertOptions: {
+        alertForms: undefined,
+        maxAlertsInStore: 20,
+        cellHighlightDuration: 2000,
+        rowHighlightDuration: 4000,
+        statusbarHighlightDuration: 2000,
+        dataChangeDetectionPolicy: 'rawValue',
+        actionHandlers: undefined,
+        alertMessageText: undefined,
+        showMissingPrimaryKeyAlert: false,
+    },
+    notificationsOptions: {
+        maxNotifications: 3,
+        position: 'BottomRight',
+        duration: 3000,
+        showProgressBar: false,
+        closeWhenClicked: false,
+        pauseWhenHovering: false,
+        isDraggable: false,
+        transition: 'Slide',
+        showApplicationIcon: false,
+        showSystemStatusMessageNotifications: false,
+        maxSystemMessagesInStore: 100,
+    },
+    dataImportOptions: {
+        fileHandlers: undefined,
+    },
+    flashingCellOptions: {
+        defaultFlashDuration: 500,
+        defaultFlashTarget: 'cell',
+        defaultDownChangeStyle: {
+            BackColor: (0, UIHelper_1.getHexForName)(UIHelper_1.RED),
+        },
+        defaultUpChangeStyle: {
+            BackColor: (0, UIHelper_1.getHexForName)(UIHelper_1.GREEN),
+        },
+        defaultNeutralChangeStyle: {
+            BackColor: (0, UIHelper_1.getHexForName)(UIHelper_1.GRAY),
+        },
+    },
+    expressionOptions: {
+        evaluateAdaptableQLExternally: undefined,
+        displayColumnFriendlyNamesForExpressions: true,
+        systemBooleanFunctions: undefined,
+        systemScalarFunctions: undefined,
+        systemObservableFunctions: undefined,
+        systemAggregatedBooleanFunctions: undefined,
+        systemAggregatedScalarFunctions: undefined,
+        moduleExpressionFunctions: undefined,
+        performExpressionValidation: true,
+        maxTimeframeSize: 28800000,
+        caseSensitiveExpressions: false,
+    },
+    calendarOptions: { holidays: undefined },
+    cellSummaryOptions: { cellSummaryOperations: undefined },
+    containerOptions: {
+        adaptableContainer: 'adaptable',
+        agGridContainer: 'grid',
+        agGridContainerWaitTimeout: 60000,
+        modalContainer: undefined,
+        systemStatusContainer: undefined,
+        alertContainer: undefined,
+    },
+    columnOptions: {
+        columnFriendlyName: undefined,
+        columnTypes: GeneralConstants_1.EMPTY_ARRAY,
+        showMissingColumnsWarning: true,
+        addColumnGroupToColumnFriendlyName: false,
+    },
+    dashboardOptions: {
+        canFloat: true,
+        showQuickSearchInHeader: true,
+        customDashboardButtons: undefined,
+        customToolbars: undefined,
+        buttonsLocation: 'right',
+    },
+    actionColumnOptions: {
+        actionColumns: undefined,
+    },
+    actionRowOptions: {
+        actionRowButtons: undefined,
+        autoHandle: true,
+        disableInlineEditing: false,
+        setPrimaryKeyValue: undefined,
+        actionRowButtonOptions: {
+            customConfiguration: undefined,
+            position: 'pinnedLeft',
+        },
+        actionRowFormOptions: {
+            formTitle: undefined,
+            formDescription: undefined,
+            formFieldLabel: undefined,
+            formButtons: undefined,
+            onFormSubmit: undefined,
+        },
+    },
+    editOptions: {
+        validateOnServer: undefined,
+        displayServerValidationMessages: true,
+        isCellEditable: undefined,
+        smartEditCustomOperations: undefined,
+    },
+    entitlementOptions: {
+        defaultAccessLevel: 'Full',
+        moduleEntitlements: undefined,
+    },
+    exportOptions: {
+        exportFormatType: 'rawValue',
+        exportDateFormat: undefined,
+        customDestinations: undefined,
+        externalReports: undefined,
+        appendFileTimestamp: false,
+        systemExportDestinations: [
+            Enums_1.ExportDestination.Excel,
+            Enums_1.ExportDestination.CSV,
+            Enums_1.ExportDestination.Clipboard,
+            Enums_1.ExportDestination.JSON,
+            Enums_1.ExportDestination.Table,
+        ],
+        systemReportNames: [
+            GeneralConstants.ALL_DATA_REPORT,
+            GeneralConstants.CURRENT_DATA_REPORT,
+            GeneralConstants.VISUAL_DATA_REPORT,
+            GeneralConstants.SELECTED_CELLS_REPORT,
+            GeneralConstants.SELECTED_ROWS_REPORT,
+        ],
+        reportFilename: undefined,
+    },
+    customSortOptions: { customSortComparers: undefined },
+    dataSetOptions: { dataSets: GeneralConstants_1.EMPTY_ARRAY },
+    groupingOptions: {
+        showGroupingTotalsAsHeader: false,
+        unbalancedGroupsKey: undefined,
+        restoreUngroupedColumns: false,
+        autoOrderGroupedColumns: true,
+    },
+    formatColumnOptions: {
+        customDisplayFormatters: undefined,
+    },
+    layoutOptions: {
+        displayRowGroups: 'closed',
+        autoSaveLayouts: true,
+        autoSizeColumnsInLayout: false,
+        autoSizeColumnsInPivotLayout: false,
+        createDefaultLayout: false,
+        layoutViewOptions: {
+            maxColumnsToDisplay: 10,
+        },
+        layoutTagOptions: {
+            autoGenerateTagsForLayouts: false,
+            isObjectAvailableInLayout: undefined,
+            autoCheckTagsForLayouts: false,
+        },
+    },
+    menuOptions: {
+        customColumnMenu: undefined,
+        customContextMenu: undefined,
+        showAdaptableContextMenu: true,
+        showAdaptableColumnMenu: true,
+        showUngroupColumnMenuItem: true,
+        columnMenuOrder: ['aggrid', 'adaptable', 'user'],
+        contextMenuOrder: ['aggrid', 'adaptable', 'user'],
+        columnMenuItems: undefined,
+        contextMenuItems: undefined,
+    },
+    columnFilterOptions: {
+        quickFilterOptions: {
+            hideQuickFilterDropdown: undefined,
+            hideQuickFilterInput: undefined,
+            quickFilterTrigger: 'mouseenter',
+            quickFilterValuesTrigger: 'mouseenter',
+            quickFilterDebounce: 250,
+            quickFilterHeight: null,
+            showQuickFilter: true,
+            quickFilterWildcards: {},
+            quickFilterValuesWidth: 180,
+        },
+        filterFormOptions: {
+            useAgGridFilterFormStyle: true,
+            defaultFilterFormTab: 'Values',
+        },
+        valuesFilterOptions: {
+            sortValuesFilter: false,
+            filterValuesUsingTime: false,
+            showDistinctFilteredValuesOnly: false,
+            maxFilterValuesToDisplay: 2000,
+            includeBlankFilterValues: false,
+            showValuesCount: undefined,
+        },
+        indicateFilteredColumns: true,
+        useAdaptableColumnFiltering: true,
+        clearColumnFiltersOnStartUp: false,
+        filterActionOnUserDataChange: {
+            applyFilter: GeneralConstants.FILTER_ALWAYS,
+            throttleDelay: 0,
+        },
+        filterActionOnExternalDataChange: {
+            applyFilter: GeneralConstants.FILTER_NEVER,
+            throttleDelay: 0,
+        },
+        autoApplyFilter: true,
+        defaultNumericColumnFilter: 'Equals',
+        defaultStringColumnFilter: 'Contains',
+        defaultDateColumnFilter: 'On',
+        enableFilterOnSpecialColumns: true,
+        showClearFilterButton: false,
+        showSuspendFilterButton: false,
+    },
+    gridFilterOptions: {
+        availableFilterEditors: 'Both',
+        clearGridFilterOnStartUp: false,
+    },
+    predicateOptions: {
+        customPredicateDefs: [],
+        systemFilterPredicates: AdaptablePredicate_1.SystemFilterPredicateIds,
+        systemAlertPredicates: AdaptablePredicate_1.SystemAlertPredicateIds,
+        systemFormatColumnPredicates: AdaptablePredicate_1.SystemFormatColumnPredicateIds,
+        systemFlashingCellPredicates: AdaptablePredicate_1.SystemFlashingCellPredicateIds,
+        systemBadgeStylePredicates: AdaptablePredicate_1.SystemBadgeStylePredicateIds,
+        caseSensitivePredicates: false,
+    },
+    quickSearchOptions: {
+        excludeColumnFromQuickSearch: undefined,
+        runQuickSearchOnRowGroups: true,
+        runQuickSearchOnPivotColumns: true,
+        clearQuickSearchOnStartUp: false,
+        quickSearchPlaceholder: 'Search',
+        filterResultsAfterQuickSearch: false,
+        runQuickSearchWithCaseSensitivity: false,
+        runBespokeQuickSearch: undefined,
+    },
+    stateOptions: {
+        debounceStateDelay: 400,
+        applyState: (state) => state,
+        saveState: (state) => state,
+        loadState: undefined,
+        persistState: undefined,
+        clearState: undefined,
+    },
+    teamSharingOptions: {
+        enableTeamSharing: false,
+        persistSharedEntities: undefined,
+        loadSharedEntities: undefined,
+        applySharedEntities: (sharedEntities) => sharedEntities,
+        saveSharedEntities: (sharedEntities) => sharedEntities,
+        updateInterval: 0,
+        updateNotification: undefined,
+        suppressOverrideConfigWarning: false,
+        showUpdateNotificationOncePerUpdate: false,
+    },
+    userInterfaceOptions: {
+        alternativeModuleNames: undefined,
+        applicationIcon: undefined,
+        useCustomMacLikeScrollbars: false,
+        englishVariant: 'GB',
+        showLoadingScreen: true,
+        disableDeleteConfirmation: false,
+        dateInputOptions: {
+            useNativeInput: false,
+            dateFormat: 'yyyy-MM-dd',
+            // locale is not explicitly defaulted to 'en-US' as this is already done by the react-day-picker
+            showWeekNumber: false,
+            showOutsideDays: true,
+            datepickerButtons: ['close', 'today'],
+        },
+        colorPalette: UIHelper_1.default.getDefaultColors(),
+        editableCellStyle: undefined,
+        readOnlyCellStyle: undefined,
+        styleClassNames: GeneralConstants_1.EMPTY_ARRAY,
+        permittedValues: undefined,
+        editLookUpItems: undefined,
+        showDocumentationLinks: true,
+        showAdapTableVersion: true,
+    },
+    toolPanelOptions: {
+        showToolPanelsDropdown: true,
+        customButtons: undefined,
+        customToolPanels: undefined,
+    },
+    dataChangeHistoryOptions: {
+        activeByDefault: false,
+        showDataChange: undefined,
+        changeHistoryButton: undefined,
+    },
+    settingsPanelOptions: {
+        popupType: 'window',
+        title: ModuleConstants.SettingsPanelFriendlyName,
+        icon: 'ConfigurationIcon',
+        navigation: {},
+        alwaysShowInDashboard: false,
+        alwaysShowInToolPanel: false,
+    },
+    chartingOptions: {
+        saveStrategy: 'none',
+        agGridContainerName: GeneralConstants.AG_GRID_CHART_WINDOW,
+        externalChartingOptions: {},
+    },
+    fdc3Options: {
+        enableLogging: false,
+        actionColumnDefaultConfiguration: {
+            columnId: 'fdc3ActionColumn',
+            headerName: 'FDC3 Actions',
+            width: 200,
+            resizable: true,
+            movable: false,
+        },
+        uiControlsDefaultConfiguration: {
+            // default config is set in FDC3 Service, to make it easier to overview
+            contexts: {},
+            intents: {},
+        },
+    },
+};

package/src/Utilities/Defaults/DefaultSettingsPanel.d.ts

@@ -0,0 +1,7 @@
+import { AdaptableSettingsPanel } from '../../PredefinedConfig/Common/Types';
+import { AdaptableModule } from '../../types';
+export declare const STANDALONE_MODULE_POPUPS: AdaptableModule[];
+/**
+ * This constants determines the order and the items that appear in the navigation.
+ */
+export declare const DEFAULT_SETTINGS_PANEL_NAVIGATION_ITEMS: (AdaptableSettingsPanel | '-')[];

package/src/Utilities/Defaults/DefaultSettingsPanel.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SETTINGS_PANEL_NAVIGATION_ITEMS = exports.STANDALONE_MODULE_POPUPS = void 0;
+exports.STANDALONE_MODULE_POPUPS = [
+    'BulkUpdate',
+    'SmartEdit',
+    'CellSummary',
+];
+/**
+ * This constants determines the order and the items that appear in the navigation.
+ */
+exports.DEFAULT_SETTINGS_PANEL_NAVIGATION_ITEMS = [
+    'GridInfo',
+    'ColumnInfo',
+    'Dashboard',
+    'ToolPanel',
+    'StatusBar',
+    '-',
+    'Layout',
+    'Export',
+    'CalculatedColumn',
+    'FreeTextColumn',
+    'CustomSort',
+    'Alert',
+    'SystemStatus',
+    '-',
+    'FormatColumn',
+    'StyledColumn',
+    'FlashingCell',
+    'Theme',
+    '-',
+    'QuickSearch',
+    'GridFilter',
+    'ColumnFilter',
+    'DataSet',
+    '-',
+    'PlusMinus',
+    'Shortcut',
+    'DataChangeHistory',
+    '-',
+    'Charting',
+    'DataImport',
+    'Schedule',
+    'NamedQuery',
+    'StateManagement',
+    'TeamSharing',
+    'Notes',
+];

package/src/Utilities/Emitter.d.ts

@@ -0,0 +1,22 @@
+/** based on emittery npm package, which is MIT */
+export type EmitterCallback = (data?: any) => any;
+export type EmitterAnyCallback = (eventName: string, data?: any) => any;
+declare class Emittery {
+    static mixin(emitteryPropertyName: string, methodNames: string[]): (target: any) => any;
+    constructor();
+    destroy(): void;
+    on(eventName: string, listener: EmitterCallback): any;
+    off(eventName: string, listener: EmitterCallback): void;
+    once(eventName: string): Promise<unknown>;
+    onIncludeFiredOnce(eventName: string): Promise<any>;
+    onIncludeFired(eventName: string, listener: EmitterCallback): any;
+    emit(eventName: string, eventData?: any): Promise<any[]>;
+    emitSync(eventName: string, eventData?: any): any[];
+    emitSerial(eventName: string, eventData: any): Promise<void>;
+    onAny(listener: EmitterAnyCallback): any;
+    offAny(listener: EmitterCallback): void;
+    clearListeners(eventName?: string): void;
+    listenerCount(eventName: string): any;
+    bindMethods(target: any, methodNames: string[]): void;
+}
+export default Emittery;

package/src/Utilities/Emitter.js

@@ -0,0 +1,246 @@
+"use strict";
+/** based on emittery npm package, which is MIT */
+Object.defineProperty(exports, "__esModule", { value: true });
+const anyMap = new WeakMap();
+const eventsMap = new WeakMap();
+const triggeredMap = new WeakMap();
+const resolvedPromise = Promise.resolve();
+//type EmitterCallback = (data?: any) => any;
+function assertEventName(eventName) {
+    if (typeof eventName !== 'string') {
+        throw new TypeError('eventName must be a string');
+    }
+}
+function assertListener(listener) {
+    if (typeof listener !== 'function') {
+        throw new TypeError('listener must be a function');
+    }
+}
+function getListeners(instance, eventName) {
+    const events = eventsMap.get(instance);
+    if (!events) {
+        // we're hitting this case only when calling `off` after the instance has been destroyed (so extremely rarely)
+        // so we want to return an empty set in order not to make the code throw an error
+        return new Set();
+    }
+    if (!events.has(eventName)) {
+        events.set(eventName, new Set());
+    }
+    return events.get(eventName);
+}
+function defaultMethodNamesOrAssert(methodNames) {
+    if (methodNames === undefined) {
+        return allEmitteryMethods;
+    }
+    if (!Array.isArray(methodNames)) {
+        throw new TypeError('`methodNames` must be an array of strings');
+    }
+    for (const methodName of methodNames) {
+        if (!allEmitteryMethods.includes(methodName)) {
+            if (typeof methodName !== 'string') {
+                throw new TypeError('`methodNames` element must be a string');
+            }
+            throw new Error(`${methodName} is not Emittery method`);
+        }
+    }
+    return methodNames;
+}
+class Emittery {
+    static mixin(emitteryPropertyName, methodNames) {
+        methodNames = defaultMethodNamesOrAssert(methodNames);
+        return (target) => {
+            if (typeof target !== 'function') {
+                throw new TypeError('`target` must be function');
+            }
+            for (const methodName of methodNames) {
+                if (target.prototype[methodName] !== undefined) {
+                    throw new Error(`The property \`${methodName}\` already exists on \`target\``);
+                }
+            }
+            function getEmitteryProperty() {
+                Object.defineProperty(this, emitteryPropertyName, {
+                    enumerable: false,
+                    value: new Emittery(),
+                });
+                return this[emitteryPropertyName];
+            }
+            Object.defineProperty(target.prototype, emitteryPropertyName, {
+                enumerable: false,
+                get: getEmitteryProperty,
+            });
+            const emitteryMethodCaller = (methodName) => (function(...args) {
+                return this[emitteryPropertyName][methodName](...args);
+            });
+            for (const methodName of methodNames) {
+                Object.defineProperty(target.prototype, methodName, {
+                    enumerable: false,
+                    value: emitteryMethodCaller(methodName),
+                });
+            }
+            return target;
+        };
+    }
+    constructor() {
+        anyMap.set(this, new Set());
+        eventsMap.set(this, new Map());
+        triggeredMap.set(this, new Map());
+    }
+    destroy() {
+        this.clearListeners();
+        // should not be needed, since those maps are weak
+        // but let's do it anyway - some of our users suggested this Emitter class
+        // could be a source of memory leaks, so let's clean this up
+        anyMap.delete(this);
+        eventsMap.delete(this);
+        triggeredMap.delete(this);
+    }
+    on(eventName, listener) {
+        assertEventName(eventName);
+        assertListener(listener);
+        getListeners(this, eventName).add(listener);
+        return this.off.bind(this, eventName, listener);
+    }
+    off(eventName, listener) {
+        assertEventName(eventName);
+        assertListener(listener);
+        getListeners(this, eventName).delete(listener);
+    }
+    once(eventName) {
+        return new Promise((resolve) => {
+            assertEventName(eventName);
+            const off = this.on(eventName, (data) => {
+                off();
+                resolve(data);
+            });
+        });
+    }
+    onIncludeFiredOnce(eventName) {
+        const triggeredEventsMap = triggeredMap.get(this);
+        const eventInfo = triggeredEventsMap.get(eventName);
+        if (eventInfo) {
+            return Promise.resolve(eventInfo.data);
+        }
+        return this.once(eventName);
+    }
+    onIncludeFired(eventName, listener) {
+        const triggeredEventsMap = triggeredMap.get(this);
+        const eventInfo = triggeredEventsMap.get(eventName);
+        if (eventInfo) {
+            listener(eventInfo.data);
+        }
+        return this.on(eventName, listener);
+    }
+    async emit(eventName, eventData) {
+        assertEventName(eventName);
+        const listeners = getListeners(this, eventName);
+        const triggeredEventsMap = triggeredMap.get(this);
+        const anyListeners = anyMap.get(this);
+        const staticListeners = [...listeners];
+        const staticAnyListeners = [...anyListeners];
+        triggeredEventsMap.set(eventName, { data: eventData });
+        await resolvedPromise;
+        return Promise.all([
+            ...staticListeners.map(async (listener) => {
+                if (listeners.has(listener)) {
+                    return listener(eventData);
+                }
+            }),
+            ...staticAnyListeners.map(async (listener) => {
+                if (anyListeners.has(listener)) {
+                    return listener(eventName, eventData);
+                }
+            }),
+        ]);
+    }
+    emitSync(eventName, eventData) {
+        assertEventName(eventName);
+        const listeners = getListeners(this, eventName);
+        const triggeredEventsMap = triggeredMap.get(this);
+        const anyListeners = anyMap.get(this);
+        const staticListeners = [...listeners];
+        const staticAnyListeners = [...anyListeners];
+        triggeredEventsMap.set(eventName, { data: eventData });
+        return [
+            ...staticListeners.map((listener) => {
+                if (listeners.has(listener)) {
+                    return listener(eventData);
+                }
+            }),
+            ...staticAnyListeners.map((listener) => {
+                if (anyListeners.has(listener)) {
+                    return listener(eventName, eventData);
+                }
+            }),
+        ];
+    }
+    async emitSerial(eventName, eventData) {
+        assertEventName(eventName);
+        const listeners = getListeners(this, eventName);
+        const anyListeners = anyMap.get(this);
+        const staticListeners = [...listeners];
+        const staticAnyListeners = [...anyListeners];
+        await resolvedPromise;
+        /* eslint-disable no-await-in-loop */
+        for (const listener of staticListeners) {
+            if (listeners.has(listener)) {
+                await listener(eventData);
+            }
+        }
+        for (const listener of staticAnyListeners) {
+            if (anyListeners.has(listener)) {
+                await listener(eventName, eventData);
+            }
+        }
+        /* eslint-enable no-await-in-loop */
+    }
+    onAny(listener) {
+        assertListener(listener);
+        anyMap.get(this).add(listener);
+        return this.offAny.bind(this, listener);
+    }
+    offAny(listener) {
+        assertListener(listener);
+        anyMap.get(this).delete(listener);
+    }
+    clearListeners(eventName) {
+        if (typeof eventName === 'string') {
+            getListeners(this, eventName).clear();
+        }
+        else {
+            anyMap.get(this).clear();
+            for (const listeners of eventsMap.get(this).values()) {
+                listeners.clear();
+            }
+        }
+    }
+    listenerCount(eventName) {
+        if (typeof eventName === 'string') {
+            return anyMap.get(this).size + getListeners(this, eventName).size;
+        }
+        if (typeof eventName !== 'undefined') {
+            assertEventName(eventName);
+        }
+        let count = anyMap.get(this).size;
+        for (const value of eventsMap.get(this).values()) {
+            count += value.size;
+        }
+        return count;
+    }
+    bindMethods(target, methodNames) {
+        if (typeof target !== 'object' || target === null) {
+            throw new TypeError('`target` must be an object');
+        }
+        methodNames = defaultMethodNamesOrAssert(methodNames);
+        for (const methodName of methodNames) {
+            if (target[methodName] !== undefined) {
+                throw new Error(`The property \`${methodName}\` already exists on \`target\``);
+            }
+            Object.defineProperty(target, methodName, {
+                enumerable: false,
+                value: this[methodName].bind(this),
+            });
+        }
+    }
+}
+const allEmitteryMethods = Object.getOwnPropertyNames(Emittery.prototype).filter((v) => v !== 'constructor');
+exports.default = Emittery;

package/src/Utilities/ExpressionFunctions/aggregatedBooleanExpressionFunctions.d.ts

@@ -0,0 +1,20 @@
+import { ExpressionFunction } from '../../parser/src/types';
+import { BaseParameter } from './expressionFunctionUtils';
+import { AggregatedScalarExpressionEvaluation } from './aggregatedScalarExpressionFunctions';
+/**
+ * List of all the Aggregation Functions available in AdaptableQL
+ */
+export type AggregatedBooleanFunctionName = 'WHERE' | 'COL' | 'GROUP_BY' | 'WEIGHT' | AggregationFunction | ComparisonFunction;
+type AggregationFunction = 'SUM' | 'MIN' | 'MAX' | 'AVG' | 'COUNT';
+type ComparisonFunction = 'EQ' | 'NEQ' | 'LT' | 'GT' | 'LTE' | 'GTE';
+export interface BooleanAggregationParameter extends BaseParameter<'aggregationBoolean', AggregationFunction> {
+    scalarAggregation: ScalarAggregationOperand;
+    conditionValue: number;
+    conditionFn: (aggregatedValue: number, conditionValue: number) => boolean;
+}
+export interface ScalarAggregationOperand extends BaseParameter<'aggregationScalar', AggregationFunction> {
+    value: AggregatedScalarExpressionEvaluation;
+}
+export declare const aggregatedBooleanExpressionFunctions: Record<AggregatedBooleanFunctionName, ExpressionFunction>;
+export declare const aggregatedBooleanExpressionFunctionNames: AggregatedBooleanFunctionName[];
+export {};