@creatio/base 0.814.0 → 0.820.0

package/esm2022/lib/public/esq/data-model/filters/between-filter.mjs

@@ -0,0 +1,58 @@
+import { ɵSingleFilter } from './single-filter';
+import { ɵComparisonType, ɵFilterType } from '../enums';
+/**
+ * @public
+ * @description Filter class of the "Between" type.
+ * @extends {ɵSingleFilter}
+ */
+export class ɵBetweenFilter extends ɵSingleFilter {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static { this._instanceOfKey = 'devkit_BetweenFilter'; }
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵSingleFilter._instanceOfKeys, this._instanceOfKey];
+    }
+    constructor(leftExpression, rightLessExpression, rightGreaterExpression) {
+        super(ɵFilterType.Between, ɵComparisonType.Between, leftExpression);
+        this.rightLessExpression = rightLessExpression?.clone();
+        this.rightGreaterExpression = rightGreaterExpression?.clone();
+    }
+    /**
+     * Parses filter from json.
+     * @public
+     */
+    static fromJson(dto, filterParser, expressionParser) {
+        const filter = new ɵBetweenFilter(expressionParser.fromJson(dto['leftExpression'], filterParser), expressionParser.fromJson(dto['rightLessExpression'], filterParser), expressionParser.fromJson(dto['rightGreaterExpression'], filterParser));
+        return filter;
+    }
+    clone() {
+        const filter = new ɵBetweenFilter(this.leftExpression, this.rightLessExpression, this.rightGreaterExpression);
+        filter.isEnabled = this.isEnabled;
+        filter.trimDateTimeParameterToDate = this.trimDateTimeParameterToDate;
+        return filter;
+    }
+    toJson() {
+        return {
+            ...super.toJson(),
+            rightLessExpression: this.serializeItem(this.rightLessExpression),
+            rightGreaterExpression: this.serializeItem(this.rightGreaterExpression),
+        };
+    }
+    /**
+     * @internal
+     */
+    _getUsedColumns() {
+        return [
+            ...super._getUsedColumns(),
+            ...this.rightLessExpression._getUsedColumns(),
+            ...this.rightGreaterExpression._getUsedColumns(),
+        ];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/public/esq/data-model/filters/compare-filter.mjs

@@ -0,0 +1,52 @@
+import { ɵSingleFilter } from './single-filter';
+import { ɵFilterType } from '../enums';
+/**
+ * @public
+ * @description Comparison filter class.
+ * @extends {ɵSingleFilter}
+ */
+export class ɵCompareFilter extends ɵSingleFilter {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static { this._instanceOfKey = 'devkit_CompareFilter'; }
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵSingleFilter._instanceOfKeys, this._instanceOfKey];
+    }
+    constructor(comparisonType, leftExpression, rightExpression) {
+        super(ɵFilterType.Compare, comparisonType, leftExpression);
+        this.rightExpression = rightExpression?.clone();
+    }
+    /**
+     * Parses filter from json.
+     * @public
+     */
+    static fromJson(dto, filterParser, expressionParser) {
+        const filter = new ɵCompareFilter(dto['comparisonType'], expressionParser.fromJson(dto['leftExpression'], filterParser), expressionParser.fromJson(dto['rightExpression'], filterParser));
+        return filter;
+    }
+    clone() {
+        const filter = new ɵCompareFilter(this.comparisonType, this.leftExpression, this.rightExpression);
+        filter.isEnabled = this.isEnabled;
+        filter.trimDateTimeParameterToDate = this.trimDateTimeParameterToDate;
+        return filter;
+    }
+    toJson() {
+        return {
+            ...super.toJson(),
+            rightExpression: this.serializeItem(this.rightExpression),
+        };
+    }
+    /**
+     * @internal
+     */
+    _getUsedColumns() {
+        return [...super._getUsedColumns(), ...this.rightExpression._getUsedColumns()];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/public/esq/data-model/filters/exists-filter.mjs

@@ -0,0 +1,64 @@
+import { ɵSingleFilter } from './single-filter';
+import { ɵComparisonType, ɵFilterType } from '../enums';
+/**
+ * @public
+ * @description The comparison filter class [Exists according to the specified condition].
+ * @extends {ɵSingleFilter}
+ */
+export class ɵExistsFilter extends ɵSingleFilter {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static { this._instanceOfKey = 'devkit_ExistsFilter'; }
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵSingleFilter._instanceOfKeys, this._instanceOfKey];
+    }
+    constructor(leftExpression, subFilters, comparisonType = ɵComparisonType.Exists, isAggregative = true) {
+        super(ɵFilterType.Exists, comparisonType, leftExpression);
+        this.subFilters = subFilters?.clone();
+        this.isAggregative = isAggregative;
+    }
+    /**
+     * Parses filter from json.
+     * @public
+     */
+    static fromJson(dto, filterParser, expressionParser) {
+        const leftExpression = expressionParser.fromJson(dto['leftExpression'], filterParser);
+        const subFiltersDto = dto['subFilters'];
+        let subFilters;
+        if (subFiltersDto) {
+            subFilters = filterParser.fromJson(dto['subFilters']);
+        }
+        return new ɵExistsFilter(leftExpression, subFilters, dto['comparisonType'], dto['isAggregative']);
+    }
+    /**
+     * @public
+     * @description Clones instance.
+     */
+    clone() {
+        const filter = new ɵExistsFilter(this.leftExpression, this.subFilters, this.comparisonType, this.isAggregative);
+        filter.isEnabled = this.isEnabled;
+        filter.trimDateTimeParameterToDate = this.trimDateTimeParameterToDate;
+        return filter;
+    }
+    /** {@inheritDoc ɵSerializable.toJson} */
+    toJson() {
+        const result = super.toJson();
+        if (this.subFilters) {
+            result['subFilters'] = this.serializeItem(this.subFilters);
+        }
+        return result;
+    }
+    /**
+     * @internal
+     */
+    _getUsedColumns() {
+        return [...super._getUsedColumns(), ...(this.subFilters?._getUsedColumns() ?? [])];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/public/esq/data-model/filters/filter-group.mjs

@@ -0,0 +1,247 @@
+import { __decorate, __metadata } from "tslib";
+import { Exclude, Expose } from 'class-transformer';
+import { ɵBaseFilter } from './base-filter';
+import { ɵBetweenFilter } from './between-filter';
+import { ɵCompareFilter } from './compare-filter';
+import { ɵExistsFilter } from './exists-filter';
+import { ɵInFilter } from './in-filter';
+import { ɵIsNullFilter } from './isnull-filter';
+import { ɵgenerateGuid } from '../../../../public/types';
+import { ɵValidationUtilities } from '../../../exceptions';
+import { ɵComparisonType } from '../enums/comparison-type.enum';
+import { ɵFilterType } from '../enums/filter-type.enum';
+import { ɵLogicalOperatorType } from '../enums/logical-operator-type.enum';
+import { ɵQueryMacrosType } from '../enums/query-macros-type.enum';
+import { ɵColumnExpression } from '../expressions/columns/column-expression';
+import { ɵMacrosFunctionExpression } from '../expressions/functions/macros-function-expression';
+import { ɵParameterExpression } from '../expressions/parameters/parameter-expression';
+/**
+ * @public
+ * @description Group of filters. Groups of filters can be nested into each other,
+ * i.e. The collection itself can be an element of another collection.
+ * @extends {ɵBaseFilter}
+ */
+export class ɵFilterGroup extends ɵBaseFilter {
+    /**
+     * @internal
+     * @dontChange
+     */
+    static { this._instanceOfKey = 'devkit_FilterGroup'; }
+    /**
+     * @internal
+     * @dontChange
+     */
+    static get _instanceOfKeys() {
+        return [...ɵBaseFilter._instanceOfKeys, this._instanceOfKey];
+    }
+    /**
+     * @public
+     * @description Return collecion of deserialized filters.
+     */
+    get items() {
+        const result = {};
+        this.filters.forEach((filter, key) => {
+            result[key] = this.serializeItem(filter);
+        });
+        return result;
+    }
+    constructor(logicalOperation = ɵLogicalOperatorType.And, rootSchemaName) {
+        super(ɵFilterType.FilterGroup);
+        /**
+         * @public
+         * @description Collection of child filters.
+         */
+        this.filters = new Map();
+        this.logicalOperation = logicalOperation;
+        this.rootSchemaName = rootSchemaName;
+    }
+    /**
+     * @public
+     * @description Parses filter group from json.
+     */
+    static fromJson(dto, filterParser) {
+        const logicalOperation = dto['logicalOperation'];
+        const group = new ɵFilterGroup(logicalOperation || ɵLogicalOperatorType.And, dto['rootSchemaName']);
+        Object.entries(dto['items']).forEach(([key, filterDTO]) => {
+            group.add(filterParser.fromJson(filterDTO), key);
+        });
+        return group;
+    }
+    /** {@inheritDoc ɵSerializable.toJson} */
+    toJson() {
+        const result = {};
+        result['filterType'] = this.filterType;
+        result['isEnabled'] = this.isEnabled;
+        result['logicalOperation'] = this.logicalOperation;
+        result['trimDateTimeParameterToDate'] = this.trimDateTimeParameterToDate;
+        result['items'] = this.items;
+        if (this.rootSchemaName) {
+            result['rootSchemaName'] = this.rootSchemaName;
+        }
+        return result;
+    }
+    _createParameterValueExpressions(values) {
+        return values.map((value) => new ɵParameterExpression({
+            value: value,
+        }));
+    }
+    /**
+     * @public
+     * @description Returns filter item by index.
+     * @param index Item index.
+     * @returns Filter.
+     */
+    getItemByIndex(index) {
+        return this.items[Object.keys(this.items)[index]];
+    }
+    /**
+     * @public
+     * @description Creates and adds compare filter by value.
+     * @param comparisonType Comparison type.
+     * @param columnPath Column path.
+     * @param parameterValue Parameter value.
+     * @param filterKey Filter key.
+     */
+    addSchemaColumnFilterWithParameter(comparisonType, columnPath, parameterValue, filterKey) {
+        const leftExpression = new ɵColumnExpression({ columnPath });
+        const rightExpression = new ɵParameterExpression({ value: parameterValue });
+        const filter = new ɵCompareFilter(comparisonType, leftExpression, rightExpression);
+        this.add(filter, filterKey);
+    }
+    /**
+     * @public
+     * @description Creates and adds in filter by values.
+     * @param comparisonType Comparison type.
+     * @param columnPath Column path.
+     * @param parameterValues Parameter values.
+     * @param filterKey Filter key.
+     */
+    addSchemaColumnInFilterWithParameters(comparisonType, columnPath, parameterValues, filterKey) {
+        const leftExpression = new ɵColumnExpression({ columnPath });
+        const expressions = this._createParameterValueExpressions(parameterValues);
+        const filter = new ɵInFilter(comparisonType, leftExpression, expressions);
+        this.add(filter, filterKey);
+    }
+    /**
+     * @public
+     * @description Creates and adds in filter for primary column.
+     * @param primaryColumnValues Primary column values.
+     * @param filterKey Filter key.
+     */
+    addPrimarySchemaColumnInFilter(primaryColumnValues, filterKey) {
+        const leftExpression = new ɵMacrosFunctionExpression({ macrosType: ɵQueryMacrosType.PrimaryColumn });
+        const expressions = this._createParameterValueExpressions(primaryColumnValues);
+        const filter = new ɵInFilter(ɵComparisonType.Equal, leftExpression, expressions);
+        this.add(filter, filterKey);
+    }
+    /**
+     * @public
+     * @description Creates and adds null filter.
+     * @param columnPath Path of column.
+     * @param filterKey Filter key.
+     */
+    addSchemaColumnIsNullFilter(columnPath, filterKey) {
+        const leftExpression = new ɵColumnExpression({ columnPath });
+        const filter = new ɵIsNullFilter(ɵComparisonType.Is_null, leftExpression);
+        this.add(filter, filterKey);
+    }
+    /**
+     * @public
+     * @description Creates and adds not null filter.
+     * @param columnPath Column path.
+     * @param filterKey Filter key.
+     */
+    addSchemaColumnIsNotNullFilter(columnPath, filterKey) {
+        const leftExpression = new ɵColumnExpression({ columnPath });
+        const filter = new ɵIsNullFilter(ɵComparisonType.Is_not_null, leftExpression);
+        this.add(filter, filterKey);
+    }
+    /**
+     * @public
+     * @description Creates and adds filter between less value and greater value.
+     * @param columnPath Column path.
+     * @param lessParamValue Less parameter value.
+     * @param greaterParamValue Greater parameter value.
+     * @param filterKey Filter key.
+     */
+    addSchemaColumnBetweenFilterWithParameters(columnPath, lessParamValue, greaterParamValue, filterKey) {
+        const leftExpression = new ɵColumnExpression({ columnPath });
+        const rightLessExpression = new ɵParameterExpression({ value: lessParamValue });
+        const rightGreaterExpression = new ɵParameterExpression({ value: greaterParamValue });
+        const filter = new ɵBetweenFilter(leftExpression, rightLessExpression, rightGreaterExpression);
+        this.add(filter, filterKey);
+    }
+    /**
+     * @public
+     * @description Creates and adds exists filter.
+     * @param columnPath Column path.
+     * @param subFilters Filters for exists expression.
+     * @param filterKey Filter key.
+     */
+    addExistsFilter(columnPath, subFilters, filterKey) {
+        const leftExpression = new ɵColumnExpression({ columnPath });
+        const filter = new ɵExistsFilter(leftExpression, subFilters);
+        this.add(filter, filterKey);
+    }
+    /**
+     * @public
+     * @description Creates and adds not exists filter.
+     * @param columnPath Column path.
+     * @param subFilters Filters for exist expression.
+     * @param filterKey Filter key.
+     */
+    addNotExistsFilter(columnPath, subFilters, filterKey) {
+        const leftExpression = new ɵColumnExpression({ columnPath });
+        const filter = new ɵExistsFilter(leftExpression, subFilters, ɵComparisonType.Not_exists);
+        this.add(filter, filterKey);
+    }
+    /**
+     * @public
+     * @description Adds filter.
+     * @param filter Instance of filter.
+     * @param filterKey Filter key.
+     */
+    add(filter, filterKey) {
+        ɵValidationUtilities.checkArgumentEmpty('filter', filter);
+        const key = filterKey || ɵgenerateGuid();
+        this.filters.set(key, filter);
+    }
+    /**
+     * @public
+     * @description Clones instance.
+     */
+    clone() {
+        const filterGroup = new ɵFilterGroup(this.logicalOperation, this.rootSchemaName);
+        this.filters.forEach((filter, filterKey) => {
+            filterGroup.filters.set(filterKey, filter.clone());
+        });
+        filterGroup.isEnabled = this.isEnabled;
+        filterGroup.trimDateTimeParameterToDate = this.trimDateTimeParameterToDate;
+        return filterGroup;
+    }
+    /**
+     * @internal
+     */
+    _getUsedColumns() {
+        const result = [];
+        this.filters.forEach((filter) => {
+            let filterUsedColumns = filter._getUsedColumns ? filter._getUsedColumns() : [];
+            filterUsedColumns = filterUsedColumns.map((usedColumn) => ({
+                path: usedColumn.path,
+                schemaName: usedColumn.schemaName ?? this.rootSchemaName,
+            }));
+            result.push(...filterUsedColumns);
+        });
+        return result;
+    }
+}
+__decorate([
+    Exclude(),
+    __metadata("design:type", Object)
+], ɵFilterGroup.prototype, "filters", void 0);
+__decorate([
+    Expose(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], ɵFilterGroup.prototype, "items", null);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter-group.js","sourceRoot":"","sources":["../../../../../../../../../../libs/devkit/base/src/lib/public/esq/data-model/filters/filter-group.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAsB,aAAa,EAAsB,MAAM,0BAA0B,CAAC;AACjG,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAC3E,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAC;AAC7E,OAAO,EAAE,yBAAyB,EAAE,MAAM,qDAAqD,CAAC;AAChG,OAAO,EAAE,oBAAoB,EAAE,MAAM,gDAAgD,CAAC;AAGtF;;;;;GAKG;AACH,MAAM,OAAO,YAAa,SAAQ,WAAW;IAC5C;;;OAGG;aACuB,mBAAc,GAAW,oBAAoB,AAA/B,CAAgC;IAExE;;;OAGG;IACO,MAAM,KAAK,eAAe;QACnC,OAAO,CAAC,GAAG,WAAW,CAAC,eAAe,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;IAC9D,CAAC;IASD;;;OAGG;IACH,IACW,KAAK;QACf,MAAM,MAAM,GAAG,EAAE,CAAC;QAClB,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE;YACpC,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;QAC1C,CAAC,CAAC,CAAC;QACH,OAAO,MAAM,CAAC;IACf,CAAC;IAWD,YAAY,gBAAgB,GAAG,oBAAoB,CAAC,GAAG,EAAE,cAAuB;QAC/E,KAAK,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;QA9BhC;;;WAGG;QAEI,YAAO,GAAG,IAAI,GAAG,EAAsB,CAAC;QA0B9C,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAC;QACzC,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;IACtC,CAAC;IAED;;;OAGG;IACI,MAAM,CAAC,QAAQ,CAAqC,GAAgB,EAAE,YAAe;QAC3F,MAAM,gBAAgB,GAAG,GAAG,CAAC,kBAAkB,CAAyB,CAAC;QACzE,MAAM,KAAK,GAAG,IAAI,YAAY,CAAC,gBAAgB,IAAI,oBAAoB,CAAC,GAAG,EAAE,GAAG,CAAC,gBAAgB,CAAW,CAAC,CAAC;QAC9G,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAgB,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,SAAS,CAAC,EAAE,EAAE;YACxE,KAAK,CAAC,GAAG,CAAC,YAAY,CAAC,QAAQ,CAAC,SAAwB,CAAgB,EAAE,GAAG,CAAC,CAAC;QAChF,CAAC,CAAC,CAAC;QACH,OAAO,KAAK,CAAC;IACd,CAAC;IAED,yCAAyC;IAClC,MAAM;QACZ,MAAM,MAAM,GAAG,EAAE,CAAC;QAClB,MAAM,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC;QACvC,MAAM,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC;QACrC,MAAM,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC;QACnD,MAAM,CAAC,6BAA6B,CAAC,GAAG,IAAI,CAAC,2BAA2B,CAAC;QACzE,MAAM,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC;QAC7B,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACzB,MAAM,CAAC,gBAAgB,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC;QAChD,CAAC;QACD,OAAO,MAAM,CAAC;IACf,CAAC;IAEO,gCAAgC,CAAC,MAA4B;QACpE,OAAO,MAAM,CAAC,GAAG,CAChB,CAAC,KAAK,EAAE,EAAE,CACT,IAAI,oBAAoB,CAAC;YACxB,KAAK,EAAE,KAAK;SACZ,CAAC,CACH,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACI,cAAc,CAAC,KAAa;QAClC,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;IACnD,CAAC;IAED;;;;;;;OAOG;IACI,kCAAkC,CACxC,cAA+B,EAC/B,UAAkB,EAClB,cAAkC,EAClC,SAAkB;QAElB,MAAM,cAAc,GAAG,IAAI,iBAAiB,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;QAC7D,MAAM,eAAe,GAAG,IAAI,oBAAoB,CAAC,EAAE,KAAK,EAAE,cAAc,EAAE,CAAC,CAAC;QAC5E,MAAM,MAAM,GAAG,IAAI,cAAc,CAAC,cAAc,EAAE,cAAc,EAAE,eAAe,CAAC,CAAC;QACnF,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC7B,CAAC;IAED;;;;;;;OAOG;IACI,qCAAqC,CAC3C,cAA+B,EAC/B,UAAkB,EAClB,eAAqC,EACrC,SAAkB;QAElB,MAAM,cAAc,GAAG,IAAI,iBAAiB,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;QAC7D,MAAM,WAAW,GAAG,IAAI,CAAC,gCAAgC,CAAC,eAAe,CAAC,CAAC;QAC3E,MAAM,MAAM,GAAG,IAAI,SAAS,CAAC,cAAc,EAAE,cAAc,EAAE,WAAW,CAAC,CAAC;QAC1E,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC7B,CAAC;IAED;;;;;OAKG;IACI,8BAA8B,CAAC,mBAAyC,EAAE,SAAkB;QAClG,MAAM,cAAc,GAAG,IAAI,yBAAyB,CAAC,EAAE,UAAU,EAAE,gBAAgB,CAAC,aAAa,EAAE,CAAC,CAAC;QACrG,MAAM,WAAW,GAAG,IAAI,CAAC,gCAAgC,CAAC,mBAAmB,CAAC,CAAC;QAC/E,MAAM,MAAM,GAAG,IAAI,SAAS,CAAC,eAAe,CAAC,KAAK,EAAE,cAAc,EAAE,WAAW,CAAC,CAAC;QACjF,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC7B,CAAC;IAED;;;;;OAKG;IACI,2BAA2B,CAAC,UAAkB,EAAE,SAAkB;QACxE,MAAM,cAAc,GAAG,IAAI,iBAAiB,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;QAC7D,MAAM,MAAM,GAAG,IAAI,aAAa,CAAC,eAAe,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;QAC1E,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC7B,CAAC;IAED;;;;;OAKG;IACI,8BAA8B,CAAC,UAAkB,EAAE,SAAkB;QAC3E,MAAM,cAAc,GAAG,IAAI,iBAAiB,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;QAC7D,MAAM,MAAM,GAAG,IAAI,aAAa,CAAC,eAAe,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;QAC9E,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC7B,CAAC;IAED;;;;;;;OAOG;IACI,0CAA0C,CAChD,UAAkB,EAClB,cAA6B,EAC7B,iBAAgC,EAChC,SAAkB;QAElB,MAAM,cAAc,GAAG,IAAI,iBAAiB,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;QAC7D,MAAM,mBAAmB,GAAG,IAAI,oBAAoB,CAAC,EAAE,KAAK,EAAE,cAAc,EAAE,CAAC,CAAC;QAChF,MAAM,sBAAsB,GAAG,IAAI,oBAAoB,CAAC,EAAE,KAAK,EAAE,iBAAiB,EAAE,CAAC,CAAC;QACtF,MAAM,MAAM,GAAG,IAAI,cAAc,CAAC,cAAc,EAAE,mBAAmB,EAAE,sBAAsB,CAAC,CAAC;QAC/F,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC7B,CAAC;IAED;;;;;;OAMG;IACI,eAAe,CAAC,UAAkB,EAAE,UAAyB,EAAE,SAAkB;QACvF,MAAM,cAAc,GAAG,IAAI,iBAAiB,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;QAC7D,MAAM,MAAM,GAAG,IAAI,aAAa,CAAC,cAAc,EAAgB,UAAU,CAAC,CAAC;QAC3E,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC7B,CAAC;IAED;;;;;;OAMG;IACI,kBAAkB,CAAC,UAAkB,EAAE,UAAyB,EAAE,SAAkB;QAC1F,MAAM,cAAc,GAAG,IAAI,iBAAiB,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;QAC7D,MAAM,MAAM,GAAG,IAAI,aAAa,CAAC,cAAc,EAAgB,UAAU,EAAE,eAAe,CAAC,UAAU,CAAC,CAAC;QACvG,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC7B,CAAC;IAED;;;;;OAKG;IACI,GAAG,CAAC,MAAmB,EAAE,SAAkB;QACjD,oBAAoB,CAAC,kBAAkB,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAC1D,MAAM,GAAG,GAAG,SAAS,IAAI,aAAa,EAAE,CAAC;QACzC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IAC/B,CAAC;IAED;;;OAGG;IACI,KAAK;QACX,MAAM,WAAW,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,gBAAgB,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QACjF,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE;YAC1C,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;QACH,WAAW,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QACvC,WAAW,CAAC,2BAA2B,GAAG,IAAI,CAAC,2BAA2B,CAAC;QAC3E,OAAO,WAAW,CAAC;IACpB,CAAC;IAED;;OAEG;IACI,eAAe;QACrB,MAAM,MAAM,GAAiB,EAAE,CAAC;QAChC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;YAC/B,IAAI,iBAAiB,GAAG,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC,MAAM,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC/E,iBAAiB,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;gBAC1D,IAAI,EAAE,UAAU,CAAC,IAAI;gBACrB,UAAU,EAAE,UAAU,CAAC,UAAU,IAAI,IAAI,CAAC,cAAc;aACxD,CAAC,CAAC,CAAC;YACJ,MAAM,CAAC,IAAI,CAAC,GAAG,iBAAiB,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;QACH,OAAO,MAAM,CAAC;IACf,CAAC;;AAhPM;IADN,OAAO,EAAE;;6CACqC;AAM/C;IAAC,MAAM,EAAE;;;yCAOR","sourcesContent":["import { Exclude, Expose } from 'class-transformer';\n\nimport { ɵBaseFilter } from './base-filter';\nimport { ɵBetweenFilter } from './between-filter';\nimport { ɵCompareFilter } from './compare-filter';\nimport { ɵExistsFilter } from './exists-filter';\nimport { ɵBaseFilterParser } from './filter-parser/base-filter-parser';\nimport { ɵInFilter } from './in-filter';\nimport { ɵIsNullFilter } from './isnull-filter';\nimport { ɵEntityColumnValue, ɵgenerateGuid, ɵGuid, ɵJsonObject } from '../../../../public/types';\nimport { ɵValidationUtilities } from '../../../exceptions';\nimport { ɵComparisonType } from '../enums/comparison-type.enum';\nimport { ɵFilterType } from '../enums/filter-type.enum';\nimport { ɵLogicalOperatorType } from '../enums/logical-operator-type.enum';\nimport { ɵQueryMacrosType } from '../enums/query-macros-type.enum';\nimport { ɵColumnExpression } from '../expressions/columns/column-expression';\nimport { ɵMacrosFunctionExpression } from '../expressions/functions/macros-function-expression';\nimport { ɵParameterExpression } from '../expressions/parameters/parameter-expression';\nimport { UsedColumn } from '../used-column';\n\n/**\n * @public\n * @description Group of filters. Groups of filters can be nested into each other,\n * i.e. The collection itself can be an element of another collection.\n * @extends {ɵBaseFilter}\n */\nexport class ɵFilterGroup extends ɵBaseFilter {\n\t/**\n\t * @internal\n\t * @dontChange\n\t */\n\tprotected static readonly _instanceOfKey: string = 'devkit_FilterGroup';\n\n\t/**\n\t * @internal\n\t * @dontChange\n\t */\n\tprotected static get _instanceOfKeys(): string[] {\n\t\treturn [...ɵBaseFilter._instanceOfKeys, this._instanceOfKey];\n\t}\n\n\t/**\n\t * @public\n\t * @description Collection of child filters.\n\t */\n\t@Exclude()\n\tpublic filters = new Map<ɵGuid, ɵBaseFilter>();\n\n\t/**\n\t * @public\n\t * @description Return collecion of deserialized filters.\n\t */\n\t@Expose()\n\tpublic get items(): { [key: string]: ɵBaseFilter } {\n\t\tconst result = {};\n\t\tthis.filters.forEach((filter, key) => {\n\t\t\tresult[key] = this.serializeItem(filter);\n\t\t});\n\t\treturn result;\n\t}\n\n\t/**\n\t * @description The type of the logical operation for a combination of filters in the collection.\n\t */\n\tpublic logicalOperation: ɵLogicalOperatorType;\n\t/**\n\t * @description Root schema name.\n\t */\n\tpublic rootSchemaName?: string;\n\n\tconstructor(logicalOperation = ɵLogicalOperatorType.And, rootSchemaName?: string) {\n\t\tsuper(ɵFilterType.FilterGroup);\n\t\tthis.logicalOperation = logicalOperation;\n\t\tthis.rootSchemaName = rootSchemaName;\n\t}\n\n\t/**\n\t * @public\n\t * @description Parses filter group from json.\n\t */\n\tpublic static fromJson<T extends typeof ɵBaseFilterParser>(dto: ɵJsonObject, filterParser: T): ɵFilterGroup {\n\t\tconst logicalOperation = dto['logicalOperation'] as ɵLogicalOperatorType;\n\t\tconst group = new ɵFilterGroup(logicalOperation || ɵLogicalOperatorType.And, dto['rootSchemaName'] as string);\n\t\tObject.entries(dto['items'] as ɵJsonObject).forEach(([key, filterDTO]) => {\n\t\t\tgroup.add(filterParser.fromJson(filterDTO as ɵJsonObject) as ɵBaseFilter, key);\n\t\t});\n\t\treturn group;\n\t}\n\n\t/** {@inheritDoc ɵSerializable.toJson} */\n\tpublic toJson(): ɵJsonObject {\n\t\tconst result = {};\n\t\tresult['filterType'] = this.filterType;\n\t\tresult['isEnabled'] = this.isEnabled;\n\t\tresult['logicalOperation'] = this.logicalOperation;\n\t\tresult['trimDateTimeParameterToDate'] = this.trimDateTimeParameterToDate;\n\t\tresult['items'] = this.items;\n\t\tif (this.rootSchemaName) {\n\t\t\tresult['rootSchemaName'] = this.rootSchemaName;\n\t\t}\n\t\treturn result;\n\t}\n\n\tprivate _createParameterValueExpressions(values: ɵEntityColumnValue[]): ɵParameterExpression[] {\n\t\treturn values.map(\n\t\t\t(value) =>\n\t\t\t\tnew ɵParameterExpression({\n\t\t\t\t\tvalue: value,\n\t\t\t\t}),\n\t\t);\n\t}\n\n\t/**\n\t * @public\n\t * @description Returns filter item by index.\n\t * @param index Item index.\n\t * @returns Filter.\n\t */\n\tpublic getItemByIndex(index: number): ɵBaseFilter {\n\t\treturn this.items[Object.keys(this.items)[index]];\n\t}\n\n\t/**\n\t * @public\n\t * @description Creates and adds compare filter by value.\n\t * @param comparisonType Comparison type.\n\t * @param columnPath Column path.\n\t * @param parameterValue Parameter value.\n\t * @param filterKey Filter key.\n\t */\n\tpublic addSchemaColumnFilterWithParameter(\n\t\tcomparisonType: ɵComparisonType,\n\t\tcolumnPath: string,\n\t\tparameterValue: ɵEntityColumnValue,\n\t\tfilterKey?: string,\n\t): void {\n\t\tconst leftExpression = new ɵColumnExpression({ columnPath });\n\t\tconst rightExpression = new ɵParameterExpression({ value: parameterValue });\n\t\tconst filter = new ɵCompareFilter(comparisonType, leftExpression, rightExpression);\n\t\tthis.add(filter, filterKey);\n\t}\n\n\t/**\n\t * @public\n\t * @description Creates and adds in filter by values.\n\t * @param comparisonType Comparison type.\n\t * @param columnPath Column path.\n\t * @param parameterValues Parameter values.\n\t * @param filterKey Filter key.\n\t */\n\tpublic addSchemaColumnInFilterWithParameters(\n\t\tcomparisonType: ɵComparisonType,\n\t\tcolumnPath: string,\n\t\tparameterValues: ɵEntityColumnValue[],\n\t\tfilterKey?: string,\n\t): void {\n\t\tconst leftExpression = new ɵColumnExpression({ columnPath });\n\t\tconst expressions = this._createParameterValueExpressions(parameterValues);\n\t\tconst filter = new ɵInFilter(comparisonType, leftExpression, expressions);\n\t\tthis.add(filter, filterKey);\n\t}\n\n\t/**\n\t * @public\n\t * @description Creates and adds in filter for primary column.\n\t * @param primaryColumnValues Primary column values.\n\t * @param filterKey Filter key.\n\t */\n\tpublic addPrimarySchemaColumnInFilter(primaryColumnValues: ɵEntityColumnValue[], filterKey?: string): void {\n\t\tconst leftExpression = new ɵMacrosFunctionExpression({ macrosType: ɵQueryMacrosType.PrimaryColumn });\n\t\tconst expressions = this._createParameterValueExpressions(primaryColumnValues);\n\t\tconst filter = new ɵInFilter(ɵComparisonType.Equal, leftExpression, expressions);\n\t\tthis.add(filter, filterKey);\n\t}\n\n\t/**\n\t * @public\n\t * @description Creates and adds null filter.\n\t * @param columnPath Path of column.\n\t * @param filterKey Filter key.\n\t */\n\tpublic addSchemaColumnIsNullFilter(columnPath: string, filterKey?: string): void {\n\t\tconst leftExpression = new ɵColumnExpression({ columnPath });\n\t\tconst filter = new ɵIsNullFilter(ɵComparisonType.Is_null, leftExpression);\n\t\tthis.add(filter, filterKey);\n\t}\n\n\t/**\n\t * @public\n\t * @description Creates and adds not null filter.\n\t * @param columnPath Column path.\n\t * @param filterKey Filter key.\n\t */\n\tpublic addSchemaColumnIsNotNullFilter(columnPath: string, filterKey?: string): void {\n\t\tconst leftExpression = new ɵColumnExpression({ columnPath });\n\t\tconst filter = new ɵIsNullFilter(ɵComparisonType.Is_not_null, leftExpression);\n\t\tthis.add(filter, filterKey);\n\t}\n\n\t/**\n\t * @public\n\t * @description Creates and adds filter between less value and greater value.\n\t * @param columnPath Column path.\n\t * @param lessParamValue Less parameter value.\n\t * @param greaterParamValue Greater parameter value.\n\t * @param filterKey Filter key.\n\t */\n\tpublic addSchemaColumnBetweenFilterWithParameters(\n\t\tcolumnPath: string,\n\t\tlessParamValue: Date | number,\n\t\tgreaterParamValue: Date | number,\n\t\tfilterKey?: string,\n\t): void {\n\t\tconst leftExpression = new ɵColumnExpression({ columnPath });\n\t\tconst rightLessExpression = new ɵParameterExpression({ value: lessParamValue });\n\t\tconst rightGreaterExpression = new ɵParameterExpression({ value: greaterParamValue });\n\t\tconst filter = new ɵBetweenFilter(leftExpression, rightLessExpression, rightGreaterExpression);\n\t\tthis.add(filter, filterKey);\n\t}\n\n\t/**\n\t * @public\n\t * @description Creates and adds exists filter.\n\t * @param columnPath Column path.\n\t * @param subFilters Filters for exists expression.\n\t * @param filterKey Filter key.\n\t */\n\tpublic addExistsFilter(columnPath: string, subFilters?: ɵFilterGroup, filterKey?: string): void {\n\t\tconst leftExpression = new ɵColumnExpression({ columnPath });\n\t\tconst filter = new ɵExistsFilter(leftExpression, <ɵFilterGroup>subFilters);\n\t\tthis.add(filter, filterKey);\n\t}\n\n\t/**\n\t * @public\n\t * @description Creates and adds not exists filter.\n\t * @param columnPath Column path.\n\t * @param subFilters Filters for exist expression.\n\t * @param filterKey Filter key.\n\t */\n\tpublic addNotExistsFilter(columnPath: string, subFilters?: ɵFilterGroup, filterKey?: string): void {\n\t\tconst leftExpression = new ɵColumnExpression({ columnPath });\n\t\tconst filter = new ɵExistsFilter(leftExpression, <ɵFilterGroup>subFilters, ɵComparisonType.Not_exists);\n\t\tthis.add(filter, filterKey);\n\t}\n\n\t/**\n\t * @public\n\t * @description Adds filter.\n\t * @param filter Instance of filter.\n\t * @param filterKey Filter key.\n\t */\n\tpublic add(filter: ɵBaseFilter, filterKey?: string): void {\n\t\tɵValidationUtilities.checkArgumentEmpty('filter', filter);\n\t\tconst key = filterKey || ɵgenerateGuid();\n\t\tthis.filters.set(key, filter);\n\t}\n\n\t/**\n\t * @public\n\t * @description Clones instance.\n\t */\n\tpublic clone(): ɵFilterGroup {\n\t\tconst filterGroup = new ɵFilterGroup(this.logicalOperation, this.rootSchemaName);\n\t\tthis.filters.forEach((filter, filterKey) => {\n\t\t\tfilterGroup.filters.set(filterKey, filter.clone());\n\t\t});\n\t\tfilterGroup.isEnabled = this.isEnabled;\n\t\tfilterGroup.trimDateTimeParameterToDate = this.trimDateTimeParameterToDate;\n\t\treturn filterGroup;\n\t}\n\n\t/**\n\t * @internal\n\t */\n\tpublic _getUsedColumns(): UsedColumn[] {\n\t\tconst result: UsedColumn[] = [];\n\t\tthis.filters.forEach((filter) => {\n\t\t\tlet filterUsedColumns = filter._getUsedColumns ? filter._getUsedColumns() : [];\n\t\t\tfilterUsedColumns = filterUsedColumns.map((usedColumn) => ({\n\t\t\t\tpath: usedColumn.path,\n\t\t\t\tschemaName: usedColumn.schemaName ?? this.rootSchemaName,\n\t\t\t}));\n\t\t\tresult.push(...filterUsedColumns);\n\t\t});\n\t\treturn result;\n\t}\n}\n"]}

package/esm2022/lib/public/esq/data-model/filters/filter-parser/base-filter-parser.mjs

@@ -0,0 +1,15 @@
+/**
+ * @public
+ * @description Filter parser interface.
+ */
+export class ɵBaseFilterParser {
+    /**
+     * @description Creates filter from JSON.
+     * @param dto - Serialized filter.
+     * @return Instance of filter.
+     */
+    static fromJson(dto) {
+        throw new Error('not implemented');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1maWx0ZXItcGFyc2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9kZXZraXQvYmFzZS9zcmMvbGliL3B1YmxpYy9lc3EvZGF0YS1tb2RlbC9maWx0ZXJzL2ZpbHRlci1wYXJzZXIvYmFzZS1maWx0ZXItcGFyc2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOzs7R0FHRztBQUNILE1BQU0sT0FBTyxpQkFBaUI7SUFDN0I7Ozs7T0FJRztJQUNJLE1BQU0sQ0FBQyxRQUFRLENBQUMsR0FBZ0I7UUFDdEMsTUFBTSxJQUFJLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0lBQ3BDLENBQUM7Q0FDRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IMm1SnNvbk9iamVjdCB9IGZyb20gJy4uLy4uLy4uLy4uL3R5cGVzL2pzb24tZGF0YS50eXBlJztcblxuLyoqXG4gKiBAcHVibGljXG4gKiBAZGVzY3JpcHRpb24gRmlsdGVyIHBhcnNlciBpbnRlcmZhY2UuXG4gKi9cbmV4cG9ydCBjbGFzcyDJtUJhc2VGaWx0ZXJQYXJzZXIge1xuXHQvKipcblx0ICogQGRlc2NyaXB0aW9uIENyZWF0ZXMgZmlsdGVyIGZyb20gSlNPTi5cblx0ICogQHBhcmFtIGR0byAtIFNlcmlhbGl6ZWQgZmlsdGVyLlxuXHQgKiBAcmV0dXJuIEluc3RhbmNlIG9mIGZpbHRlci5cblx0ICovXG5cdHB1YmxpYyBzdGF0aWMgZnJvbUpzb24oZHRvOiDJtUpzb25PYmplY3QpOiB1bmtub3duIHtcblx0XHR0aHJvdyBuZXcgRXJyb3IoJ25vdCBpbXBsZW1lbnRlZCcpO1xuXHR9XG59XG4iXX0=

package/esm2022/lib/public/esq/data-model/filters/filter-parser/filter-parser.mjs

@@ -0,0 +1,23 @@
+import { ɵBaseFilterParser } from './base-filter-parser';
+import { ɵFilterResolver } from './filter-resolver';
+import { ɵExpressionParser } from '../../expressions/expression-parser/expression-parser';
+/**
+ * @public
+ * @description Filter parser.
+ */
+export class ɵFilterParser extends ɵBaseFilterParser {
+    /**
+     * @description Creates filter from JSON.
+     * @param dto - Serialized filter.
+     */
+    static fromJson(dto) {
+        const filterType = dto['filterType'];
+        const isEnabled = dto['isEnabled'];
+        const trimDateTimeParameterToDate = dto['trimDateTimeParameterToDate'];
+        const filter = ɵFilterResolver.resolve(filterType).fromJson(dto, ɵFilterParser, ɵExpressionParser);
+        filter.isEnabled = isEnabled !== false;
+        filter.trimDateTimeParameterToDate = trimDateTimeParameterToDate === true;
+        return filter;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/public/esq/data-model/filters/filter-parser/filter-resolver.mjs

@@ -0,0 +1,31 @@
+import { ɵFilterType } from '../../enums/filter-type.enum';
+import { ɵBetweenFilter } from '../between-filter';
+import { ɵCompareFilter } from '../compare-filter';
+import { ɵExistsFilter } from '../exists-filter';
+import { ɵFilterGroup } from '../filter-group';
+import { ɵInFilter } from '../in-filter';
+import { ɵIsNullFilter } from '../isnull-filter';
+/**
+ * @public
+ * @description Filter resolver.
+ */
+export class ɵFilterResolver {
+    /**
+     * @public
+     * @description Resolves class of filter.
+     * @param filterType - Type of filter.
+     * @return Class of filter.
+     */
+    static resolve(filterType) {
+        const filterClass = {
+            [ɵFilterType.Compare]: ɵCompareFilter,
+            [ɵFilterType.FilterGroup]: ɵFilterGroup,
+            [ɵFilterType.In]: ɵInFilter,
+            [ɵFilterType.IsNull]: ɵIsNullFilter,
+            [ɵFilterType.Exists]: ɵExistsFilter,
+            [ɵFilterType.Between]: ɵBetweenFilter,
+        };
+        return filterClass[filterType];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/public/esq/data-model/filters/filter-test-utils.mjs

@@ -0,0 +1,17 @@
+/**
+ * @internal
+ */
+export const ɵDEFAULT_FILTER_PLAIN_OBJ = {
+    isEnabled: true,
+    trimDateTimeParameterToDate: false,
+};
+/**
+ * @internal
+ */
+export function ɵgetFilterPlainObj(filterPlainObj) {
+    return {
+        ...ɵDEFAULT_FILTER_PLAIN_OBJ,
+        ...filterPlainObj,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyLXRlc3QtdXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2RldmtpdC9iYXNlL3NyYy9saWIvcHVibGljL2VzcS9kYXRhLW1vZGVsL2ZpbHRlcnMvZmlsdGVyLXRlc3QtdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSx5QkFBeUIsR0FBVztJQUNoRCxTQUFTLEVBQUUsSUFBSTtJQUNmLDJCQUEyQixFQUFFLEtBQUs7Q0FDbEMsQ0FBQztBQUVGOztHQUVHO0FBQ0gsTUFBTSxVQUFVLGtCQUFrQixDQUFDLGNBQXVCO0lBQ3pELE9BQU87UUFDTixHQUFHLHlCQUF5QjtRQUM1QixHQUFHLGNBQWM7S0FDakIsQ0FBQztBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBpbnRlcm5hbFxuICovXG5leHBvcnQgY29uc3QgybVERUZBVUxUX0ZJTFRFUl9QTEFJTl9PQko6IG9iamVjdCA9IHtcblx0aXNFbmFibGVkOiB0cnVlLFxuXHR0cmltRGF0ZVRpbWVQYXJhbWV0ZXJUb0RhdGU6IGZhbHNlLFxufTtcblxuLyoqXG4gKiBAaW50ZXJuYWxcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIMm1Z2V0RmlsdGVyUGxhaW5PYmooZmlsdGVyUGxhaW5PYmo/OiBvYmplY3QpOiBvYmplY3Qge1xuXHRyZXR1cm4ge1xuXHRcdC4uLsm1REVGQVVMVF9GSUxURVJfUExBSU5fT0JKLFxuXHRcdC4uLmZpbHRlclBsYWluT2JqLFxuXHR9O1xufVxuIl19