@netgrif/components-core 6.0.1

package/esm5/lib/search/models/configuration-input.js

@@ -0,0 +1,71 @@
+import { FormControl } from '@angular/forms';
+import { filter, map, startWith } from 'rxjs/operators';
+/**
+ * Represents a search category configuration input.
+ *
+ * Should handle all the logic related to autocomplete search configuration inputs.
+ * If this class has its `type` set to `OPERATOR` it works mostly as a placeholder object, because the
+ * operator and operand selection logic is handled by the {@link Category} class.
+ * This behavior might be changed in future releases.
+ */
+var ConfigurationInput = /** @class */ (function () {
+    /**
+     * @param type the type of the configuration input
+     * @param label the translation path for the label of the input
+     * @param displayBold whether the configuration input should be displayed in bold after selection or not
+     * @param _autocompleteOptions the autocomplete options that are available in this configuration input
+     * @param filterOptions a method that receives the keys of the available options and should return
+     * the appropriately filtered autocomplete options
+     */
+    function ConfigurationInput(type, label, displayBold, _autocompleteOptions, filterOptions) {
+        var _this = this;
+        this.type = type;
+        this.label = label;
+        this.displayBold = displayBold;
+        this._autocompleteOptions = _autocompleteOptions;
+        this._formControl = new FormControl();
+        this._filteredOptions$ = this._formControl.valueChanges.pipe(startWith(''), filter(function (newValue) { return typeof newValue === 'string'; }), map(function (newValue) {
+            return filterOptions(Array.from(_this._autocompleteOptions.keys()), newValue);
+        }));
+    }
+    Object.defineProperty(ConfigurationInput.prototype, "formControl", {
+        get: function () {
+            return this._formControl;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ConfigurationInput.prototype, "isOptionSelected", {
+        get: function () {
+            return !!this._formControl.value && (typeof this._formControl.value !== 'string');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ConfigurationInput.prototype, "selectedOptionTranslatePath", {
+        get: function () {
+            return this.isOptionSelected ? this._formControl.value.text : '';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ConfigurationInput.prototype, "filteredOptions$", {
+        get: function () {
+            return this._filteredOptions$;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Value changes of the encapsulated `FormControl` object
+     */
+    ConfigurationInput.prototype.valueChanges$ = function () {
+        return this._formControl.valueChanges;
+    };
+    ConfigurationInput.prototype.clear = function () {
+        this._formControl.setValue(undefined);
+    };
+    return ConfigurationInput;
+}());
+export { ConfigurationInput };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/datafield-map-key.js

@@ -0,0 +1,91 @@
+/**
+ * Objects that represent keys to the map of available data fields in {@link CaseDataset} search category.
+ *
+ * Since javascript maps don't support objects as keys this class has a serialized form, that is used as a `string` key.
+ *
+ * This class also acts as an autocomplete option when the target datafield is selected. The real data fields are then extracted from the
+ * map to which this object is a key.
+ */
+var DatafieldMapKey = /** @class */ (function () {
+    function DatafieldMapKey(_inputType, _title) {
+        this._inputType = _inputType;
+        this._title = _title;
+    }
+    DatafieldMapKey.serializedForm = function (type, title) {
+        return type + "#" + title;
+    };
+    DatafieldMapKey.parse = function (serializedMapKey) {
+        var parts = serializedMapKey.split('#');
+        return new DatafieldMapKey(parts.shift(), parts.join('#'));
+    };
+    Object.defineProperty(DatafieldMapKey.prototype, "title", {
+        get: function () {
+            return this._title;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DatafieldMapKey.prototype, "type", {
+        get: function () {
+            return this._inputType;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DatafieldMapKey.prototype, "icon", {
+        get: function () {
+            switch (this._inputType) {
+                case 'boolean':
+                    return 'toggle_off';
+                case 'date':
+                    return 'today';
+                case 'enumeration':
+                    return 'radio_button_checked';
+                case 'file':
+                    return 'insert_drive_file';
+                case 'fileList':
+                    return 'file_copy';
+                case 'multichoice':
+                    return 'check_box';
+                case 'number':
+                    return 'looks_one';
+                case 'user':
+                    return 'person';
+                case 'userList':
+                    return 'people';
+                case 'dateTime':
+                    return 'schedule';
+                default:
+                    return 'text_format';
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DatafieldMapKey.prototype, "value", {
+        /**
+         * Alias for [toSerializedForm()]{@link DatafieldMapKey#toSerializedForm}
+         */
+        get: function () {
+            return this.toSerializedForm();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DatafieldMapKey.prototype, "text", {
+        /**
+         * Alias for [title]{@link DatafieldMapKey#title}
+         */
+        get: function () {
+            return this.title;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DatafieldMapKey.prototype.toSerializedForm = function () {
+        return DatafieldMapKey.serializedForm(this._inputType, this._title);
+    };
+    return DatafieldMapKey;
+}());
+export { DatafieldMapKey };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/escape-result.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNjYXBlLXJlc3VsdC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9zZWFyY2gvbW9kZWxzL2VzY2FwZS1yZXN1bHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUmVzdWx0IGZyb20gdGhlIFtlc2NhcGVJbnB1dCgpXXtAbGluayBPcGVyYXRvciNlc2NhcGVJbnB1dH0gZnVuY3Rpb24uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRXNjYXBlUmVzdWx0IHtcbiAgICAvKipcbiAgICAgKiBUaGUgZXNjYXBlZCB2YWx1ZS5cbiAgICAgKi9cbiAgICB2YWx1ZTogc3RyaW5nO1xuXG4gICAgLyoqXG4gICAgICogV2hldGhlciBzb21lIGNoYXJhY3RlcnMgaGFkIGJlZW4gZXNjYXBlZCBvciBub3QuXG4gICAgICovXG4gICAgd2FzRXNjYXBlZDogYm9vbGVhbjtcbn1cbiJdfQ==

package/esm5/lib/search/models/operator/equals-date-time.js

@@ -0,0 +1,31 @@
+import { __extends } from "tslib";
+import { InRangeDateTime } from './in-range-date-time';
+import { Operator } from './operator';
+import { Operators } from './operators';
+/**
+ * Equality operator for indexed fields that store a date time object in timestamp format.
+ *
+ * Will create a range query that matches every timestamp from the 0th millisecond of the selected date time object (included)
+ * to the 0th millisecond after of the next minute after the minute of the date time object (excluded).
+ */
+var EqualsDateTime = /** @class */ (function (_super) {
+    __extends(EqualsDateTime, _super);
+    function EqualsDateTime(operators) {
+        var _this = _super.call(this, 1) || this;
+        _this.dateTimeRange = operators.getOperator(InRangeDateTime);
+        return _this;
+    }
+    EqualsDateTime.prototype.createQuery = function (elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        return this.dateTimeRange.createQuery(elasticKeywords, [args[0], args[0]]);
+    };
+    EqualsDateTime.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.equals', Operator.INPUT_PLACEHOLDER];
+    };
+    EqualsDateTime.prototype.serialize = function () {
+        return Operators.EQUALS_DATE_TIME;
+    };
+    return EqualsDateTime;
+}(Operator));
+export { EqualsDateTime };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/operator/equals-date.js

@@ -0,0 +1,31 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import { InRangeDate } from './in-range-date';
+import { Operators } from './operators';
+/**
+ * Equality operator for indexed fields that store a date in timestamp format.
+ *
+ * Will create a range query that matches every timestamp from the midnight of the selected day (included)
+ * to the midnight of the next day (excluded).
+ */
+var EqualsDate = /** @class */ (function (_super) {
+    __extends(EqualsDate, _super);
+    function EqualsDate(operators) {
+        var _this = _super.call(this, 1) || this;
+        _this.dateRange = operators.getOperator(InRangeDate);
+        return _this;
+    }
+    EqualsDate.prototype.createQuery = function (elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        return this.dateRange.createQuery(elasticKeywords, [args[0], args[0]]);
+    };
+    EqualsDate.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.equals', Operator.INPUT_PLACEHOLDER];
+    };
+    EqualsDate.prototype.serialize = function () {
+        return Operators.EQUALS_DATE;
+    };
+    return EqualsDate;
+}(Operator));
+export { EqualsDate };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/operator/equals.js

@@ -0,0 +1,25 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import { Operators } from './operators';
+/**
+ * Strict equality operator. Will match if the field has the exact same value as the input.
+ * Can be used with keyword fields and different types,
+ * but it is not recommended to use it with date and datetime fields as an exact timestamp match would be required.
+ * For timestamps use {@link EqualsDate} or {@link EqualsDateTime} instead.
+ */
+var Equals = /** @class */ (function (_super) {
+    __extends(Equals, _super);
+    function Equals() {
+        // query string queries don't use a special symbol for strict equality
+        return _super.call(this, 1, '') || this;
+    }
+    Equals.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.equals', Operator.INPUT_PLACEHOLDER];
+    };
+    Equals.prototype.serialize = function () {
+        return Operators.EQUALS;
+    };
+    return Equals;
+}(Operator));
+export { Equals };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXF1YWxzLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3NlYXJjaC9tb2RlbHMvb3BlcmF0b3IvZXF1YWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sWUFBWSxDQUFDO0FBQ3BDLE9BQU8sRUFBQyxTQUFTLEVBQUMsTUFBTSxhQUFhLENBQUM7QUFFdEM7Ozs7O0dBS0c7QUFDSDtJQUE0QiwwQkFBeUI7SUFDakQ7UUFDSSxzRUFBc0U7ZUFDdEUsa0JBQU0sQ0FBQyxFQUFFLEVBQUUsQ0FBQztJQUNoQixDQUFDO0lBRUQsd0NBQXVCLEdBQXZCO1FBQ0ksT0FBTyxDQUFDLHdCQUF3QixFQUFFLFFBQVEsQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0lBQ2xFLENBQUM7SUFFRCwwQkFBUyxHQUFUO1FBQ0ksT0FBTyxTQUFTLENBQUMsTUFBTSxDQUFDO0lBQzVCLENBQUM7SUFDTCxhQUFDO0FBQUQsQ0FBQyxBQWJELENBQTRCLFFBQVEsR0FhbkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge09wZXJhdG9yfSBmcm9tICcuL29wZXJhdG9yJztcbmltcG9ydCB7T3BlcmF0b3JzfSBmcm9tICcuL29wZXJhdG9ycyc7XG5cbi8qKlxuICogU3RyaWN0IGVxdWFsaXR5IG9wZXJhdG9yLiBXaWxsIG1hdGNoIGlmIHRoZSBmaWVsZCBoYXMgdGhlIGV4YWN0IHNhbWUgdmFsdWUgYXMgdGhlIGlucHV0LlxuICogQ2FuIGJlIHVzZWQgd2l0aCBrZXl3b3JkIGZpZWxkcyBhbmQgZGlmZmVyZW50IHR5cGVzLFxuICogYnV0IGl0IGlzIG5vdCByZWNvbW1lbmRlZCB0byB1c2UgaXQgd2l0aCBkYXRlIGFuZCBkYXRldGltZSBmaWVsZHMgYXMgYW4gZXhhY3QgdGltZXN0YW1wIG1hdGNoIHdvdWxkIGJlIHJlcXVpcmVkLlxuICogRm9yIHRpbWVzdGFtcHMgdXNlIHtAbGluayBFcXVhbHNEYXRlfSBvciB7QGxpbmsgRXF1YWxzRGF0ZVRpbWV9IGluc3RlYWQuXG4gKi9cbmV4cG9ydCBjbGFzcyBFcXVhbHMgZXh0ZW5kcyBPcGVyYXRvcjxzdHJpbmcgfCBudW1iZXI+IHtcbiAgICBjb25zdHJ1Y3RvcigpIHtcbiAgICAgICAgLy8gcXVlcnkgc3RyaW5nIHF1ZXJpZXMgZG9uJ3QgdXNlIGEgc3BlY2lhbCBzeW1ib2wgZm9yIHN0cmljdCBlcXVhbGl0eVxuICAgICAgICBzdXBlcigxLCAnJyk7XG4gICAgfVxuXG4gICAgZ2V0T3BlcmF0b3JOYW1lVGVtcGxhdGUoKTogQXJyYXk8c3RyaW5nPiB7XG4gICAgICAgIHJldHVybiBbJ3NlYXJjaC5vcGVyYXRvci5lcXVhbHMnLCBPcGVyYXRvci5JTlBVVF9QTEFDRUhPTERFUl07XG4gICAgfVxuXG4gICAgc2VyaWFsaXplKCk6IE9wZXJhdG9ycyB8IHN0cmluZyB7XG4gICAgICAgIHJldHVybiBPcGVyYXRvcnMuRVFVQUxTO1xuICAgIH1cbn1cbiJdfQ==

package/esm5/lib/search/models/operator/in-range-date-time.js

@@ -0,0 +1,47 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import moment from 'moment';
+import { Query } from '../query/query';
+import { Operators } from './operators';
+/**
+ * Range operator for indexed fields that store a date time in timestamp format.
+ *
+ * Will create a range query that matches every timestamp from the 0th millisecond of the first date time object (included)
+ * to the 0th millisecond of the next minute after the minute in the second date time object (excluded).
+ */
+var InRangeDateTime = /** @class */ (function (_super) {
+    __extends(InRangeDateTime, _super);
+    function InRangeDateTime() {
+        return _super.call(this, 2) || this;
+    }
+    /**
+     * Creates a query as specified by the [classes]{@link InRangeDate} documentation.
+     * See [super.createQuery()]{@link Operator#createQuery} for more information.
+     * @param elasticKeywords keywords of the fields that should be queried.
+     * If more than one is provided then queries for every keyword will be generated and combined with an OR operator.
+     * @param args start and end date for the range. If you want to ignore the time information use {@link InRangeDate}
+     * Operator instead. The two date time objects must be in ascending order, if not the behavior is undefined.
+     */
+    InRangeDateTime.prototype.createQuery = function (elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        var arg1 = moment(args[0]);
+        arg1.milliseconds(0);
+        arg1.seconds(0);
+        var arg2 = moment(args[1]);
+        arg2.milliseconds(0);
+        arg2.seconds(0);
+        arg2.minutes(arg2.minutes() + 1); // moment handles rollover
+        return Operator.forEachKeyword(elasticKeywords, function (keyword) {
+            return new Query("(" + keyword + ":[" + arg1.valueOf() + " TO " + arg2.valueOf() + "})");
+        });
+    };
+    InRangeDateTime.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.inRange.from', Operator.INPUT_PLACEHOLDER, 'search.operator.inRange.to', Operator.INPUT_PLACEHOLDER];
+    };
+    InRangeDateTime.prototype.serialize = function () {
+        return Operators.IN_RANGE_DATE_TIME;
+    };
+    return InRangeDateTime;
+}(Operator));
+export { InRangeDateTime };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/operator/in-range-date.js

@@ -0,0 +1,46 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import { Query } from '../query/query';
+import moment from 'moment';
+import { clearTimeInformation } from '../../../utility/clear-time-information';
+import { Operators } from './operators';
+/**
+ * Range operator for indexed fields that store a date in timestamp format.
+ *
+ * Will create a range query that matches every timestamp from the midnight of the first day (included)
+ * to the midnight of the day after the second day (excluded).
+ */
+var InRangeDate = /** @class */ (function (_super) {
+    __extends(InRangeDate, _super);
+    function InRangeDate() {
+        return _super.call(this, 2) || this;
+    }
+    /**
+     * Creates a query as specified by the [classes]{@link InRangeDate} documentation.
+     * See [super.createQuery()]{@link Operator#createQuery} for more information.
+     * @param elasticKeywords keywords of the fields that should be queried.
+     * If more than one is provided then queries for every keyword will be generated and combined with an OR operator.
+     * @param args start and end date for the range. Any time information will be ignored use {@link InRangeDateTime}
+     * if you want a date time query instead. The two dates must be in ascending order, if not the behavior is undefined.
+     */
+    InRangeDate.prototype.createQuery = function (elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        var arg1 = moment(args[0]);
+        clearTimeInformation(arg1);
+        var arg2 = moment(args[1]);
+        clearTimeInformation(arg2);
+        arg2.date(arg2.date() + 1); // moment handles rollover
+        return Operator.forEachKeyword(elasticKeywords, function (keyword) {
+            return new Query("(" + keyword + ":[" + arg1.valueOf() + " TO " + arg2.valueOf() + "})");
+        });
+    };
+    InRangeDate.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.inRange.from', Operator.INPUT_PLACEHOLDER, 'search.operator.inRange.to', Operator.INPUT_PLACEHOLDER];
+    };
+    InRangeDate.prototype.serialize = function () {
+        return Operators.IN_RANGE_DATE;
+    };
+    return InRangeDate;
+}(Operator));
+export { InRangeDate };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/operator/in-range.js

@@ -0,0 +1,26 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import { Query } from '../query/query';
+import { Operators } from './operators';
+/**
+ * A range operator for numeric fields, with closed interval on both sides of the range.
+ */
+var InRange = /** @class */ (function (_super) {
+    __extends(InRange, _super);
+    function InRange() {
+        return _super.call(this, 2) || this;
+    }
+    InRange.prototype.createQuery = function (elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        return Operator.forEachKeyword(elasticKeywords, function (keyword) { return new Query("(" + keyword + ":[" + args[0] + " TO " + args[1] + "])"); });
+    };
+    InRange.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.inRange.from', Operator.INPUT_PLACEHOLDER, 'search.operator.inRange.to', Operator.INPUT_PLACEHOLDER];
+    };
+    InRange.prototype.serialize = function () {
+        return Operators.IN_RANGE;
+    };
+    return InRange;
+}(Operator));
+export { InRange };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/operator/is-null.js

@@ -0,0 +1,75 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import { Query } from '../query/query';
+import { Operators } from './operators';
+/**
+ * An operator that can be used on any field and matches entries with null or empty string values.
+ *
+ * Beware that if any additional constraints should be applied to the generated query the results may behave strangely.
+ * Consult the [createQueryWithConstraint()]{@link IsNull#createQueryWithConstraint} method for more information.
+ */
+var IsNull = /** @class */ (function (_super) {
+    __extends(IsNull, _super);
+    function IsNull() {
+        return _super.call(this, 0) || this;
+    }
+    /**
+     * @param elasticKeywords the queried fields
+     * @returns Generates a query that matches null fields and fields with empty string values.
+     */
+    IsNull.prototype.createQuery = function (elasticKeywords) {
+        var _this = this;
+        return Operator.forEachKeyword(elasticKeywords, function (keyword) { return new Query("(" + _this.nullQueryString(keyword) + "OR" + _this.emptyStringQueryString(keyword) + ")"); });
+    };
+    /**
+     * Counterintuitively elasticsearch query string queries behave weirdly when combining the queries with operators such as `AND`.
+     * Because of this the following query:
+     *
+     *    (dataSet.text_0.value:"")
+     *
+     * returns an empty result set.
+     *
+     * But query that should be intuitively more constraining:
+     *
+     *     (dataSet.text_0.value:"") AND (processId:600168ccf68fea5241ae5e62)
+     *
+     * will return a non empty and expected result.
+     *
+     * This method exists to combat this issue and add the, sometimes necessary, constraint into the query generated by this operator.
+     *
+     * @param elasticKeywords the queried fields
+     * @param constraint a constraining query that is distributively applied into the query generated by this operator.
+     * If an empty query is provided the result will be the same as calling [createQuery()]{@link IsNull#createQuery}.
+     * @returns a query with distributively applied constraint query
+     */
+    IsNull.prototype.createQueryWithConstraint = function (elasticKeywords, constraint) {
+        var _this = this;
+        if (constraint.isEmpty) {
+            return this.createQuery(elasticKeywords);
+        }
+        return Operator.forEachKeyword(elasticKeywords, function (keyword) { return new Query("((" + _this.nullQueryString(keyword) + "AND" + constraint.value + ")OR(" + _this.emptyStringQueryString(keyword) + "AND" + constraint.value + "))"); });
+    };
+    /**
+     * @param elasticKeyword the queried field
+     * @returns a string representation of the query that checks whether the field is null
+     */
+    IsNull.prototype.nullQueryString = function (elasticKeyword) {
+        return "(!(_exists_:" + elasticKeyword + "))";
+    };
+    /**
+     * @param elasticKeyword the queried field
+     * @returns a string representation of the query that checks whether the field has an empty string value
+     */
+    IsNull.prototype.emptyStringQueryString = function (elasticKeyword) {
+        return "(" + elasticKeyword + ":\"\")";
+    };
+    IsNull.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.isNull'];
+    };
+    IsNull.prototype.serialize = function () {
+        return Operators.IS_NULL;
+    };
+    return IsNull;
+}(Operator));
+export { IsNull };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/operator/less-than-date-time.js

@@ -0,0 +1,32 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import moment from 'moment';
+import { LessThan } from './less-than';
+import { Operators } from './operators';
+/**
+ * A strict less than operator for DateTime fields
+ */
+var LessThanDateTime = /** @class */ (function (_super) {
+    __extends(LessThanDateTime, _super);
+    function LessThanDateTime(operators) {
+        var _this = _super.call(this, 1) || this;
+        _this.lessThan = operators.getOperator(LessThan);
+        return _this;
+    }
+    LessThanDateTime.prototype.createQuery = function (elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        var arg = moment(args[0]);
+        arg.milliseconds(0);
+        arg.seconds(0);
+        return this.lessThan.createQuery(elasticKeywords, [arg.valueOf()]);
+    };
+    LessThanDateTime.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.lessThan', Operator.INPUT_PLACEHOLDER];
+    };
+    LessThanDateTime.prototype.serialize = function () {
+        return Operators.LESS_THAN_DATE_TIME;
+    };
+    return LessThanDateTime;
+}(Operator));
+export { LessThanDateTime };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/operator/less-than-date.js

@@ -0,0 +1,32 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import moment from 'moment';
+import { clearTimeInformation } from '../../../utility/clear-time-information';
+import { LessThan } from './less-than';
+import { Operators } from './operators';
+/**
+ * A strict less than operator for Date fields
+ */
+var LessThanDate = /** @class */ (function (_super) {
+    __extends(LessThanDate, _super);
+    function LessThanDate(operators) {
+        var _this = _super.call(this, 1) || this;
+        _this.lessThan = operators.getOperator(LessThan);
+        return _this;
+    }
+    LessThanDate.prototype.createQuery = function (elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        var arg = moment(args[0]);
+        clearTimeInformation(arg);
+        return this.lessThan.createQuery(elasticKeywords, [arg.valueOf()]);
+    };
+    LessThanDate.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.lessThan', Operator.INPUT_PLACEHOLDER];
+    };
+    LessThanDate.prototype.serialize = function () {
+        return Operators.LESS_THAN_DATE;
+    };
+    return LessThanDate;
+}(Operator));
+export { LessThanDate };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/search/models/operator/less-than-equal-date-time.js

@@ -0,0 +1,32 @@
+import { __extends } from "tslib";
+import { Operator } from './operator';
+import moment from 'moment';
+import { LessThanEqual } from './less-than-equal';
+import { Operators } from './operators';
+/**
+ * Greater or equal than operator for Datetime fields
+ */
+var LessThanEqualDateTime = /** @class */ (function (_super) {
+    __extends(LessThanEqualDateTime, _super);
+    function LessThanEqualDateTime(operators) {
+        var _this = _super.call(this, 1) || this;
+        _this.lessThanEqual = operators.getOperator(LessThanEqual);
+        return _this;
+    }
+    LessThanEqualDateTime.prototype.createQuery = function (elasticKeywords, args) {
+        this.checkArgumentsCount(args);
+        var arg = moment(args[0]);
+        arg.milliseconds(0);
+        arg.seconds(0);
+        return this.lessThanEqual.createQuery(elasticKeywords, [arg.valueOf()]);
+    };
+    LessThanEqualDateTime.prototype.getOperatorNameTemplate = function () {
+        return ['search.operator.lessThanEqual', Operator.INPUT_PLACEHOLDER];
+    };
+    LessThanEqualDateTime.prototype.serialize = function () {
+        return Operators.LESS_THAN_DATE_TIME;
+    };
+    return LessThanEqualDateTime;
+}(Operator));
+export { LessThanEqualDateTime };
+//# sourceMappingURL=data:application/json;base64,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