@netgrif/components-core 6.0.1

package/lib/search/search-operand-input-component/abstract-search-operand-input.component.d.ts

@@ -0,0 +1,38 @@
+import { ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { SearchInputType } from '../models/category/search-input-type';
+import { Observable } from 'rxjs';
+import { SearchAutocompleteOption } from '../models/category/search-autocomplete-option';
+export declare abstract class AbstractSearchOperandInputComponent implements OnInit, OnDestroy {
+    /**
+     * Whether the contents displayed in this component can be edited by the user or not.
+     *
+     * Defaults to `true`
+     */
+    editable: boolean;
+    inputFormControl: FormControl;
+    inputType: SearchInputType;
+    first: boolean;
+    /**
+     * Only if the input is of type [AUTOCOMPLETE{@link SearchInputType#AUTOCOMPLETE}
+     */
+    filterOptionsFunction: (userInput: Observable<string>) => Observable<Array<SearchAutocompleteOption<unknown>>>;
+    protected _inputConfirmed: boolean;
+    private _filteredOptions$;
+    private _autocompleteChange;
+    private _initialExpansion;
+    renderSelection: (selection: SearchAutocompleteOption<unknown>) => string;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get filteredOptions$(): Observable<Array<SearchAutocompleteOption<unknown>>>;
+    get isInputFilled(): boolean;
+    set categoryInput(input: ElementRef<HTMLInputElement>);
+    confirmInput(): void;
+    editInput(): void;
+    /**
+     * Autocomplete `displayWith` function
+     * @param selection the selected option
+     */
+    protected _renderSelection(selection: SearchAutocompleteOption<unknown>): string;
+    protected isInputValueSet(): boolean;
+}

package/lib/search/search-predicate-component/abstract-search-predicate.component.d.ts

@@ -0,0 +1,64 @@
+import { OnDestroy, OnInit, Type } from '@angular/core';
+import { Subject, Subscription } from 'rxjs';
+import { Category } from '../models/category/category';
+import { SearchAutocompleteOption } from '../models/category/search-autocomplete-option';
+import { ElementaryPredicate } from '../models/predicate/elementary-predicate';
+import { LoggerService } from '../../logger/services/logger.service';
+import { MatSelect } from '@angular/material/select';
+import { EditableElementaryPredicate } from '../models/predicate/editable-elementary-predicate';
+import { AdvancedSearchComponentInitializationService } from '../advanced-search-component-initialization-service/advanced-search-component-initialization.service';
+import { CategoryFactory } from '../category-factory/category-factory';
+/**
+ * Is responsible for the interactive creation of a single {@link ElementaryPredicate} object instance.
+ */
+export declare abstract class AbstractSearchPredicateComponent implements OnInit, OnDestroy {
+    private _naeSearchCategories;
+    protected _logger: LoggerService;
+    protected _initializationService: AdvancedSearchComponentInitializationService;
+    protected _categoryFactory: CategoryFactory;
+    /**
+     * Whether the contents displayed in this component can be edited by the user or not.
+     *
+     * Defaults to `true`
+     */
+    editable: boolean;
+    predicate: EditableElementaryPredicate;
+    predicateId: number;
+    remove$: Subject<number>;
+    /**
+     * Optional generator with prefilled values. Can be used to add prefilled predicate components to the search GUI.
+     */
+    generator: Category<any> | undefined;
+    protected _selectedCategory: Category<any>;
+    protected _predicateChange: Subscription;
+    protected _searchCategories: Array<Category<any>>;
+    protected constructor(_naeSearchCategories: Array<Type<Category<any>>>, _logger: LoggerService, _initializationService: AdvancedSearchComponentInitializationService, _categoryFactory: CategoryFactory);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get searchCategories(): Array<Category<any>>;
+    set categoryInput(input: MatSelect);
+    get selectedCategory(): Category<any>;
+    set selectedCategory(newCategory: Category<any>);
+    /**
+     * Lambda that is used to preserve `this` reference in HTML binding.
+     *
+     * See [_renderSelection()]{@link AbstractSearchPredicateComponent#_renderSelection} for information about the transform function.
+     * @param option the {@link SearchAutocompleteOption} object that was selected in the autocomplete list.
+     */
+    renderSelection: (option: SearchAutocompleteOption<unknown>) => string;
+    remove(): void;
+    categoryChanged(newCategory: Category<any>): void;
+    clearCategorySelection(): void;
+    /**
+     * Transforms a {@link SearchAutocompleteOption} object into it's name.
+     * Used for displaying user selection in the input field, when an autocomplete option is selected.
+     * @param option the object we want to transform. It might not exist if user input doesn't match any autocomplete option
+     * @returns option name if it exists, empty string otherwise
+     */
+    protected _renderSelection(option: SearchAutocompleteOption<unknown>): string;
+    /**
+     * Notifies the `EditableElementaryPredicate` about changes to the predicate generated by the selected `Category`.
+     * @param newPredicate predicate generated by the selected `Category`
+     */
+    protected processPredicateChange(newPredicate: ElementaryPredicate | undefined): void;
+}

package/lib/search/search-service/search.service.d.ts

@@ -0,0 +1,182 @@
+import { OnDestroy } from '@angular/core';
+import { Filter } from '../../filter/models/filter';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { Predicate } from '../models/predicate/predicate';
+import { SimpleFilter } from '../../filter/models/simple-filter';
+import { PredicateRemovalEvent } from '../models/predicate-removal-event';
+import { Query } from '../models/query/query';
+import { EditableClausePredicateWithGenerators } from '../models/predicate/editable-clause-predicate-with-generators';
+import { Category } from '../models/category/category';
+import { PredicateTreeMetadata } from '../models/persistance/generator-metadata';
+import { BaseFilter } from '../models/base-filter';
+import { LoggerService } from '../../logger/services/logger.service';
+import { CategoryFactory } from '../category-factory/category-factory';
+import { FilterType } from '../../filter/models/filter-type';
+import { LoadingEmitter } from '../../utility/loading-emitter';
+import { FilterMetadata } from '../models/persistance/filter-metadata';
+import { FilterTextSegment } from '../models/persistance/filter-text-segment';
+/**
+ * Holds information about the filter that is currently applied to the view component, that provides this services.
+ */
+export declare class SearchService implements OnDestroy {
+    protected _log: LoggerService;
+    protected _categoryFactory: CategoryFactory;
+    /**
+     * {@link Filter} that is applied to the view, even if the user doesn't search anything.
+     */
+    protected _baseFilter: Filter;
+    /**
+     * Holds the {@link Predicate} tree root for user search queries.
+     */
+    protected _rootPredicate: EditableClausePredicateWithGenerators;
+    /**
+     * Holds the {@link Filter} that is currently being applied to the view.
+     */
+    protected _activeFilter: BehaviorSubject<Filter>;
+    /**
+     * Holds the full text {@link Filter} if set, `undefined` otherwise.
+     */
+    protected _fullTextFilter: SimpleFilter | undefined;
+    /**
+     * The index of a removed {@link Predicate} is emmited into this stream
+     */
+    protected _predicateRemoved$: Subject<PredicateRemovalEvent>;
+    protected _loadingFromMetadata$: LoadingEmitter;
+    /**
+     * The `rootPredicate` uses this stream to notify the search service about changes to the held query
+     */
+    private readonly _predicateQueryChanged$;
+    private readonly subFilter;
+    /**
+     * The {@link Predicate} tree root uses an [AND]{@link BooleanOperator#AND} operator to combine the Predicates.
+     * @param _log {@link LoggerService}
+     * @param _categoryFactory a {@link CategoryFactory} instance. This dependency is optional.
+     * It is required if we want to load predicate filter from saved metadata
+     * @param baseFilter Filter that should be applied to the view when no searching is being performed.
+     * Injected trough the {@link NAE_BASE_FILTER} injection token.
+     */
+    constructor(_log: LoggerService, _categoryFactory: CategoryFactory, baseFilter: BaseFilter);
+    ngOnDestroy(): void;
+    /**
+     * @returns the Filter that is currently applied to the view
+     */
+    get activeFilter(): Filter;
+    /**
+     * @returns an `Observable` that updates every time the active Filter changes.
+     */
+    get activeFilter$(): Observable<Filter>;
+    /**
+     * @returns `true` if a filter other than the base filter is currently applied.
+     * Returns `false` if only the base filter is currently applied.
+     */
+    get additionalFiltersApplied(): boolean;
+    /**
+     * @returns `true` if any visible predicates are applied.
+     * Returns `false` if there are no predicates, or if there are only hidden predicates applied
+     */
+    get hasVisiblePredicates(): boolean;
+    /**
+     * @returns a copy of the base filter
+     */
+    get baseFilter(): Filter;
+    /**
+     * @returns an Observable that emits the index of the removed predicate whenever a predicate is removed
+     */
+    get predicateRemoved$(): Observable<PredicateRemovalEvent>;
+    /**
+     * @returns the root predicate of the search service, that can be used to generate search requests with custom queries
+     */
+    get rootPredicate(): EditableClausePredicateWithGenerators;
+    /**
+     * @returns the type of the filter held in this search service instance
+     */
+    get filterType(): FilterType;
+    /**
+     * @returns whether the search service is currently loading its state from metadata or not.
+     *
+     * See [loadFromMetadata()]{@link SearchService#loadFromMetadata}
+     */
+    get loadingFromMetadata(): boolean;
+    /**
+     * @returns an `Observable` that emits `true` if the search service is currently loading its state from metadata,
+     * emits `false` otherwise.
+     *
+     * See [loadFromMetadata()]{@link SearchService#loadFromMetadata}
+     */
+    get loadingFromMetadata$(): Observable<boolean>;
+    /**
+     * @returns an Observable that emits whenever the root predicates query changes
+     */
+    protected get predicateQueryChanged$(): Observable<Query>;
+    /**
+     * Adds a {@link Predicate} to the Predicate root and updates the active Filter.
+     *
+     * Predicates added this way will not be visible in the search GUI.
+     * If you want to make sure your predicates are visible (and editable)
+     * use the [addGeneratedLeafPredicate()]{@link SearchService#addGeneratedLeafPredicate} method instead.
+     * @param newPredicate Predicate that should be added to the search queries.
+     * @returns the index of the added Predicate
+     */
+    addPredicate(newPredicate: Predicate): number;
+    /**
+     * Adds a new hidden branch of the predicate tree with a singular leaf node containing the provided Query.
+     *
+     * This can be used to add predicates to the search tree (think header search),
+     * which can be made visible and editable in the search GUI later.
+     * @param generator the generator that is in such state, that it generates the Query, that should be added as branch/leaf.
+     * If the generator doesn't currently generate a query a node with an empty query will be added.
+     */
+    addGeneratedLeafPredicate(generator: Category<any>): number;
+    /**
+     * Removes the {@link Predicate} object from the provided index. If the index is invalid does nothing.
+     * Updates the the active Filter if the Predicate tree was affected.
+     * @param index index of the Predicate that should be removed
+     * @param clearInput whether the input, that corresponds to the predicate should be cleared
+     */
+    removePredicate(index: number, clearInput?: boolean): void;
+    /**
+     * Removes all {@link Predicate} objects that contribute to the search. Updates the active Filter if it was affected.
+     *
+     * @param clearHidden whether the hidden predicates should be cleared as well
+     */
+    clearPredicates(clearHidden?: boolean): void;
+    /**
+     * Adds a {@link Filter} with the [fullText]{@link CaseSearchRequestBody#fullText} attribute set to the provided value.
+     * If full text filter is already set, it will be replaced.
+     * @param searchedSubstring value that should be searched on all full text fields
+     */
+    setFullTextFilter(searchedSubstring: string): void;
+    /**
+     * Clears the full text filter (if set). If the full text filter is not set, does nothing.
+     */
+    clearFullTextFilter(): 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.
+     */
+    show(predicateIds: Array<number>): void;
+    /**
+     * Reads the current query from the predicate tree, combines it with the base Filter and full text Filter (if set)
+     * and updates the active Filter.
+     */
+    protected updateActiveFilter(): void;
+    /**
+     * @returns `undefined` if the predicate tree contains no complete query.
+     * Otherwise returns the serialized form of the completed queries in the predicate tree.
+     */
+    createPredicateMetadata(): PredicateTreeMetadata | undefined;
+    /**
+     * Replaces the current predicate filter by the one corresponding to the provided generator metadata.
+     *
+     * The {@link CategoryFactory} instance must be provided for this service if we want to use this method. Logs an error and does nothing.
+     *
+     * The `filterType` of this search service must match the `filterType` of the provided metadata. Otherwise an error is thrown.
+     *
+     * @param metadata the serialized state of the predicate tree that should be restored to this search service
+     */
+    loadFromMetadata(metadata: FilterMetadata): void;
+    /**
+     * @returns an Array of filter text segments that correspond to the currently displayed completed predicates
+     */
+    createFilterTextSegments(): Array<FilterTextSegment>;
+}

package/lib/side-menu/content-components/filter-selector/abstract-filter-selector.component.d.ts

@@ -0,0 +1,105 @@
+import { OnDestroy } from '@angular/core';
+import { SideMenuControl } from '../../models/side-menu-control';
+import { FilterRepository } from '../../../filter/filter.repository';
+import { Filter } from '../../../filter/models/filter';
+import { FilteredArray } from './model/filtered-array';
+import { FormControl } from '@angular/forms';
+import { MatSelectionList, MatSelectionListChange } from '@angular/material/list';
+import { Subscription } from 'rxjs';
+/**
+ * Allows user to choose a {@link Filter} from the {@link FilterRepository}.
+ *
+ * Publishes events to the {@link SideMenuControl} object when:
+ *
+ * - filter is selected by the user. Message: `New selected filter`, Data: is either the selected filter or `undefined` if the user
+ * deselected the filter
+ *
+ * - filter selection is confirmed by the user. Message: `Selected filter was confirmed`, Data: the selected filter. If the user didn't
+ * select any filter this event will not be published.
+ *
+ */
+export declare abstract class AbstractFilterSelectorComponent implements OnDestroy {
+    protected _sideMenuControl: SideMenuControl;
+    protected _filterRepository: FilterRepository;
+    /**
+     * @ignore
+     * Case filters bound to HTML
+     */
+    caseFilters: FilteredArray<Filter>;
+    /**
+     * @ignore
+     * Task filters bound to html
+     */
+    taskFilters: FilteredArray<Filter>;
+    /**
+     * @ignore
+     * Task filters bound to html
+     */
+    protected subValue: Subscription;
+    /**
+     * @ignore
+     * `FormControl` for the search input
+     */
+    searchFormControl: FormControl;
+    /**
+     * @ignore
+     * Currently selected filter. `undefined` if no filter is selected.
+     */
+    protected _selectedFilter: Filter;
+    /**
+     * @ignore
+     * Reference to the `mat-selection-list` component, that holds the list of case filters.
+     */
+    caseFilterList: MatSelectionList;
+    /**
+     * @ignore
+     * Reference to the `mat-selection-list` component, that holds the list of task filters.
+     */
+    taskFilterList: MatSelectionList;
+    /**
+     * @ignore
+     * Stores the predicate used for filtering of filters with {@linkFilteredArray}.
+     * @param item some filter from the list
+     * @param searchInput value the user is searching for
+     */
+    protected _filterPredicate: (item: Filter, searchInput: string) => boolean;
+    /**
+     * Retrieves the {@link Filter} objects from the {@link FilterRepository} and instantiates this component.
+     *
+     * Filters that are available for selection can be set using the injected data. See {@link FilterSelectorInjectionData}
+     * for more information.
+     * @param _sideMenuControl -
+     * @param _filterRepository -
+     */
+    constructor(_sideMenuControl: SideMenuControl, _filterRepository: FilterRepository);
+    ngOnDestroy(): void;
+    /**
+     * @ignore
+     * Changes the currently selected filter and publishes an event about this to the output stream in {@link SideMenuControl}.
+     * @param filter the newly selected filter
+     */
+    filterSelected(filter: Filter): void;
+    /**
+     * @ignore
+     * Closes the side menu and publishes an event with the currently selected filter.
+     */
+    filterSelectionConfirmed(): void;
+    /**
+     * @ignore
+     * Clears selection of task filters and ensures that only one case filter can be selected at once.
+     * @param event list change event published byt the material component
+     */
+    caseFilterSelected(event: MatSelectionListChange): void;
+    /**
+     * @ignore
+     * Clears selection of case filters and ensures that only one task filter can be selected at once.
+     * @param event list change event published byt the material component
+     */
+    taskFilterSelected(event: MatSelectionListChange): void;
+    /**
+     * @ignore
+     * Filters both lists of filters based on user search input.
+     * @param newValue user search input value
+     */
+    filterFilters(newValue: string): void;
+}

package/lib/side-menu/content-components/filter-selector/filter-selector-list-item/abstract-filter-selector-list-item.component.d.ts

@@ -0,0 +1,20 @@
+import { OnInit } from '@angular/core';
+import { Filter } from '../../../../filter/models/filter';
+/**
+ * @ignore
+ * Renders a single filter in the selection list.
+ */
+export declare abstract class AbstractFilterSelectorListItemComponent implements OnInit {
+    /**
+     * Filter that should be rendered
+     */
+    filter: Filter;
+    /**
+     * Text that is bound to HTML
+     */
+    text: string;
+    /**
+     * Sets the text bound to HTML, to either the filter title (if it exists), or to it's ID.
+     */
+    ngOnInit(): void;
+}

package/lib/side-menu/content-components/filter-selector/model/filter-selector-injection-data.d.ts

@@ -0,0 +1,20 @@
+import { SideMenuInjectionData } from '../../../models/side-menu-injection-data';
+import { FilterType } from '../../../../filter/models/filter-type';
+/**
+ * Objects of this type can be used to constrain filters listed in {@link AbstractFilterSelectorComponent}.
+ *
+ * If no constraints are provided, all filters from {@link FilterRepository} will be displayed.
+ *
+ * If both constraints are provided and [listed filter IDs]{@link FilterSelectorInjectionData#filterIdsConstraint} are not
+ * of a single [type]{@link FilterSelectorInjectionData#filterTypeConstraint}, only the filters of the specified type will be displayed.
+ */
+export interface FilterSelectorInjectionData extends SideMenuInjectionData {
+    /**
+     * Constrains filters shown in {@link AbstractFilterSelectorComponent} to a single type.
+     */
+    filterTypeConstraint?: FilterType;
+    /**
+     * Constrains filters shown in {@link AbstractFilterSelectorComponent} to specific filters, by their IDs.
+     */
+    filterIdsConstraint?: Array<string>;
+}

package/lib/side-menu/content-components/filter-selector/model/filtered-array.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Simple class that generalizes filtering of array of elements.
+ * Filtered Results are contained in a separate array and can be bound to HTML.
+ * @typeparam T type of elements contained in the arrays.
+ */
+export declare class FilteredArray<T> {
+    private _unfiltered;
+    private _filterPredicate;
+    /**
+     * Contains all the elements from the provided array, that match the provided predicate.
+     */
+    filtered: Array<T>;
+    /**
+     * @param _unfiltered elements that can be filtered
+     * @param _filterPredicate predicate that is used to filter elements of the provided array. It should return `true` if `item` with
+     * the given `data` should appear in the filtered array.
+     */
+    constructor(_unfiltered: Array<T>, _filterPredicate: (item: T, data: any) => boolean);
+    /**
+     * Applies the filter predicate on all items of the unfiltered array.
+     * Each item that returns `true` will be included in the filtered array.
+     * @param data data that is sent to the {@link FilteredArray#_filterPredicate} for evaluation
+     */
+    filter(data: any): void;
+}

package/lib/side-menu/content-components/import-net/abstract-import-net.component.d.ts

@@ -0,0 +1,50 @@
+import { AfterViewInit, OnInit } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { SideMenuControl } from '../../models/side-menu-control';
+import { PetriNetResourceService } from '../../../resources/engine-endpoint/petri-net-resource.service';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { SnackBarService } from '../../../snack-bar/services/snack-bar.service';
+import { FileUploadDataModel } from '../../../data-fields/file-field/models/file-field';
+import { Subscription } from 'rxjs';
+import { TranslateService } from '@ngx-translate/core';
+import { PetriNetEventOutcome } from '../../../event/model/event-outcomes/petrinet-outcomes/petri-net-event-outcome';
+export declare class FileUploadModel {
+    stringId: string;
+    data: File | FileUploadDataModel;
+    inProgress: boolean;
+    progress: number;
+    completed: boolean;
+    error?: boolean;
+    uploaded?: boolean;
+    downloading: boolean;
+    sub?: Subscription;
+}
+interface FileList {
+    [key: string]: FileUploadModel;
+}
+export declare abstract class AbstractImportNetComponent implements OnInit, AfterViewInit {
+    protected _sideMenuControl: SideMenuControl;
+    protected _petriNetResource: PetriNetResourceService;
+    protected _log: LoggerService;
+    protected _snackbar: SnackBarService;
+    protected _translate: TranslateService;
+    files: FileList;
+    releaseTypes: Array<string>;
+    releaseTypeControl: FormControl;
+    protected _response: PetriNetEventOutcome;
+    protected _fileInput: HTMLInputElement;
+    constructor(_sideMenuControl: SideMenuControl, _petriNetResource: PetriNetResourceService, _log: LoggerService, _snackbar: SnackBarService, _translate: TranslateService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    get fileList(): Array<FileUploadModel>;
+    get isAllFinished(): boolean;
+    onProcessFileChosen(): void;
+    cancelFile(file: FileUploadModel): void;
+    retryFile(file: FileUploadModel): void;
+    close(): void;
+    protected setupFile(file: File): FileUploadModel;
+    protected uploadFiles(): void;
+    protected removeFile(file: FileUploadModel): void;
+    protected uploadFile(file: FileUploadModel): void;
+}
+export {};

package/lib/side-menu/content-components/injection-tokens.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken } from '@angular/core';
+import { ComponentType } from '@angular/cdk/portal';
+export declare const NAE_USER_ASSIGN_COMPONENT: InjectionToken<ComponentType<unknown>>;
+export declare const NAE_FILES_UPLOAD_COMPONENT: InjectionToken<ComponentType<unknown>>;
+export declare const NAE_NEW_CASE_COMPONENT: InjectionToken<ComponentType<unknown>>;
+export declare const NAE_OPTION_SELECTOR_COMPONENT: InjectionToken<ComponentType<unknown>>;
+export declare const NAE_SAVE_FILTER_COMPONENT: InjectionToken<ComponentType<unknown>>;
+export declare const NAE_LOAD_FILTER_COMPONENT: InjectionToken<ComponentType<unknown>>;

package/lib/side-menu/content-components/load-filter/abstract-load-filter.component.d.ts

@@ -0,0 +1,13 @@
+import { SideMenuControl } from '../../models/side-menu-control';
+import { LoadFilterInjectionData } from './model/load-filter-injection-data';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { AbstractCaseView } from '../../../view/case-view/abstract-case-view';
+import { CaseViewService } from '../../../view/case-view/service/case-view-service';
+import { Case } from '../../../resources/interface/case';
+export declare abstract class AbstractLoadFilterComponent extends AbstractCaseView {
+    protected _sideMenuControl: SideMenuControl;
+    protected _log: LoggerService;
+    protected _injectedData: LoadFilterInjectionData;
+    protected constructor(_sideMenuControl: SideMenuControl, _log: LoggerService, caseViewService: CaseViewService);
+    handleCaseClick(clickedCase: Case): void;
+}

package/lib/side-menu/content-components/load-filter/model/load-filter-injection-data.d.ts

@@ -0,0 +1,8 @@
+import { SideMenuInjectionData } from '../../../models/side-menu-injection-data';
+import { Filter } from '../../../../filter/models/filter';
+export interface LoadFilterInjectionData extends SideMenuInjectionData {
+    /**
+     * A case filter of the filter cases
+     */
+    filter: Filter;
+}

package/lib/side-menu/content-components/new-case/abstract-new-case.component.d.ts

@@ -0,0 +1,62 @@
+import { OnDestroy } from '@angular/core';
+import { FormBuilder, FormControl } from '@angular/forms';
+import { StepperSelectionEvent } from '@angular/cdk/stepper';
+import { BehaviorSubject, Observable, ReplaySubject } from 'rxjs';
+import { SnackBarService } from '../../../snack-bar/services/snack-bar.service';
+import { SideMenuControl } from '../../models/side-menu-control';
+import { CaseResourceService } from '../../../resources/engine-endpoint/case-resource.service';
+import { NewCaseInjectionData } from './model/new-case-injection-data';
+import { TranslateService } from '@ngx-translate/core';
+import { HotkeysService } from 'angular2-hotkeys';
+import { MatToolbar } from '@angular/material/toolbar';
+import { MatOption } from '@angular/material/core';
+interface Form {
+    value: string;
+    viewValue: string;
+    version?: string;
+}
+export declare abstract class AbstractNewCaseComponent implements OnDestroy {
+    protected _sideMenuControl: SideMenuControl;
+    protected _formBuilder: FormBuilder;
+    protected _snackBarService: SnackBarService;
+    protected _caseResourceService: CaseResourceService;
+    protected _hotkeysService: HotkeysService;
+    protected _translate: TranslateService;
+    processFormControl: FormControl;
+    titleFormControl: FormControl;
+    netVersion: string;
+    options: Array<Form>;
+    colors: Array<Form>;
+    filteredOptions$: Observable<Array<Form>>;
+    toolbar: MatToolbar;
+    stepper1: any;
+    stepper2: any;
+    protected _options$: ReplaySubject<Array<Form>>;
+    protected _injectedData: NewCaseInjectionData;
+    protected _hasMultipleNets$: ReplaySubject<boolean>;
+    protected _notInitialized$: BehaviorSubject<boolean>;
+    private _allowedNetsSubscription;
+    protected constructor(_sideMenuControl: SideMenuControl, _formBuilder: FormBuilder, _snackBarService: SnackBarService, _caseResourceService: CaseResourceService, _hotkeysService: HotkeysService, _translate: TranslateService);
+    ngOnDestroy(): void;
+    get hasMultipleNets$(): Observable<boolean>;
+    get notInitialized$(): Observable<boolean>;
+    stepChange($event: StepperSelectionEvent): void;
+    displayFn(process: Form): string;
+    createNewCase(): void;
+    /**
+     * Function to filter out matchless options without accent and case-sensitive differences
+     * @param value to compare matching options
+     * @param options that should be filtered
+     * @return  return matched options
+     */
+    protected _filter(value: string, options: Array<Form>): Array<Form>;
+    protected closeNoNets(): void;
+    nextStep(): void;
+    titleShortening(): any;
+    private removeOldVersions;
+    isCaseTitleEnabled(): boolean;
+    isCaseTitleRequired(): boolean;
+    showVersion(option: MatOption): void;
+    checkVersion(viewValue: any): void;
+}
+export {};

package/lib/side-menu/content-components/new-case/model/new-case-injection-data.d.ts

@@ -0,0 +1,13 @@
+import { SideMenuInjectionData } from '../../../models/side-menu-injection-data';
+import { Observable } from 'rxjs';
+import { PetriNetReference } from '../../../../resources/interface/petri-net-reference';
+export interface NewCaseInjectionData extends SideMenuInjectionData {
+    allowedNets$: Observable<Array<PetriNetReference>>;
+}
+/**
+ * injection token used for new case title configuration
+ */
+export interface NewCaseCreationConfigurationData {
+    enableCaseTitle: boolean;
+    isCaseTitleRequired: boolean;
+}

package/lib/side-menu/content-components/option-selector/abstract-option-selector.component.d.ts

@@ -0,0 +1,14 @@
+import { SideMenuControl } from '../../models/side-menu-control';
+import { Option, OptionSelectorInjectionData } from './model/option-selector-injection-data';
+import { FormControl } from '@angular/forms';
+import { Observable } from 'rxjs';
+export declare abstract class AbstractOptionSelectorComponent {
+    protected _sideMenuControl: SideMenuControl;
+    data: OptionSelectorInjectionData;
+    selectorFormControl: FormControl;
+    filteredOptions: Observable<Array<Option>>;
+    constructor(_sideMenuControl: SideMenuControl);
+    submit(): void;
+    displayFn(option: Option): string;
+    protected _filter(value: string): Array<Option>;
+}

package/lib/side-menu/content-components/option-selector/model/option-selector-injection-data.d.ts

@@ -0,0 +1,24 @@
+import { SideMenuInjectionData } from '../../../models/side-menu-injection-data';
+export interface OptionSelectorInjectionData extends SideMenuInjectionData {
+    /**
+     * The title that is displayed above the selection and passed trough a translate pipe
+     */
+    title: string;
+    /**
+     * Options that can be chosen from
+     */
+    options: Array<Option>;
+}
+/**
+ * One of the selector choices
+ */
+export interface Option {
+    /**
+     * Text displayed to the user
+     */
+    text: string;
+    /**
+     * The value that is returned when the option is confirmed
+     */
+    value: string;
+}