@netgrif/components-core 6.0.1

package/lib/search/models/operator/less-than.d.ts

@@ -0,0 +1,10 @@
+import { Operator } from './operator';
+import { Operators } from './operators';
+/**
+ * A strict less than operator for numeric fields.
+ */
+export declare class LessThan extends Operator<number> {
+    constructor();
+    getOperatorNameTemplate(): Array<string>;
+    serialize(): Operators | string;
+}

package/lib/search/models/operator/like.d.ts

@@ -0,0 +1,18 @@
+import { Operator } from './operator';
+import { Query } from '../query/query';
+import { Operators } from './operators';
+/**
+ * A fuzzy search operator for string fields.
+ *
+ * Behaves differently for strings with spaces and without.
+ * With spaces searches for matches containing the tokenized strings.
+ * Without spaces searches for strings within the default edit distance.
+ * See [docs]{@link https://www.elastic.co/guide/en/elasticsearch/reference/6.6/query-dsl-query-string-query.html#_fuzziness}
+ * for more information.
+ */
+export declare class Like extends Operator<string> {
+    constructor();
+    createQuery(elasticKeywords: Array<string>, args: Array<string>): Query;
+    getOperatorNameTemplate(): Array<string>;
+    serialize(): Operators | string;
+}

package/lib/search/models/operator/more-than-date-time.d.ts

@@ -0,0 +1,16 @@
+import { Operator } from './operator';
+import { Moment } from 'moment';
+import { MoreThan } from './more-than';
+import { OperatorService } from '../../operator-service/operator.service';
+import { Query } from '../query/query';
+import { Operators } from './operators';
+/**
+ * A strict greater than operator for DateTime fields
+ */
+export declare class MoreThanDateTime extends Operator<Moment> {
+    protected moreThan: MoreThan;
+    constructor(operators: OperatorService);
+    createQuery(elasticKeywords: Array<string>, args: Array<Moment>): Query;
+    getOperatorNameTemplate(): Array<string>;
+    serialize(): Operators | string;
+}

package/lib/search/models/operator/more-than-date.d.ts

@@ -0,0 +1,16 @@
+import { Operator } from './operator';
+import { OperatorService } from '../../operator-service/operator.service';
+import { Query } from '../query/query';
+import { MoreThan } from './more-than';
+import { Moment } from 'moment';
+import { Operators } from './operators';
+/**
+ * A strict greater than operator for Date fields
+ */
+export declare class MoreThanDate extends Operator<Moment> {
+    protected moreThan: MoreThan;
+    constructor(operators: OperatorService);
+    createQuery(elasticKeywords: Array<string>, args: Array<Moment>): Query;
+    getOperatorNameTemplate(): Array<string>;
+    serialize(): Operators | string;
+}

package/lib/search/models/operator/more-than-equal-date-time.d.ts

@@ -0,0 +1,16 @@
+import { Operator } from './operator';
+import moment, { Moment } from 'moment';
+import { MoreThanEqual } from './more-than-equal';
+import { OperatorService } from '../../operator-service/operator.service';
+import { Operators } from './operators';
+import { Query } from '../query/query';
+/**
+ * Greater or equal than operator for Datetime fields
+ */
+export declare class MoreThanEqualDateTime extends Operator<Moment> {
+    protected moreThanEqual: MoreThanEqual;
+    constructor(operators: OperatorService);
+    createQuery(elasticKeywords: Array<string>, args: Array<moment.Moment>): Query;
+    getOperatorNameTemplate(): Array<string>;
+    serialize(): Operators | string;
+}

package/lib/search/models/operator/more-than-equal-date.d.ts

@@ -0,0 +1,16 @@
+import { Operator } from './operator';
+import { Moment } from 'moment';
+import { OperatorService } from '../../operator-service/operator.service';
+import { MoreThanEqual } from './more-than-equal';
+import { Operators } from './operators';
+import { Query } from '../query/query';
+/**
+ * Greater or equal than operator for Date fields
+ */
+export declare class MoreThanEqualDate extends Operator<Moment> {
+    protected moreThanEqual: MoreThanEqual;
+    constructor(operators: OperatorService);
+    createQuery(elasticKeywords: Array<string>, args: Array<Moment>): Query;
+    getOperatorNameTemplate(): Array<string>;
+    serialize(): Operators | string;
+}

package/lib/search/models/operator/more-than-equal.d.ts

@@ -0,0 +1,10 @@
+import { Operator } from './operator';
+import { Operators } from './operators';
+/**
+ * Greater or equal than operator for numeric fields
+ */
+export declare class MoreThanEqual extends Operator<number> {
+    constructor();
+    getOperatorNameTemplate(): Array<string>;
+    serialize(): Operators | string;
+}

package/lib/search/models/operator/more-than.d.ts

@@ -0,0 +1,10 @@
+import { Operator } from './operator';
+import { Operators } from './operators';
+/**
+ * A strict greater than operator for numeric fields.
+ */
+export declare class MoreThan extends Operator<number> {
+    constructor();
+    getOperatorNameTemplate(): Array<string>;
+    serialize(): Operators | string;
+}

package/lib/search/models/operator/not-equals-date-time.d.ts

@@ -0,0 +1,13 @@
+import { Operator } from './operator';
+import { OperatorService } from '../../operator-service/operator.service';
+import { Query } from '../query/query';
+import { Moment } from 'moment';
+import { Operators } from './operators';
+import { EqualsDateTime } from './equals-date-time';
+export declare class NotEqualsDateTime extends Operator<Moment> {
+    protected equals: EqualsDateTime;
+    constructor(operators: OperatorService);
+    createQuery(elasticKeywords: Array<string>, args: Array<Moment>): Query;
+    getOperatorNameTemplate(): Array<string>;
+    serialize(): Operators | string;
+}

package/lib/search/models/operator/not-equals-date.d.ts

@@ -0,0 +1,16 @@
+import { Operator } from './operator';
+import { OperatorService } from '../../operator-service/operator.service';
+import { Query } from '../query/query';
+import { EqualsDate } from './equals-date';
+import { Moment } from 'moment';
+import { Operators } from './operators';
+/**
+ * Inequality operator for Date fields. Will match if the field has a date with different day than the provided date.
+ */
+export declare class NotEqualsDate extends Operator<Moment> {
+    protected equals: EqualsDate;
+    constructor(operators: OperatorService);
+    createQuery(elasticKeywords: Array<string>, args: Array<Moment>): Query;
+    getOperatorNameTemplate(): Array<string>;
+    serialize(): Operators | string;
+}

package/lib/search/models/operator/not-equals.d.ts

@@ -0,0 +1,18 @@
+import { Operator } from './operator';
+import { Equals } from './equals';
+import { OperatorService } from '../../operator-service/operator.service';
+import { Query } from '../query/query';
+import { Operators } from './operators';
+/**
+ * Inequality operator. Will match if the field has a different value than the input.
+ * Can be used with keyword fields and different types. We don't recommend using this operator with date and datetime fields
+ * as an exact timestamp mismatch would be required.
+ * For Date needs use {@link NotEqualsDate} instead.
+ */
+export declare class NotEquals extends Operator<string | number> {
+    protected equals: Equals;
+    constructor(operators: OperatorService);
+    createQuery(elasticKeywords: Array<string>, args: Array<string | number>): Query;
+    getOperatorNameTemplate(): Array<string>;
+    serialize(): Operators | string;
+}

package/lib/search/models/operator/operator.d.ts

@@ -0,0 +1,98 @@
+import { EscapeResult } from '../escape-result';
+import { Query } from '../query/query';
+import { WrapResult } from '../wrap-result';
+import { Operators } from './operators';
+/**
+ * Represents the low level abstraction of query generation that is responsible for the creation of queries themselves.
+ *
+ * Operators are ment to be stateless and held as singleton instances, as they can be shared without any issues.
+ * This library uses the {@link OperatorService} to store the singleton instances, but you can use your own solution,
+ * or instantiate them multiple times if you prefer.
+ *
+ * @typeparam T type of arguments this Operator can generate queries from
+ */
+export declare abstract class Operator<T> {
+    /**
+     * Represents the placeholder "block" in operator display names.
+     */
+    static readonly INPUT_PLACEHOLDER = "";
+    /**
+     * Reserved characters for Elasticsearch queries. These characters can be escaped with a `\` character.
+     */
+    private static readonly ESCAPABLE_CHARACTERS;
+    /**
+     * Reserved characters for Elasticsearch queries. These characters cannot be escaped and must be removed from queries.
+     */
+    private static readonly UNESCAPABLE_CHARACTERS;
+    /**
+     * Determines the arity of the operator, that is the number of arguments/operands it takes.
+     */
+    private readonly _numberOfOperands;
+    /**
+     * The operator symbol that is used to generate the query.
+     */
+    private readonly _operatorSymbols;
+    protected constructor(numberOfOperands: number, operatorSymbols?: string);
+    /**
+     * Escapes all escapable Elasticsearch symbols. Removes all unescapable Elasticsearch symbols.
+     *
+     * For a list of symbols see Elasticsearch's Query string query
+     * [doc]{@link https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-query-string-query.html#_reserved_characters}.
+     * @param input user input that should have special characters escaped
+     * @returns user input with the escapable characters escaped and the unescapable characters removed
+     */
+    static escapeInput(input: string): EscapeResult;
+    /**
+     * Creates a Query string query string literal with the provided arguments.
+     * @param elasticKeyword Elasticsearch index keyword for the field you want to query
+     * @param arg The value that you want to query the property for
+     * @param operator The operator you want to use to query the indexed field. Consult the Elasticsearch's
+     * [documentation]{@link https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-query-string-query.html}
+     * for more information.
+     * @returns combines the input strings by this pattern: `([elasticKeyword]:[operator][arg])`
+     */
+    static query(elasticKeyword: string, arg: string, operator: string): string;
+    /**
+     * Applies the provided function to all keywords and combines the resulting queries with an `OR` operator.
+     * @param elasticKeywords keywords that the function is call on
+     * @param queryConstructor function that generates a `Query` object for each keyword
+     */
+    static forEachKeyword(elasticKeywords: Array<string>, queryConstructor: (keyword: string) => Query): Query;
+    /**
+     * If the value contains a space character, or if `force` is set to `true`.
+     * @param input user input that should be wrapped with double quotes
+     * @param forceWrap if set to `true` the value will be wrapped regardless of it's content
+     */
+    static wrapInputWithQuotes(input: string, forceWrap?: boolean): WrapResult;
+    /**
+     * @returns the arity of the operator.
+     */
+    get numberOfOperands(): number;
+    /**
+     * Simple implementation of query generation. Will not be suitable for all Operator derivatives.
+     *
+     * Escapes the first argument from the `args` array, calls the [query()]{@link Operator#query} function for each `keyword` and combines
+     * the results with an `OR` operator.
+     * @returns query that wos constructed with the given arguments and keywords. Returns an empty query if no arguments are provided.
+     */
+    createQuery(elasticKeywords: Array<string>, args: Array<T>, escapeArgs?: boolean): Query;
+    /**
+     * The name template is used when generating search GUI, and so the arity of the operator should match the number of
+     * {@link INPUT_PLACEHOLDER} constant occurrences in the returned array.
+     *
+     * @returns an array of translation paths that represent the operator name, as it should be displayed to the user.
+     * The {@link INPUT_PLACEHOLDER} constant (or any falsy value) can be used to place visual input placeholder blocks in the
+     * operator name where user input is expected.
+     */
+    abstract getOperatorNameTemplate(): Array<string>;
+    /**
+     * @returns the operator class in a serializable form
+     */
+    abstract serialize(): Operators | string;
+    /**
+     * Checks whether the provided array contains at leas as many arguments, as is the operators number of operands.
+     * Throws an error if not enough arguments is provided.
+     * @param args an array of potential operands
+     */
+    protected checkArgumentsCount(args: Array<any>): void;
+}

package/lib/search/models/operator/operators.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Represents the available {@link Operator} classes in a serializable form.
+ */
+export declare enum Operators {
+    EQUALS = "equals",
+    EQUALS_DATE = "equals_date",
+    EQUALS_DATE_TIME = "equals_date_time",
+    IN_RANGE = "in_range",
+    IN_RANGE_DATE = "in_range_date",
+    IN_RANGE_DATE_TIME = "in_range_date_time",
+    IS_NULL = "is_null",
+    LESS_THAN = "less_than",
+    LESS_THAN_DATE = "less_than_date",
+    LESS_THAN_DATE_TIME = "less_than_date_time",
+    LESS_THAN_EQUAL = "less_than_equal",
+    LESS_THAN_EQUAL_DATE = "less_than_equal_date",
+    LESS_THAN_EQUAL_DATE_TIME = "less_than_equal_date_time",
+    LIKE = "like",
+    MORE_THAN = "more_than",
+    MORE_THAN_DATE = "more_than_date",
+    MORE_THAN_DATE_TIME = "more_than_date_time",
+    MORE_THAN_EQUAL = "more_than_equal",
+    MORE_THAN_EQUAL_DATE = "more_than_equal_date",
+    MORE_THAN_EQUAL_DATE_TIME = "more_than_equal_date_time",
+    NOT_EQUALS = "not_equals",
+    NOT_EQUALS_DATE = "not_equals_date",
+    NOT_EQUALS_DATE_TIME = "not_equals_date_time",
+    SUBSTRING = "substring"
+}

package/lib/search/models/operator/substring.d.ts

@@ -0,0 +1,13 @@
+import { Operator } from './operator';
+import { Query } from '../query/query';
+import { Operators } from './operators';
+/**
+ * Operator that matches if the input is a substring of some value.
+ * Can only be used on fields that are texts and are not indexed as keywords.
+ */
+export declare class Substring extends Operator<string> {
+    constructor();
+    createQuery(elasticKeywords: Array<string>, args: Array<string>): Query;
+    getOperatorNameTemplate(): Array<string>;
+    serialize(): Operators | string;
+}

package/lib/search/models/operator-template-part-type.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Type of a processed operator template part/segment.
+ */
+export declare enum OperatorTemplatePartType {
+    /**
+     * Template segment that represents an input field.
+     */
+    INPUT = "input",
+    /**
+     * Template segment that represents a text display
+     */
+    TEXT = "text"
+}

package/lib/search/models/operator-template-part.d.ts

@@ -0,0 +1,26 @@
+import { OperatorTemplatePartType } from './operator-template-part-type';
+import { FormControl } from '@angular/forms';
+/**
+ * Represents a process operator template part/segment.
+ *
+ * Is used to be iterated over by ngFor to display a combination of text segments and user inputs that together create an operator input GUI
+ */
+export declare class OperatorTemplatePart {
+    id: number;
+    first: boolean;
+    protected _type: OperatorTemplatePartType;
+    protected _content: string | FormControl;
+    /**
+     * The
+     * @param part either the displayed text or a `FormControl` object, that represents the operator template segment.
+     * @param id for ngFor trackBy comparison
+     * @param first whether it is the first input in the template
+     */
+    constructor(part: string | FormControl, id: number, first?: boolean);
+    /**
+     * @returns [TEXT]{@link OperatorTemplatePartType#TEXT} if the segment is a text (content has type `string`),
+     * or [INPUT]{@link OperatorTemplatePartType#INPUT} if the segment is an input field (content has type `FormControl`)
+     */
+    get type(): OperatorTemplatePartType;
+    get content(): string | FormControl;
+}

package/lib/search/models/persistance/filter-metadata-allowed-nets.d.ts

@@ -0,0 +1,14 @@
+import { FilterMetadata } from './filter-metadata';
+/**
+ * The bare minimum of information necessary for the reconstruction of a saved filter
+ */
+export interface FilterMetadataAllowedNets {
+    /**
+     * Allowed nets used to create the filter
+     */
+    allowedNets: Array<string>;
+    /**
+     * Serialized advanced search state of the saved filter
+     */
+    filterMetadata: FilterMetadata;
+}

package/lib/search/models/persistance/filter-metadata.d.ts

@@ -0,0 +1,29 @@
+import { FilterType } from '../../../filter/models/filter-type';
+import { PredicateTreeMetadata } from './generator-metadata';
+/**
+ * Saved filter generated by the {@link AbstractAdvancedSearchComponent}.
+ */
+export interface FilterMetadata {
+    filterType: FilterType;
+    predicateMetadata: PredicateTreeMetadata;
+    /**
+     * Serialized {@link Category} classes, that were available in the saved search component.
+     */
+    searchCategories?: Array<string>;
+    /**
+     * Whether the search categories default to the view the filter will be loaded in should be merged with the saved categories.
+     *
+     * Defaults to a falsy value.
+     *
+     * If falsy, only the categories stored in [searchCategories]{@link FilterMetadata#searchCategories} will be used.
+     */
+    defaultSearchCategories?: boolean;
+    /**
+     * Whether the allowed nets used to generate category metadata can be inherited from frontend providers.
+     *
+     * Defaults to a falsy value.
+     *
+     * If falsy, only the allowed nets stored in the filter data field will be used to generate category metadata.
+     */
+    inheritAllowedNets?: boolean;
+}

package/lib/search/models/persistance/filter-text-segment.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Represents a segment of the extracted filter text
+ */
+export interface FilterTextSegment {
+    /**
+     * The text content
+     *
+     * Should be passed through the translate pipe
+     */
+    segment: string;
+    /**
+     * Whether the segment should be displayed in bold font face
+     */
+    bold?: boolean;
+    /**
+     * Whether the segment should be displayed with uppercase letters
+     */
+    uppercase?: boolean;
+}

package/lib/search/models/persistance/generator-metadata.d.ts

@@ -0,0 +1,44 @@
+import { Categories } from '../category/categories';
+/**
+ * Holds serializable information necessary for recreation of any {@link Category} instance in any internal state.
+ *
+ * Is used to persist search GUI state.
+ */
+export interface CategoryGeneratorMetadata {
+    category: Categories | string;
+    configuration: CategoryMetadataConfiguration;
+    values: Array<unknown>;
+}
+/**
+ * The keys are some configuration options that make sense to the {@link Category} instance that generated
+ * the {@link CategoryGeneratorMetadata} object.
+ *
+ * The values are some serializable data, that the Category needs to restore its state.
+ */
+export interface CategoryMetadataConfiguration {
+    [k: string]: unknown;
+}
+/**
+ * The two nested arrays represent a predicate tree with 3 levels. The root node of the tree is a predicate consisting of a conjunction
+ * (AND) of its subtrees.
+ *
+ * The single array represents a predicate tree with 2 levels. The root node of the tree is a predicate consisting of a disjunction (OR) of
+ * its subtrees.
+ *
+ * The {@link CategoryGeneratorMetadata} represents a predicate tree with 1 level - a leaf node.
+ */
+export declare type GeneratorMetadata = PredicateTreeMetadata | Array<CategoryGeneratorMetadata> | CategoryGeneratorMetadata;
+/**
+ * Serialized [advanced search]{@link AbstractAdvancedSearchComponent} filter predicate tree.
+ *
+ * The nested array represent nested predicate trees with boolean operators.
+ * The structure of the tree mirrors the search component.
+ *
+ * The top level array is a conjunction (AND) of its subtrees.
+ *
+ * The second level array is a disjunction (OR) of the leaves.
+ *
+ * The {@link CategoryGeneratorMetadata} is a leaf node of the predicate tree containing a single query
+ * generated by {@link AbstractSearchPredicateComponent} (and by extension by a {@link Category}).
+ */
+export declare type PredicateTreeMetadata = Array<Array<CategoryGeneratorMetadata>>;

package/lib/search/models/persistance/saved-filter-metadata.d.ts

@@ -0,0 +1,26 @@
+import { Filter } from '../../../filter/models/filter';
+import { Case } from '../../../resources/interface/case';
+import { FilterMetadataAllowedNets } from './filter-metadata-allowed-nets';
+/**
+ * All the necessary data for full reconstruction of a saved filter
+ */
+export interface SavedFilterMetadata extends FilterMetadataAllowedNets {
+    /**
+     * The view ID of the view the filter was created in
+     */
+    originViewId: string;
+    /**
+     * The filter object represented by the provided metadata
+     */
+    filter: Filter;
+    /**
+     * The filter's case object.
+     *
+     * Only present if the filter is loaded. When the filter is saved onle the case id is returned
+     */
+    filterCase?: Case;
+    /**
+     * ID of the filter's case.
+     */
+    filterCaseId: string;
+}

package/lib/search/models/predicate/clause-predicate.d.ts

@@ -0,0 +1,56 @@
+import { Predicate } from './predicate';
+import { Query } from '../query/query';
+import { BooleanOperator } from '../boolean-operator';
+/**
+ * Represents a clause of {@link Predicate}s combined with a {@link BooleanOperator}.
+ */
+export declare class ClausePredicate extends Predicate {
+    protected _operator: BooleanOperator;
+    protected _bracketSubPredicateText: boolean;
+    /**
+     * Stores the {@link Predicate}s that this Predicate combines.
+     */
+    protected _predicates: Array<Predicate>;
+    /**
+     * Stores the resulting query of this Predicate.
+     */
+    protected _query: Query;
+    /**
+     * @param predicates Predicates that should be combined into one
+     * @param _operator Operator that is used to combine the predicates
+     * @param initiallyVisible whether the predicate should be initially displayed or not
+     * @param _bracketSubPredicateText whether the individual sub predicates are wrapped in brackets when a textual representation
+     * is generated
+     */
+    constructor(predicates: Array<Predicate>, _operator: BooleanOperator, initiallyVisible?: boolean, _bracketSubPredicateText?: boolean);
+    get query(): Query;
+    /**
+     * Adds another {@link Predicate} to the clause and updates this {@link Predicate}'s {@link Query}.
+     * @param newPredicate - the Predicate that should be added to the clause
+     * @returns the index of the added Predicate, that can be used to remove it.
+     * Note that removing predicates with a lower index shifts the order of indices.
+     */
+    addPredicate(newPredicate: Predicate): number;
+    /**
+     * Removes the {@link Predicate} at the given `index` from this clause and updates this {@link Predicate}'s {@link Query}.
+     * If the `index` is invalid does nothing.
+     * @param index index of the {@link Predicate} in this clause that should be removed
+     * @returns whether a predicate was removed, or not
+     */
+    removePredicate(index: number): boolean;
+    /**
+     * Sets this predicate and all its sub-predicates to visible.
+     */
+    showAll(): void;
+    /**
+     * Updates the value of the [_query]{@link ClausePredicate#_query} attribute.
+     *
+     * See [combineQueries()]{@link Query#combineQueries} for more information.
+     */
+    protected updateQuery(): void;
+    /**
+     * @returns the `Array` of {@link Query} objects stored within this object's [_predicates]{@link ClausePredicate#_predicates} attribute.
+     */
+    protected get queries(): Array<Query>;
+    private initializeFilterTextSegmentsGenerator;
+}

package/lib/search/models/predicate/editable-clause-predicate-with-generators.d.ts

@@ -0,0 +1,24 @@
+import { EditableClausePredicate } from './editable-clause-predicate';
+import { BooleanOperator } from '../boolean-operator';
+import { Subject } from 'rxjs';
+import { PredicateWithGenerator } from './predicate-with-generator';
+import { Predicate } from './predicate';
+import { Category } from '../category/category';
+export declare class EditableClausePredicateWithGenerators extends EditableClausePredicate {
+    protected _predicates: Map<number, PredicateWithGenerator>;
+    constructor(operator: BooleanOperator, parentNotifier?: Subject<void>, initiallyVisible?: boolean, bracketSubPredicateText?: boolean);
+    addNewClausePredicate(operator: BooleanOperator, initiallyVisible?: boolean): number;
+    addPredicate(predicate: Predicate, initiallyVisible?: boolean): number;
+    /**
+     * Creates a new editable predicate from the provided generator {@link Category} instance,
+     * connects it to the update notifications stream and adds it to the predicate subtree.
+     * @param generator
+     * @param initiallyVisible
+     */
+    addNewPredicateFromGenerator(generator: Category<any>, initiallyVisible?: boolean): number;
+    getPredicateMap(): Map<number, PredicateWithGenerator>;
+    /**
+     * Cleans-up the inner state of this object
+     */
+    destroy(): void;
+}

package/lib/search/models/predicate/editable-clause-predicate.d.ts

@@ -0,0 +1,67 @@
+import { BooleanOperator } from '../boolean-operator';
+import { Subject } from 'rxjs';
+import { IncrementingCounter } from '../../../utility/incrementing-counter';
+import { OnDestroy } from '@angular/core';
+import { Query } from '../query/query';
+import { EditablePredicate } from './editable-predicate';
+import { Predicate } from './predicate';
+/**
+ * A complex, editable `Predicate`. Represents an inner node in the predicate tree, that can process changes of `Query` objects
+ * held by its child nodes. It can notify the parent tree node about changes to the held `Query`.
+ */
+export declare class EditableClausePredicate extends EditablePredicate implements OnDestroy {
+    protected _operator: BooleanOperator;
+    protected _bracketSubPredicateText: boolean;
+    protected _predicates: Map<number, Predicate>;
+    protected _childUpdated$: Subject<void>;
+    protected _childCounter: IncrementingCounter;
+    protected _query: Query;
+    constructor(_operator: BooleanOperator, parentNotifier?: Subject<void>, initiallyVisible?: boolean, _bracketSubPredicateText?: boolean);
+    ngOnDestroy(): void;
+    get query(): Query;
+    show(): void;
+    /**
+     * Shows the predicates with the given ids. Skips ids that don't exist.
+     * @param predicateIds the ids of the predicates that should be shown.
+     */
+    showPredicates(predicateIds: Array<number>): void;
+    /**
+     * Adds new child predicate of type {@link EditableElementaryPredicate}
+     * @param initiallyVisible whether the new predicate should be initially visible
+     */
+    addNewElementaryPredicate(initiallyVisible?: boolean): number;
+    /**
+     * Adds new child predicate of type {@link EditableClausePredicate}
+     * @param operator the operator of the child clause predicate
+     * @param initiallyVisible whether the new predicate should be initially visible
+     */
+    addNewClausePredicate(operator: BooleanOperator, initiallyVisible?: boolean): number;
+    /**
+     * Generates an id for the new predicate, adds it into the map and updates the query
+     *
+     * If you want to add an editable predicate, use one of the other methods, so that this predicate can react to changes.
+     * @param predicate the new predicate
+     */
+    addPredicate(predicate: Predicate): number;
+    removePredicate(id: number): boolean;
+    getPredicateMap(): Map<number, Predicate>;
+    /**
+     * Updates the `Query` and notifies the parent.
+     */
+    protected updateQueryAndNotify(): void;
+    /**
+     * Updates the value of the [_query]{@link ClausePredicate#_query} attribute.
+     *
+     * See [combineQueries()]{@link Query#combineQueries} for more information.
+     */
+    protected updateQuery(): void;
+    /**
+     * @returns the `Array` of {@link Query} objects stored within this object's [_predicates]{@link ClausePredicate#_predicates} attribute.
+     */
+    protected get queries(): Array<Query>;
+    /**
+     * Sets this predicate and all its sub-predicates to visible.
+     */
+    protected showAll(): void;
+    private initializeFilterTextSegmentsGenerator;
+}