@talxis/base-controls 1.2406.2

package/src/components/Grid/filtering/model/Condition.ts

@@ -0,0 +1,309 @@
+import { DatasetConditionOperator } from "../../core/enums/ConditionOperator";
+import { DataType } from "../../core/enums/DataType";
+import { IGridColumn } from "../../core/interfaces/IGridColumn";
+import { Grid } from "../../core/model/Grid";
+import { GridDependency } from "../../core/model/GridDependency";
+import { ColumnValidation } from "../../validation/model/ColumnValidation";
+import { FilteringUtils } from "../utils/FilteringUtilts";
+
+export class Condition extends GridDependency {
+    private _column: IGridColumn;
+    private _isAppliedToDataset: boolean = false;
+    private _conditionExpression: ComponentFramework.PropertyHelper.DataSetApi.ConditionExpression = {} as any;
+    private _isRemoved?: boolean;
+    private _conditionUtils = FilteringUtils.condition();
+    private _isValid: boolean = true;
+    private _inicializationPromise: Promise<boolean> | undefined;
+    private _initialized: boolean = false;
+
+    constructor(grid: Grid, column: IGridColumn) {
+        super(grid);
+        this._column = column;
+        return new Proxy(this, {
+            get: (target, prop) => {
+                if(prop !== 'init') {
+                    if(!target._initialized) {
+                        throw new Error('Condition has not been initialized. Make sure to call the init() method on the condition object before any operations.')
+                    }
+                }
+                //@ts-ignore
+                if (typeof target[prop] === 'function') {
+                    //@ts-ignore
+                    return target[prop].bind(target);
+                }
+                //@ts-ignore
+                return target[prop];
+            }
+        })
+    }
+    public async init() {
+        if (!this._inicializationPromise) {
+            this._inicializationPromise = new Promise(async (resolve) => {
+                const [map, key] = await this._getConditionFromFilterExpression();
+                if(!key) {
+                    this._conditionExpression = this._getDefault();
+                }
+                else {
+                    this._isAppliedToDataset = true;
+                    this._conditionExpression = map.get(key)!;
+                }
+                this._conditionExpression.conditionOperator = this._operatorDecorator(this._conditionExpression.conditionOperator, this._conditionExpression.value, true) as any;
+                this._conditionExpression.value = this._valueDecorator(this._conditionExpression.conditionOperator, this._conditionExpression.value, true);
+                this._conditionExpression.attributeName = await this._attributeNameDecorator(this._conditionExpression.conditionOperator, this._conditionExpression.attributeName, true);
+                resolve(true);
+                this._initialized = true;
+            })
+        }
+        return this._inicializationPromise;
+    }
+    public get isRemoved() {
+        return this._isRemoved;
+    }
+
+    public get column() {
+        return this._column;
+    }
+
+    public get isAppliedToDataset() {
+        return this._isAppliedToDataset;
+    }
+
+    public get isValid() {
+        return this._isValid;
+    }
+
+    public async getExpression() {
+        const result = { ...this._conditionExpression };
+        result.conditionOperator = this._operatorDecorator(this._conditionExpression.conditionOperator, this._conditionExpression.value) as any;
+        result.value = this._valueDecorator(this._conditionExpression.conditionOperator, this._conditionExpression.value);
+        result.attributeName = await this._attributeNameDecorator(this._conditionExpression.conditionOperator, this._conditionExpression.attributeName);
+        return result;
+
+    }
+    public async save(): Promise<boolean> {
+        if (!await this.value.isValid()) {
+            this._isValid = false;
+            this._triggerRefreshCallbacks();
+            return false;
+        }
+        const filterExpression = this._filterExpression;
+        if (this._isAppliedToDataset || this._isRemoved) {
+            const [map, key] = await this._getConditionFromFilterExpression();
+            map.delete(key);
+            filterExpression.conditions = [...map.values()];
+        }
+        if (!this._isRemoved) {
+            filterExpression.conditions.push(await this.getExpression());
+        }
+        this._dataset.filtering.setFilter(filterExpression);
+        return true;
+
+    }
+    public remove() {
+        this._isRemoved = true;
+    }
+    public clear() {
+        this._inicializationPromise = undefined;
+    }
+    public get operator() {
+        return {
+            get: () => this._get('operator') as DatasetConditionOperator,
+            set: (conditionOperator: DatasetConditionOperator) => {
+                const previousOperator = this._conditionExpression.conditionOperator
+                this._set("operator", conditionOperator, null);
+                const isCurrentEditable = this._conditionUtils.value(conditionOperator).isManuallyEditable;
+                const isPreviousEditable = this._conditionUtils.value(previousOperator).isManuallyEditable;
+
+                if (isCurrentEditable !== isPreviousEditable) {
+                    // we are transitioning between editable and non-editable operators and the value of these data types needs to be set to null
+                    // to prevent type incompability
+                    switch (this._column.dataType) {
+                        case DataType.MULTI_SELECT_OPTIONSET:
+                        case DataType.OPTIONSET:
+                        case DataType.TWO_OPTIONS:
+                        case DataType.LOOKUP_SIMPLE:
+                        case DataType.LOOKUP_OWNER:
+                        case DataType.DATE_AND_TIME_DATE_AND_TIME:
+                        case DataType.DATE_AND_TIME_DATE_ONLY: {
+                            this._conditionExpression!.value = ""
+                            break;
+                        }
+                    }
+                }
+            },
+        }
+    }
+
+    public get value() {
+        return {
+            get: () => this._get('value') as any,
+            set: (value: any) => this._set("value", undefined, value),
+            isValid: async () => {
+                if(this._conditionUtils.operator(this.operator.get()).doesNotAllowValue) {
+                    return true;
+                }
+                const [result, errorMessage] = await new ColumnValidation(this._grid, this._column, true).validate(await this.value.get());
+                return result;
+            }
+        }
+    }
+    private _get(type: 'operator' | 'value'): DatasetConditionOperator | any {
+        if (type === 'operator') {
+            return this._conditionExpression.conditionOperator;
+        }
+        return this._conditionExpression.value;
+    }
+    private _set(type: 'operator' | 'value', conditionOperator?: DatasetConditionOperator, value?: any) {
+        this._isValid = true;
+        if (type === 'operator') {
+            this._conditionExpression.conditionOperator = conditionOperator as any;
+        }
+        else {
+            this._conditionExpression.value = value;
+        }
+        this._triggerRefreshCallbacks();
+    }
+
+    private async _attributeNameDecorator(conditionOperator: DatasetConditionOperator, attributeName: string, undecorate?: boolean) {
+        if (!this._conditionUtils.value(conditionOperator).isManuallyEditable) {
+            return attributeName;
+        }
+        switch (this._column.dataType) {
+            case DataType.OPTIONSET:
+            case DataType.TWO_OPTIONS:
+            case DataType.LOOKUP_OWNER:
+            case DataType.LOOKUP_SIMPLE: {
+                if (undecorate) {
+                    if (attributeName.endsWith('name')) {
+                        return attributeName.slice(0, -4);
+                    }
+                    return attributeName;
+                }
+                if (attributeName.endsWith('name')) {
+                    return attributeName;
+                }
+                return `${attributeName}name`
+            }
+/*             case DataType.LOOKUP_OWNER:
+            case DataType.LOOKUP_SIMPLE: {
+                if (undecorate) {
+                    return attributeName;
+                }
+                const metadata = await this._grid.metadata.get(this._column);
+                return `${this._column.attributeName}${metadata.PrimaryNameAttribute}`;
+            } */
+            default: {
+                return attributeName;
+            }
+        }
+    }
+    private _valueDecorator(conditionOperator: DatasetConditionOperator, value: any, undecorate?: boolean) {
+        switch (conditionOperator) {
+            case DatasetConditionOperator.BeginWith:
+            case DatasetConditionOperator.DoesNotBeginWith: {
+                if (undecorate) {
+                    return value.slice(0, -1);
+                }
+                return `${value}%`;
+            }
+            case DatasetConditionOperator.EndsWith:
+            case DatasetConditionOperator.DoesNotEndWith: {
+                if (undecorate) {
+                    return value.slice(1)
+                }
+                return `%${value}`;
+            }
+            case DatasetConditionOperator.Like:
+            case DatasetConditionOperator.NotLike: {
+                if (undecorate) {
+                    return value.slice(1, -1)
+                }
+                return `%${value}%`;
+            }
+            default: {
+                return value;
+            }
+        }
+    }
+
+    private _operatorDecorator(conditionOperator: DatasetConditionOperator, value: any, undecorate?: boolean): DatasetConditionOperator {
+        switch (this._column.dataType) {
+            case DataType.MULTI_SELECT_OPTIONSET:
+            case DataType.OPTIONSET:
+            case DataType.TWO_OPTIONS:
+            case DataType.LOOKUP_OWNER:
+            case DataType.LOOKUP_SIMPLE: {
+                //we need to switch the operators based on the number of selected options
+                if (typeof value !== 'string') {
+                    if(undecorate) {
+                        switch(conditionOperator) {
+                            case DatasetConditionOperator.In: {
+                                return DatasetConditionOperator.Equal
+                            }
+                            case DatasetConditionOperator.NotIn: {
+                                return DatasetConditionOperator.NotEqual;
+                            }
+                        }
+                    }
+                    switch (conditionOperator) {
+                        case DatasetConditionOperator.Equal: {
+                            return DatasetConditionOperator.In;
+                        }
+                        case DatasetConditionOperator.NotEqual: {
+                            return DatasetConditionOperator.NotIn;
+                        }
+                    }
+                }
+                else {
+                    switch (conditionOperator) {
+                        case DatasetConditionOperator.In: {
+                            return DatasetConditionOperator.Equal;
+                        }
+                        case DatasetConditionOperator.NotIn: {
+                            return DatasetConditionOperator.NotEqual;
+                        }
+                    }
+                }
+            }
+        }
+        return conditionOperator;
+    }
+
+    private _getDefault(): ComponentFramework.PropertyHelper.DataSetApi.ConditionExpression {
+        const cond: ComponentFramework.PropertyHelper.DataSetApi.ConditionExpression = {
+            attributeName: this._column.attributeName,
+            conditionOperator: DatasetConditionOperator.Equal,
+            entityAliasName: this._column.entityAliasName,
+            value: ""
+        }
+        switch (this._column.dataType) {
+            case DataType.DATE_AND_TIME_DATE_AND_TIME:
+            case DataType.DATE_AND_TIME_DATE_ONLY: {
+                cond.conditionOperator = DatasetConditionOperator.On;
+                break;
+            }
+            case DataType.IMAGE:
+            case DataType.FILE: {
+                cond.conditionOperator = DatasetConditionOperator.NotNull as any;
+                break;
+            }
+        }
+        return cond;
+    }
+    private get _filterExpression() {
+        return structuredClone(this._dataset.filtering.getFilter()) ?? {
+            conditions: [],
+            filterOperator: 0
+        }
+    }
+    private async  _getConditionFromFilterExpression(): Promise<[Map<string, ComponentFramework.PropertyHelper.DataSetApi.ConditionExpression>, string]> {
+        const map = new Map<string, ComponentFramework.PropertyHelper.DataSetApi.ConditionExpression>(this._filterExpression.conditions.map(x => [x.attributeName, x]));
+        for (const cond of map.values()) {
+            const conditionAttributeName = await this._attributeNameDecorator(cond.conditionOperator, cond.attributeName, true);
+            if(conditionAttributeName === this._column.attributeName) {
+                return [map, cond.attributeName]
+            }
+        }
+        return [map, ""];
+    }
+}

package/src/components/Grid/filtering/model/Filtering.ts

@@ -0,0 +1,78 @@
+import { IGridColumn } from "../../core/interfaces/IGridColumn";
+import { GridDependency } from "../../core/model/GridDependency";
+import { Condition } from "./Condition";
+
+export class Filtering extends GridDependency {
+    private _conditions: Map<string, Condition> = new Map();
+
+    public async save(): Promise<boolean> {
+        const filterExpression = this._filterExpression;
+        for (const condition of this._conditions.values()) {
+            if(!condition.value.isValid()) {
+                return false;
+            }
+            const expression = await condition.getExpression();
+            if (condition.isAppliedToDataset || condition.isRemoved) {
+                filterExpression.conditions = this._filterExpression.conditions.filter(cond => this._getColumnKeyFromCondition(cond) !== condition.column.key);
+            }
+            if (!condition.isRemoved) {
+                filterExpression.conditions.push(expression)
+            }
+        }
+        this.clear();
+        this._dataset.filtering.setFilter(filterExpression);
+        this._dataset.refresh();
+        return true;
+    }
+
+    public clear() {
+        this._conditions.clear();
+    }
+
+    public async condition(column: IGridColumn): Promise<Condition> {
+        const columnKey = column.key
+        if (!this._conditions.get(columnKey)) {
+            this._conditions.set(columnKey, new Condition(this._grid, column))
+        }
+        const cond = new Proxy(this._conditions.get(columnKey)!, {
+            get: (target, prop) => {
+                if (prop === 'save') {
+                    return async () => {
+                        const saveResult = await target.save();
+                        if (saveResult) {
+                            this._conditions.delete(target.column.key);
+                            this._dataset.refresh();
+                        }
+                        return saveResult;
+                    };
+                }
+                if(prop === 'clear') {
+                    this._conditions.delete(target.column.key);
+                }
+                //@ts-ignore
+                if (typeof target[prop] === 'function') {
+                    //@ts-ignore
+                    return target[prop].bind(target);
+                }
+                //@ts-ignore
+                return target[prop];
+            },
+        });
+        await cond.init();
+        return cond;
+    }
+
+    private get _filterExpression() {
+        return structuredClone(this._grid.dataset.filtering.getFilter()) ?? {
+            conditions: [],
+            filterOperator: 0
+        }
+    }
+
+    private _getColumnKeyFromCondition(condition: ComponentFramework.PropertyHelper.DataSetApi.ConditionExpression) {
+        if (condition.entityAliasName) {
+            return `${condition.entityAliasName}.${condition.attributeName}`;
+        }
+        return condition.attributeName;
+    }
+}

package/src/components/Grid/filtering/utils/FilteringUtilts.ts

@@ -0,0 +1,190 @@
+import { DatasetConditionOperator } from "../../core/enums/ConditionOperator";
+import { OPERATORS } from "../constants";
+
+
+export class FilteringUtils {
+    public static condition() {
+        return {
+            operator: (conditionOperator?: DatasetConditionOperator) => {
+                return {
+                    textFieldOperators: (() => {
+                        return OPERATORS.filter(operator => {
+                            switch (operator.type) {
+                                case DatasetConditionOperator.Equal:
+                                case DatasetConditionOperator.NotEqual:
+                                case DatasetConditionOperator.Like:
+                                case DatasetConditionOperator.NotLike:
+                                case DatasetConditionOperator.BeginWith:
+                                case DatasetConditionOperator.DoesNotBeginWith:
+                                case DatasetConditionOperator.EndsWith:
+                                case DatasetConditionOperator.DoesNotEndWith:
+                                case DatasetConditionOperator.NotNull:
+                                case DatasetConditionOperator.Null: {
+                                    return true;
+                                }
+                                default: {
+                                    return false;
+                                }
+                            }
+                        });
+                    })(),
+                    numberOperators: (() => {
+                        return OPERATORS.filter(operator => {
+                            switch (operator.type) {
+                                case DatasetConditionOperator.Equal:
+                                case DatasetConditionOperator.NotEqual:
+                                case DatasetConditionOperator.GreaterThan:
+                                case DatasetConditionOperator.GreaterEqual:
+                                case DatasetConditionOperator.LessThan:
+                                case DatasetConditionOperator.LessEqual:
+                                case DatasetConditionOperator.Null:
+                                    return true;
+                                default:
+                                    return false;
+                            }
+                        });
+                    })(),
+                    dateOperators: (() => {
+                        return OPERATORS.filter(operator => {
+                            switch (operator.type) {
+                                case DatasetConditionOperator.On:
+                                case DatasetConditionOperator.OnOrAfter:
+                                case DatasetConditionOperator.OnOrBefore:
+                                case DatasetConditionOperator.Today:
+                                case DatasetConditionOperator.Yesterday:
+                                case DatasetConditionOperator.Tomorrow:
+                                case DatasetConditionOperator.ThisWeek:
+                                case DatasetConditionOperator.ThisMonth:
+                                case DatasetConditionOperator.ThisYear:
+                                case DatasetConditionOperator.Next7Days:
+                                case DatasetConditionOperator.NextXDays:
+                                case DatasetConditionOperator.NextXMonths:
+                                case DatasetConditionOperator.LastWeek:
+                                case DatasetConditionOperator.Last7Days:
+                                case DatasetConditionOperator.LastMonth:
+                                case DatasetConditionOperator.LastYear:
+                                case DatasetConditionOperator.LastXDays:
+                                case DatasetConditionOperator.LastXMonths:
+                                case DatasetConditionOperator.Null:
+                                    return true;
+                                default:
+                                    return false;
+                            }
+                        });
+                    })(),
+                    multipleOptionSetOperators: (() => {
+                        return OPERATORS.filter(operator => {
+                            switch (operator.type) {
+                                case DatasetConditionOperator.Equal:
+                                case DatasetConditionOperator.NotEqual:
+                                case DatasetConditionOperator.ContainValues:
+                                case DatasetConditionOperator.DoesNotContainValues:
+                                case DatasetConditionOperator.Null:
+                                case DatasetConditionOperator.NotNull:
+                                    return true;
+                                default:
+                                    return false;
+                            }
+                        });
+                    })(),
+                    fileOperators: (() => {
+                        return OPERATORS.filter(operator => {
+                            switch (operator.type) {
+                                case DatasetConditionOperator.Null:
+                                case DatasetConditionOperator.NotNull:
+                                    return true;
+                                default:
+                                    return false;
+                            }
+                        })
+                    })(),
+                    allowsOnlyFreeText: (() => {
+                        switch (conditionOperator) {
+                            case DatasetConditionOperator.BeginWith:
+                            case DatasetConditionOperator.DoesNotBeginWith:
+                            case DatasetConditionOperator.EndsWith:
+                            case DatasetConditionOperator.DoesNotEndWith:
+                            case DatasetConditionOperator.Like:
+                            case DatasetConditionOperator.NotLike: {
+                                return true;
+                            }
+                        }
+                        return false;
+                    })(),
+                    allowsOnlyNumber: (() => {
+                        switch (conditionOperator) {
+                            case DatasetConditionOperator.LastXDays:
+                            case DatasetConditionOperator.LastXMonths:
+                            case DatasetConditionOperator.NextXMonths:
+                            case DatasetConditionOperator.NextXDays: {
+                                return true;
+                            }
+                        }
+                        return false;
+                    })(),
+                    doesNotAllowValue: (() => {
+                        switch (conditionOperator) {
+                            case DatasetConditionOperator.Null:
+                            case DatasetConditionOperator.NotNull:
+                            case DatasetConditionOperator.Today:
+                            case DatasetConditionOperator.Yesterday:
+                            case DatasetConditionOperator.Tomorrow:
+                            case DatasetConditionOperator.ThisWeek:
+                            case DatasetConditionOperator.ThisMonth:
+                            case DatasetConditionOperator.ThisYear:
+                            case DatasetConditionOperator.LastWeek:
+                            case DatasetConditionOperator.Last7Days:
+                            case DatasetConditionOperator.LastMonth:
+                            case DatasetConditionOperator.LastYear:
+                                return true;
+                            default:
+                                return false;
+                        }
+                    })()
+                }
+            },
+            value: (conditionOperator: DatasetConditionOperator) => {
+                return {
+                    isEditable: (() => {
+                        switch (conditionOperator) {
+                            case DatasetConditionOperator.Null:
+                            case DatasetConditionOperator.NotNull:
+                            case DatasetConditionOperator.Today:
+                            case DatasetConditionOperator.Yesterday:
+                            case DatasetConditionOperator.Tomorrow:
+                            case DatasetConditionOperator.ThisMonth:
+                            case DatasetConditionOperator.ThisWeek:
+                            case DatasetConditionOperator.InFiscalPeriodAndYear:
+                            case DatasetConditionOperator.Next7Days:
+                            case DatasetConditionOperator.LastWeek:
+                            case DatasetConditionOperator.Last7Days:
+                            case DatasetConditionOperator.LastMonth:
+                            case DatasetConditionOperator.LastYear: {
+                                return false;
+                            }
+                        }
+                        return true;
+                    })(),
+                    isManuallyEditable: (() => {
+                        switch (conditionOperator) {
+                            case DatasetConditionOperator.Like:
+                            case DatasetConditionOperator.NotLike:
+                            case DatasetConditionOperator.BeginWith:
+                            case DatasetConditionOperator.DoesNotBeginWith:
+                            case DatasetConditionOperator.EndsWith:
+                            case DatasetConditionOperator.DoesNotEndWith:
+                            case DatasetConditionOperator.LastXDays:
+                            case DatasetConditionOperator.LastXMonths:
+                            case DatasetConditionOperator.NextXMonths:
+                            case DatasetConditionOperator.NextXDays:
+                                {
+                                    return true;
+                                }
+                        }
+                        return false;
+                    })()
+                }
+            }
+        }
+    }
+}

package/src/components/Grid/interfaces.ts

@@ -0,0 +1,109 @@
+import { IDatasetProperty, IParameters, IStringProperty, ITwoOptionsProperty } from "../../interfaces";
+import { IComponent, IOutputs, ITranslations } from "../../interfaces/context";
+
+export interface IGrid extends IComponent<IGridParameters, IGridOutputs, IGridTranslations> {
+
+}
+
+export interface IEntityColumn extends ComponentFramework.PropertyHelper.DataSetApi.Column {
+    isResizable?: boolean;
+    isFilterable?: boolean;
+    isEditable?: boolean;
+    isRequired?: boolean;
+}
+export interface IEntityRecord extends ComponentFramework.PropertyHelper.DataSetApi.EntityRecord {
+    setValue: (columnName: string, value: any) => void;
+    save: () => Promise<void>;
+}
+
+export interface IGridParameters extends IParameters {
+    EnableEditing?: Omit<ITwoOptionsProperty, 'attributes'>;
+    EnablePagination?: Omit<ITwoOptionsProperty, 'attributes'>;
+    EnableFiltering?: Omit<ITwoOptionsProperty, 'attributes'>;
+    EnableSorting?: Omit<ITwoOptionsProperty, 'attributes'>;
+    EnableNavigation?: Omit<ITwoOptionsProperty, 'attributes'>;
+    IsNested?: Omit<ITwoOptionsProperty, 'attributes'>;
+    SelectableRows?: ComponentFramework.PropertyTypes.EnumProperty<"none" | "single" | "multiple">;
+    Grid: IDatasetProperty;
+}
+
+export interface IGridOutputs extends IOutputs {
+
+}
+export interface IGridTranslations extends ITranslations {
+    "condition-none": { [LCID: number]: string };
+    "condition-equal": { [LCID: number]: string };
+    "condition-notequal": { [LCID: number]: string };
+    "condition-greaterthan": { [LCID: number]: string };
+    "condition-lessthan": { [LCID: number]: string };
+    "condition-greaterequal": { [LCID: number]: string };
+    "condition-lessequal": { [LCID: number]: string };
+    "condition-like": { [LCID: number]: string };
+    "condition-notlike": { [LCID: number]: string };
+    "condition-null": { [LCID: number]: string };
+    "condition-notnull": { [LCID: number]: string };
+    "condition-beginwith": { [LCID: number]: string };
+    "condition-doesnotbeginwith": { [LCID: number]: string };
+    "condition-endswith": { [LCID: number]: string };
+    "condition-doesnotendwith": { [LCID: number]: string };
+    "condition-yesterday": { [LCID: number]: string };
+    "condition-today": { [LCID: number]: string };
+    "condition-tomorrow": { [LCID: number]: string };
+    "condition-last7days": { [LCID: number]: string };
+    "condition-next7days": { [LCID: number]: string };
+    "condition-lastweek": { [LCID: number]: string };
+    "condition-thisweek": { [LCID: number]: string };
+    "condition-lastmonth": { [LCID: number]: string };
+    "condition-thismonth": { [LCID: number]: string };
+    "condition-on": { [LCID: number]: string };
+    "condition-onorbefore": { [LCID: number]: string };
+    "condition-onorafter": { [LCID: number]: string };
+    "condition-lastyear": { [LCID: number]: string };
+    "condition-thisyear": { [LCID: number]: string };
+    "condition-lastxdays": { [LCID: number]: string };
+    "condition-nextxdays": { [LCID: number]: string };
+    "condition-lastxmonths": { [LCID: number]: string };
+    "condition-nextxmonths": { [LCID: number]: string };
+    "condition-contains": { [LCID: number]: string };
+    "condition-infiscalperiodandyear": { [LCID: number]: string };
+    "condition-above": { [LCID: number]: string };
+    "condition-under": { [LCID: number]: string };
+    "condition-notunder": { [LCID: number]: string };
+    "condition-aboveorequal": { [LCID: number]: string };
+    "condition-underorequal": { [LCID: number]: string };
+    "condition-containvalues": { [LCID: number]: string };
+    "condition-doesnotcontainvalues": { [LCID: number]: string };
+    "filtermenu-filterby": { [LCID: number]: string };
+    "filtermenu-applybutton": { [LCID: number]: string };
+    "filtermenu-clearbutton": { [LCID: number]: string };
+    "filtersortmenu-sorttext-a-z": { [LCID: number]: string };
+    "filtersortmenu-sorttext-z-a": { [LCID: number]: string };
+    "filtersortmenu-sortdate-a-z": { [LCID: number]: string };
+    "filtersortmenu-sortdate-z-a": { [LCID: number]: string };
+    "filtersortmenu-sortnumber-a-z": { [LCID: number]: string };
+    "filtersortmenu-sortnumber-z-a": { [LCID: number]: string };
+    "filtersortmenu-sorttwooption-a-z": { [LCID: number]: string };
+    "filtersortmenu-sorttwooption-z-a": { [LCID: number]: string };
+    "filtersortmenu-sorttwooption-joint": { [LCID: number]: string };
+    "filtersortmenu-filterby": { [LCID: number]: string };
+    "filtersortmenu-clearfilter": { [LCID: number]: string };
+    "paging-pages": { [LCID: number]: string };
+    "paging-of": { [LCID: number]: string };
+    "paging-firstpage": { [LCID: number]: string };
+    "paging-previouspage": { [LCID: number]: string };
+    "paging-page": { [LCID: number]: string };
+    "paging-nextpage": { [LCID: number]: string };
+    "paging-lastpage": { [LCID: number]: string };
+    "norecordsfound": { [LCID: number]: string };
+    "saving-changenotification": { [LCID: number]: string };
+    "saving-save": { [LCID: number]: string };
+    "saving-saving": { [LCID: number]: string };
+    "saving-changepreview-title": { [LCID: number]: string };
+    "saving-validation-error": { [LCID: number]: string };
+    "validation-input-value": { [LCID: number]: string };
+    "validation-email": { [LCID: number]: string };
+    "validation-url": { [LCID: number]: string };
+    "validation-date": { [LCID: number]: string };
+    "validation-number": { [LCID: number]: string };
+    "no-name": { [LCID: number]: string };
+}