@netgrif/components-core 6.0.1

package/lib/search/models/category/case/case-net-attribute-autocomplete-category.d.ts

@@ -0,0 +1,18 @@
+import { NetAttributeAutocompleteCategory } from '../net-attribute-autocomplete-category';
+import { Operator } from '../../operator/operator';
+import { LoggerService } from '../../../../logger/services/logger.service';
+import { OptionalDependencies } from '../../../category-factory/optional-dependencies';
+import { CaseProcess } from './case-process';
+import { Net } from '../../../../process/net';
+import { Category } from '../category';
+import { OperatorService } from '../../../operator-service/operator.service';
+/**
+ * Utility class with the same use as its parent but witch Case search specific methods implemented.
+ */
+export declare abstract class CaseNetAttributeAutocompleteCategory extends NetAttributeAutocompleteCategory {
+    protected _processCategory: CaseProcess;
+    protected constructor(elasticKeywords: Array<string>, allowedOperators: Array<Operator<any>>, translationPath: string, log: LoggerService, operatorService: OperatorService, optionalDependencies: OptionalDependencies);
+    destroy(): void;
+    protected getProcessCategory(): Category<Array<string>>;
+    protected getPetriNetIdentifier(net: Net): string;
+}

package/lib/search/models/category/case/case-process.d.ts

@@ -0,0 +1,27 @@
+import { Query } from '../../query/query';
+import { OperatorService } from '../../../operator-service/operator.service';
+import { LoggerService } from '../../../../logger/services/logger.service';
+import { OptionalDependencies } from '../../../category-factory/optional-dependencies';
+import { NoConfigurationAutocompleteCategory } from '../no-configuration-autocomplete-category';
+import { Categories } from '../categories';
+export declare class CaseProcess extends NoConfigurationAutocompleteCategory<string> {
+    protected _optionalDependencies: OptionalDependencies;
+    private static readonly _i18n;
+    protected _uniqueOptionsMap: Map<string, Set<string>>;
+    private _allowedNetsSub;
+    private _destroyed;
+    constructor(operators: OperatorService, logger: LoggerService, _optionalDependencies: OptionalDependencies);
+    destroy(): void;
+    protected createOptions(): void;
+    /**
+     * Checks whether the provided option is unique and updates the list of unique options with it.
+     * @param key autocomplete option key
+     * @param value autocomplete option value
+     * @returns `true` if the option has not yet been checked as unique. `false` if the option has been checked before.
+     */
+    protected isUniqueOption(key: string, value: string): boolean;
+    protected generateQuery(userInput: Array<Array<string>>): Query;
+    get inputPlaceholder(): string;
+    duplicate(): CaseProcess;
+    serializeClass(): Categories | string;
+}

package/lib/search/models/category/case/case-role.d.ts

@@ -0,0 +1,15 @@
+import { OperatorService } from '../../../operator-service/operator.service';
+import { LoggerService } from '../../../../logger/services/logger.service';
+import { OptionalDependencies } from '../../../category-factory/optional-dependencies';
+import { Net } from '../../../../process/net';
+import { NameIdPair } from '../name-id-pair';
+import { CaseNetAttributeAutocompleteCategory } from './case-net-attribute-autocomplete-category';
+import { Categories } from '../categories';
+export declare class CaseRole extends CaseNetAttributeAutocompleteCategory {
+    private static readonly _i18n;
+    constructor(operators: OperatorService, logger: LoggerService, optionalDependencies: OptionalDependencies);
+    protected extractAttributes(petriNet: Net): Array<NameIdPair>;
+    get inputPlaceholder(): string;
+    duplicate(): CaseRole;
+    serializeClass(): Categories | string;
+}

package/lib/search/models/category/case/case-search.enum.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Contains the identifiers of the queried elastic search indices.
+ */
+export declare enum CaseSearch {
+    CREATION_DATE = "creationDateSortable",
+    PROCESS_IDENTIFIER = "processIdentifier",
+    TASK_ID = "taskIds",
+    TITLE = "title",
+    VISUAL_ID = "visualId",
+    ENABLED_ROLES = "enabledRoles",
+    AUTHOR = "author",
+    STRING_ID = "stringId"
+}

package/lib/search/models/category/case/case-simple-dataset.d.ts

@@ -0,0 +1,58 @@
+import { OperatorService } from '../../../operator-service/operator.service';
+import { LoggerService } from '../../../../logger/services/logger.service';
+import { Query } from '../../query/query';
+import { Operator } from '../../operator/operator';
+import { CaseProcess } from './case-process';
+import { OptionalDependencies } from '../../../category-factory/optional-dependencies';
+import { NoConfigurationCategory } from '../no-configuration-category';
+import { CaseDataset } from './case-dataset';
+import { Categories } from '../categories';
+import { CategoryGeneratorMetadata } from '../../persistance/generator-metadata';
+import { Observable } from 'rxjs';
+/**
+ * This class aims to be a simpler more limited version of the {@link CaseDataset} {@link Category} implementation.
+ *
+ * It can only generate "equality" queries for a single field. The category must be configured before it can be used to generate queries.
+ *
+ * This category cannot be serialized. If you want to preserve this category's state convert it to {@link CaseDataset}
+ * with the [transformToCaseDataset()]{@link CaseSimpleDataset#transformToCaseDataset} method and serialize the result.
+ *
+ * See [configure]{@link CaseSimpleDataset#configure} for more information.
+ */
+export declare class CaseSimpleDataset extends NoConfigurationCategory<string> {
+    protected _optionalDependencies: OptionalDependencies;
+    private static readonly _i18n;
+    protected _fieldId: string;
+    protected _fieldType: string;
+    protected _netIdentifiers: Array<string>;
+    protected _elasticKeyword: string;
+    protected _processCategory: CaseProcess;
+    constructor(operators: OperatorService, logger: LoggerService, _optionalDependencies: OptionalDependencies);
+    destroy(): void;
+    get inputPlaceholder(): string;
+    configure(fieldId: string, fieldType: string, netIdentifiers: Array<string>): void;
+    protected resolveElasticKeyword(): void;
+    protected get elasticKeywords(): Array<string>;
+    get selectedOperator(): Operator<any>;
+    duplicate(): CaseSimpleDataset;
+    /**
+     * Creates a {@link CaseDataset} instance and configures it so, that the query it generates targets
+     * the selected field, uses the default operator and its operands are what the user provided.
+     *
+     * @param fieldType the type of the field that should be targeted by the transformed Category
+     * @param fieldTitle the title of the field that should be targeted by the transformed Category
+     * @param userInput the operands for the queried field
+     * @returns a new {@link CaseDataset} configured with the provided values
+     */
+    transformToCaseDataset(fieldType: string, fieldTitle: string, userInput: Array<any>): CaseDataset;
+    protected generateQuery(userInput: Array<unknown>): Query;
+    serializeClass(): Categories | string;
+    /**
+     * Serialization is not supported. Throws an error.
+     */
+    createMetadata(): never;
+    /**
+     * Deserialization is not supported. Throws an error.
+     */
+    loadFromMetadata(metadata: CategoryGeneratorMetadata): Observable<void>;
+}

package/lib/search/models/category/case/case-string-id.d.ts

@@ -0,0 +1,11 @@
+import { OperatorService } from '../../../operator-service/operator.service';
+import { LoggerService } from '../../../../logger/services/logger.service';
+import { NoConfigurationCategory } from '../no-configuration-category';
+import { Categories } from '../categories';
+export declare class CaseStringId extends NoConfigurationCategory<string> {
+    private static readonly _i18n;
+    constructor(operators: OperatorService, logger: LoggerService);
+    get inputPlaceholder(): string;
+    duplicate(): CaseStringId;
+    serializeClass(): Categories | string;
+}

package/lib/search/models/category/case/case-task.d.ts

@@ -0,0 +1,15 @@
+import { OperatorService } from '../../../operator-service/operator.service';
+import { LoggerService } from '../../../../logger/services/logger.service';
+import { OptionalDependencies } from '../../../category-factory/optional-dependencies';
+import { NameIdPair } from '../name-id-pair';
+import { Net } from '../../../../process/net';
+import { CaseNetAttributeAutocompleteCategory } from './case-net-attribute-autocomplete-category';
+import { Categories } from '../categories';
+export declare class CaseTask extends CaseNetAttributeAutocompleteCategory {
+    private static readonly _i18n;
+    constructor(operators: OperatorService, logger: LoggerService, optionalDependencies: OptionalDependencies);
+    protected extractAttributes(petriNet: Net): Array<NameIdPair>;
+    get inputPlaceholder(): string;
+    duplicate(): CaseTask;
+    serializeClass(): Categories | string;
+}

package/lib/search/models/category/case/case-title.d.ts

@@ -0,0 +1,11 @@
+import { OperatorService } from '../../../operator-service/operator.service';
+import { LoggerService } from '../../../../logger/services/logger.service';
+import { NoConfigurationCategory } from '../no-configuration-category';
+import { Categories } from '../categories';
+export declare class CaseTitle extends NoConfigurationCategory<string> {
+    private static readonly _i18n;
+    constructor(operators: OperatorService, logger: LoggerService);
+    get inputPlaceholder(): string;
+    duplicate(): CaseTitle;
+    serializeClass(): Categories | string;
+}

package/lib/search/models/category/case/case-visual-id.d.ts

@@ -0,0 +1,11 @@
+import { OperatorService } from '../../../operator-service/operator.service';
+import { LoggerService } from '../../../../logger/services/logger.service';
+import { NoConfigurationCategory } from '../no-configuration-category';
+import { Categories } from '../categories';
+export declare class CaseVisualId extends NoConfigurationCategory<string> {
+    private static readonly _i18n;
+    constructor(operators: OperatorService, logger: LoggerService);
+    get inputPlaceholder(): string;
+    duplicate(): CaseVisualId;
+    serializeClass(): Categories | string;
+}

package/lib/search/models/category/categories.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Represents the available {@link Category} classes in a serializable form.
+ */
+export declare enum Categories {
+    CASE_AUTHOR = "case_author",
+    CASE_CREATION_DATE = "case_creation_date",
+    CASE_CREATION_DATE_TIME = "case_creation_date_time",
+    CASE_DATASET = "case_dataset",
+    CASE_PROCESS = "case_process",
+    CASE_ROLE = "case_role",
+    CASE_SIMPLE_DATASET = "case_simple_dataset",
+    CASE_TASK = "case_task",
+    CASE_TITLE = "case_title",
+    CASE_VISUAL_ID = "case_visual_id",
+    CASE_STRING_ID = "case_string_id",
+    TASK_ASSIGNEE = "task_assignee",
+    TASK_PROCESS = "task_process",
+    TASK_ROLE = "task_role",
+    TASK_TASK = "task_task"
+}

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

@@ -0,0 +1,363 @@
+import { Operator } from '../operator/operator';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { Query } from '../query/query';
+import { ElementaryPredicate } from '../predicate/elementary-predicate';
+import { SearchInputType } from './search-input-type';
+import { FormControl } from '@angular/forms';
+import { BehaviorSubject, Observable, ReplaySubject } from 'rxjs';
+import { OperatorTemplatePart } from '../operator-template-part';
+import { IncrementingCounter } from '../../../utility/incrementing-counter';
+import { ConfigurationInput } from '../configuration-input';
+import { CategoryGeneratorMetadata, CategoryMetadataConfiguration } from '../persistance/generator-metadata';
+import { Categories } from './categories';
+import { OperatorService } from '../../operator-service/operator.service';
+import { FilterTextSegment } from '../persistance/filter-text-segment';
+/**
+ * The top level of abstraction in search query generation. Represents a set of indexed fields that can be searched.
+ * Encapsulates the the state and logic of the query construction process.
+ *
+ * As opposed to {@link Operator}s Categories are not stateless and shouldn't be shared.
+ * A single Category instance is capable of holding the state of one {@link EditablePredicate},
+ * or can be used as a builder to form an unlimited amount of [ElementaryPredicates]{@link ElementaryPredicate}.
+ *
+ * You can use {@link CategoryFactory} to get instances of Category classes.
+ * Alternatively you can use the [clone()]{@Link Category#clone} method to duplicate an existing instance.
+ *
+ * If you want to make your own Category class you have to make sure that the constructor takes {@link OperatorService} as it's first
+ * argument and {@link LoggerService} as it's second argument. Alternatively you can make your own implementation of the
+ * {@link CategoryFactory} so, that your style of constructors is supported.
+ *
+ * @typeparam T type of objects the category expects to generate queries from
+ */
+export declare abstract class Category<T> {
+    protected readonly _elasticKeywords: Array<string>;
+    protected readonly _allowedOperators: Array<Operator<any>>;
+    readonly translationPath: string;
+    protected readonly _inputType: SearchInputType;
+    protected _log: LoggerService;
+    protected _operatorService: OperatorService;
+    /**
+     * The {@link CategoryMetadataConfiguration} key for this Category's {@link Operator}
+     */
+    protected static readonly OPERATOR_METADATA = "operator";
+    /**
+     * Contains the `FormControl` object that is used to drive the operator selection.
+     *
+     * The category can subscribe to it if it wishes to react to the selection change by the user.
+     */
+    protected _operatorFormControl: FormControl;
+    /**
+     * Stores the `FormControl` objects that are pushed into the observable when the number of operands changes.
+     */
+    protected _operandsFormControls: Array<FormControl>;
+    /**
+     * Contains the `FormControl` objects that can be used to input search arguments.
+     */
+    protected _operandsFormControls$: ReplaySubject<Array<FormControl> | undefined>;
+    /**
+     * Contains the operator template parts that make up the operands GUI.
+     */
+    protected _operatorTemplate$: BehaviorSubject<Array<OperatorTemplatePart> | undefined>;
+    /**
+     * Generates IDs for template parts supplied to ng for.
+     */
+    protected _trackByIdGenerator: IncrementingCounter;
+    /**
+     * Emit a new `Predicate` if the `Category` is in a state that it can be created.
+     * Emits `undefined` if the `Category` is not in such state.
+     */
+    protected _generatedPredicate$: BehaviorSubject<ElementaryPredicate | undefined>;
+    /**
+     * Utility variable that can be used as value for the [configurationInputs$]{@link Category#configurationInputs$} `Observable`.
+     */
+    protected readonly _OPERATOR_INPUT: ConfigurationInput;
+    /**
+     * The constructor fills the values of all protected fields and then calls the [initializeCategory()]{@link Category#initializeCategory}
+     * method. If you want to override the category creation behavior override that method.
+     *
+     * @param _elasticKeywords Elasticsearch keywords that should be queried by queries generated with this category
+     * @param _allowedOperators Operators that can be used to generated queries on the above keywords
+     * @param translationPath path to the translation string
+     * @param _inputType input field type that should be used to enter operator arguments for this category
+     * @param _log used to record information about incorrect use of this class
+     * @param _operatorService used to resolve serialized operators during deserialization
+     */
+    protected constructor(_elasticKeywords: Array<string>, _allowedOperators: Array<Operator<any>>, translationPath: string, _inputType: SearchInputType, _log: LoggerService, _operatorService: OperatorService);
+    /**
+     * Cleans up the internal state of the object before its destruction.
+     *
+     * The developer must call this method at an appropriate moment, as this object cannot hook into the Angular lifecycle.
+     */
+    destroy(): void;
+    /**
+     * Configuration input represent the steps that are necessary to configure the category.
+     * The last input must always be of type [OPERATOR]{@link SearchInputType#OPERATOR}.
+     * Selecting the operator completes the configuration of the category and the arguments inputs
+     * (based on category input type and operator arity) are displayed.
+     *
+     * Beware that while most categories always return the same constant it must not always be the case.
+     *
+     * @returns the required input type for configuration steps of this category
+     */
+    abstract get configurationInputs$(): Observable<Array<ConfigurationInput>>;
+    /**
+     * If you use the `Category` class as a sort of PredicateBuilder, then you want to use the
+     * [generatePredicate()]{@link Category#generatePredicate} method instead.
+     *
+     * This stream publishes either a new `Predicate` object or `undefined` based on changes to the `FormControls` that are
+     * managed by this class. If (based on user input) the `Category` reaches a state when construction of a `Predicate` is possible
+     * it will emit this `Predicate`. If it reaches a state when the `Predicate` can not longer be created `undefined` is emitted.
+     */
+    get generatedPredicate$(): Observable<ElementaryPredicate | undefined>;
+    /**
+     * Returns the {@link Predicate} currently generated by the Category.
+     *
+     * For more information see [generatedPredicate$]{@link Category#generatedPredicate$}.
+     */
+    get generatedPredicate(): ElementaryPredicate | undefined;
+    /**
+     * Beware that while most categories always return the same constant it is not a requirement.
+     * An example for such behavior is the {@link CaseDataset} category, where the argument input type depends
+     * on the selected data field type.
+     *
+     * @returns the required input type for arguments for this category
+     */
+    get inputType(): SearchInputType;
+    /**
+     * @returns the set of Operators that can be used with this category. Iteration order determines the display order.
+     */
+    get allowedOperators(): Array<Operator<any>>;
+    /**
+     * @returns the currently selected operator or `undefined` if no operator is selected.
+     */
+    get selectedOperator(): Operator<any>;
+    /**
+     * @returns an array of `FormControl` objects that contains as many controls as is the arity of the selected operator.
+     * Calling this method multiple times will return the same `FormControl` instances.
+     * When no operator is selected `undefined` is emitted.
+     */
+    get operandsFormControls$(): Observable<Array<FormControl> | undefined>;
+    /**
+     * A new value is emitted whenever the selected operator changes. `undefined` is emitted if no operator is selected.
+     *
+     * @returns [operators template]{@link Operator#getOperatorNameTemplate} in processed form fit for GUI rendering
+     */
+    get operatorTemplate$(): Observable<Array<OperatorTemplatePart> | undefined>;
+    /**
+     * @returns whether the category is fully configured and represents a valid predicate or not
+     */
+    get providesPredicate(): boolean;
+    /**
+     * @returns the set of Elasticsearch keywords that should be queried by queries generated with this category.
+     * The method can be overridden if the keywords are not static and change based on some additional selection (eg. Data fields)
+     */
+    protected get elasticKeywords(): Array<string>;
+    /**
+     * @returns the arity of the selected operator. Throws an error if no operator is selected.
+     */
+    protected get selectedOperatorArity(): number;
+    /**
+     * Changes the state of the Category. Category can create queries when an {@link Operator} is selected.
+     *
+     * This method is useful if you want to use the Category class as predicate builder.
+     *
+     * @param operatorIndex index in the [allowedOperators]{@link Category#allowedOperators} array of the {@link Operator} that
+     * should be selected
+     */
+    selectOperator(operatorIndex: number): void;
+    /**
+     * Changes the state of the Category and generates a query if all necessary operands were set.
+     *
+     * If you are using the category as a builder. Consider using the [generatePredicate()]{@link Category#generatePredicate}
+     * method instead.
+     *
+     * @param userInput values entered by the user. The length of the array should match the
+     * [arity]{@link Operator#_numberOfOperands} of the selected Operator.
+     */
+    setOperands(userInput: Array<T>): void;
+    /**
+     * Resets the state of the Category, deselecting any selected category and removing other state
+     * information if the Category defines them.
+     *
+     * This method can be used to reset the state of the category after each predicate constructed,
+     * effectively turning the category instance into a predicate builder.
+     */
+    reset(): void;
+    /**
+     * Calls the [createQuery]{@link Operator#createQuery} method on the selected Operator.
+     *
+     * Throws an Error if no Operator is selected.
+     *
+     * Override this method if the query should be generated in some other way.
+     * @param userInput values entered by the user. The length of the array should match the
+     * [arity]{@link Operator#_numberOfOperands} of the selected Operator.
+     * @returns the Query generated by the selected Operator
+     */
+    protected generateQuery(userInput: Array<T>): Query;
+    /**
+     * Calls the [generateQuery]{@link Category#generateQuery} method and creates an {@link ElementaryPredicate} with the result.
+     * @param userInput values entered by the user. The length of the array should match the
+     * [arity]{@link Operator#_numberOfOperands} of the selected Operator.
+     * @returns Predicate with {@link Query} generated by this object's [generateQuery]{@link Category#generateQuery} method
+     */
+    generatePredicate(userInput: Array<T>): ElementaryPredicate;
+    /**
+     * Selects the default operator that should be used for query generation, when no Operator selection is provided to the user.
+     *
+     * The default implementation selects the first operator in the [_allowedOperators]{@link Category#allowedOperators} array.
+     *
+     * See [selectOperator()]{@link Category#selectOperator} for more information.
+     */
+    selectDefaultOperator(): void;
+    /**
+     * @returns the translation string path for the text that should be displayed in the input placeholder
+     */
+    abstract get inputPlaceholder(): string;
+    /**
+     * @returns whether the category text should be rendered with bold text when selected
+     */
+    abstract get displayBold(): boolean;
+    /**
+     * @returns whether an operator is currently selected or not.
+     */
+    isOperatorSelected(): boolean;
+    /**
+     * Deselects the currently selected operator (if any)
+     */
+    clearOperatorSelection(): void;
+    /**
+     * Creates a duplicate of the current category object. Note that a duplicate is NOT a clone.
+     * The state of the returned category is not necessarily the same as the state of this category.
+     *
+     * @returns a category instance of the same type as this category in its initial state.
+     */
+    abstract duplicate(): Category<T>;
+    /**
+     * Provides the necessary information for the serialisation of this category's state.
+     *
+     * Not every state must be preservable. The default library implementation supports only the preservation of the final state when the
+     * Category is generating a predicate object.
+     *
+     * @returns an object containing all the necessary information for the reconstruction of this category's state,
+     * barring information about allowed nets. Returns `undefined` if the category is not in a state that generates a predicate.
+     * See [providesPredicate()]{@link Category#providesPredicate}.
+     */
+    createMetadata(): CategoryGeneratorMetadata | undefined;
+    /**
+     * Restores the saved state contained in the provided metadata.
+     *
+     * @param metadata the metadata created by calling the [createMetadata()]{@link Category#createMetadata} method
+     *
+     * @returns an Observable. When the Observable emits the category has finished restoring its state.
+     */
+    loadFromMetadata(metadata: CategoryGeneratorMetadata): Observable<void>;
+    /**
+     * This method is calle in the constructor. Apart from calling this method, the constructor only creates instances to fill the protected
+     * fields of this class.
+     *
+     * The default implementation manages creation of operand `FormControl` instances and manages subscriptions to them.
+     *
+     * You can override this method to change the initialization of your category without having to rewrite the base
+     * constructor from scratch.
+     */
+    protected initializeCategory(): void;
+    /**
+     * The method that is (by default) called whenever an operand `FormControl` changes its value.
+     *
+     * @param operandIndex the index of the operand that changed its value
+     */
+    protected operandValueChanges(operandIndex: number): void;
+    /**
+     * @returns the category class in a serializable form
+     *
+     * @deprecated in 5.6.0 - Category serialisation should be done by utilising the {@link CategoryResolverService} instead
+     */
+    abstract serializeClass(): Categories | string;
+    /**
+     * The default implementation serializes only the operator.
+     * If the category contains additional configuration, this method must be extended.
+     *
+     * @returns an object containing all the necessary information for the reconstruction of the configuration of this category instance
+     */
+    protected createMetadataConfiguration(): CategoryMetadataConfiguration;
+    /**
+     * The default implementation returns the value of all operand form control objects up to the current number of operands.
+     * To serialize value of each operand the [serializeOperandValue()]{@link Category#serializeOperandValue} method is used.
+     *
+     * If the values used by this category are not serializable, then either this method, or the `serializeOperandValue` method,
+     * must be overridden.
+     *
+     * @returns an array containing values input by the user in a serializable form
+     */
+    protected createMetadataValues(): Array<unknown>;
+    /**
+     * @param valueFormControl FormControl object of one operand
+     * @returns the value of the operand in a serialized form. The default implementation returns the FormControls `value` attribute.
+     */
+    protected serializeOperandValue(valueFormControl: FormControl): unknown;
+    /**
+     * Restored the saved configuration from the metadata created by the
+     * [createMetadataConfiguration()]{@link Category#createMetadataConfiguration} method.
+     *
+     * The default implementation restores only the saved operator.
+     *
+     * If the Category overrides the serialization method, it must override this method as well.
+     *
+     * @param configuration the serialized configuration
+     *
+     * @returns an Observable. When the Observable emits the category has finished loading its configuration.
+     */
+    protected loadConfigurationFromMetadata(configuration: CategoryMetadataConfiguration): Observable<void>;
+    /**
+     * The default implementation sets the provided values into this Category's operand form controls.
+     *
+     * An operator must be set before calling this method! Otherwise an error will be thrown.
+     *
+     * If the number of values doesn't match the arity of the selected operator an error will be thrown!
+     *
+     * If this Category overrides the [serializeOperandValue()]{@link Category#serializeOperandValue}, it must also
+     * override its deserialization counterpart - [deserializeOperandValue()]{@link #Category#deserializeOperandValue}!
+     *
+     * @param values the serialized values that should be loaded into this Category instance
+     *
+     * @returns an Observable. When the Observable emits the category has finished loading its values.
+     */
+    protected loadValuesFromMetadata(values: Array<unknown>): Observable<void>;
+    /**
+     * @param value the serialized output of the [serializeOperandValue()]{@link Category#serializeOperandValue} method
+     * @returns an `Observable` that emits the deserialized value, that can be set as FormControl value and then completes
+     *
+     * This method may throw na error if the value cannot be deserialized.
+     */
+    protected deserializeOperandValue(value: unknown): Observable<any>;
+    /**
+     * @param newValue the value of the `FormControl` object that we want to test
+     * @returns `true` if the newly selected value is a valid value, `false` otherwise.
+     */
+    protected abstract isOperandValueSelected(newValue: any): boolean;
+    /**
+     * Performs a transformation of the `FormControl` value before passing it into the selected `Operator` for query generation.
+     * It is mostly useful only for AutocompleteCategories, where the selected value of the FormControl is an object.
+     *
+     * The default implementation performs an identity transformation - returns the input.
+     * @param value the FormControlValue
+     * @returns the value used for query generation
+     */
+    protected transformCategoryValue(value: any): T;
+    /**
+     * @returns an Array containing text segments representing the content of the predicate generated by this category
+     */
+    createFilterTextSegments(): Array<FilterTextSegment>;
+    /**
+     * @returns an Array containing text segments representing the configuration inputs of this category
+     */
+    protected abstract createConfigurationFilterTextSegments(): Array<FilterTextSegment>;
+    /**
+     * @returns an Array containing text segments representing the operators with operands of this category
+     */
+    protected createOperatorFilterTextSegments(): Array<FilterTextSegment>;
+    /**
+     * @returns filter text segment representing the operand value at the specified index
+     */
+    protected createOperandFilterTextSegment(operandIndex: number): FilterTextSegment;
+}

package/lib/search/models/category/name-id-pair.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Interface used for extraction of net attributes by {@link NetAttributeAutocompleteCategory} implementations.
+ */
+export interface NameIdPair {
+    /**
+     * Display name of the attribute
+     */
+    name: string;
+    /**
+     * Unique id of the attribute, that is used for searching
+     */
+    id: string;
+}

package/lib/search/models/category/net-attribute-autocomplete-category.d.ts

@@ -0,0 +1,55 @@
+import { NoConfigurationAutocompleteCategory } from './no-configuration-autocomplete-category';
+import { NetAttributePair } from './net-attribute-pair';
+import { Operator } from '../operator/operator';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { Net } from '../../../process/net';
+import { NameIdPair } from './name-id-pair';
+import { Query } from '../query/query';
+import { Category } from './category';
+import { OperatorService } from '../../operator-service/operator.service';
+import { OptionalDependencies } from '../../category-factory/optional-dependencies';
+/**
+ * A utility class for autocomplete search categories that are net specific, such as searching by roles, or tasks.
+ *
+ * The generated queries combine the ids of the selected attribute with the net id, so that no unexpected results are found.
+ */
+export declare abstract class NetAttributeAutocompleteCategory extends NoConfigurationAutocompleteCategory<NetAttributePair> {
+    protected _optionalDependencies: OptionalDependencies;
+    private _allowedNetsSub;
+    private _destroyed;
+    protected constructor(elasticKeywords: Array<string>, allowedOperators: Array<Operator<any>>, translationPath: string, log: LoggerService, operatorService: OperatorService, _optionalDependencies: OptionalDependencies);
+    destroy(): void;
+    protected createOptions(): void;
+    /**
+     * This method should extract the relevant attribute display names and ids.
+     * They will be automatically paired with the net id for further use by this search category.
+     *
+     * @param petriNet Petri net that should have its search relevant attributes extracted
+     * @returns an array of the attribute display name and id pairs
+     */
+    protected abstract extractAttributes(petriNet: Net): Array<NameIdPair>;
+    /**
+     *  This method should return the appropriate category instance for searching of processes, so that process queries
+     *  can be generated with it.
+     *
+     *  Currently it can be either the {@link CaseProcess} or the {@link TaskProcess} category class.
+     */
+    protected abstract getProcessCategory(): Category<Array<string>>;
+    /**
+     * This method should return the appropriate identifier of a PetriNet.
+     *
+     * Categories that query cases should use process identifier.
+     *
+     * Categories that query tasks should use stringId.
+     *
+     * @param net PetriNet whose identifier should be extracted
+     */
+    protected abstract getPetriNetIdentifier(net: Net): string;
+    /**
+     * Generates the query as a combination of the selected attribute pairs.
+     * Each attribute is ANDed with its net id and ORed with other attributes.
+     * @param userInput inputs selected by the user in each of the operand input fields
+     * @returns the Query generated by the selected Operator
+     */
+    protected generateQuery(userInput: Array<Array<NetAttributePair>>): Query;
+}