@tilde-nlp/ngx-common 7.0.1 → 8.0.1

package/index.d.ts

@@ -1,5 +1,2470 @@
+import * as i8 from '@angular/material/icon';
+import { MatIconRegistry } from '@angular/material/icon';
+import { DomSanitizer, Title } from '@angular/platform-browser';
+import * as i0 from '@angular/core';
+import { OnInit, EventEmitter, PipeTransform, ChangeDetectorRef, ElementRef, ViewContainerRef, Renderer2, AfterViewInit, OnDestroy, AfterContentInit, QueryList, OnChanges, SimpleChanges, InjectionToken, TemplateRef, Provider } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Observable, Subscription, Subject } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import * as i3 from '@ngx-translate/core';
+import { TranslateService, MissingTranslationHandler, MissingTranslationHandlerParams } from '@ngx-translate/core';
+import * as i2 from '@angular/common';
+import * as i5 from '@angular/material/tooltip';
+import * as i4 from '@angular/material/button';
+import { MatButton } from '@angular/material/button';
+import * as i3$1 from '@ngbracket/ngx-layout';
+import * as i5$1 from '@angular/router';
+import { TitleStrategy, RouterStateSnapshot } from '@angular/router';
+import * as i16 from '@angular/material/paginator';
+import { MatPaginatorIntl, PageEvent, MatPaginator } from '@angular/material/paginator';
+import * as i3$2 from '@angular/material/progress-bar';
+import * as i6 from '@angular/material/dialog';
+import { MatDialog, MatDialogRef } from '@angular/material/dialog';
+import * as i8$1 from '@angular/forms';
+import { FormGroup, FormBuilder, FormControl } from '@angular/forms';
+import * as i7 from '@angular/material/select';
+import { MatSelectChange } from '@angular/material/select';
+import * as i4$1 from '@angular/material/input';
+import * as i5$2 from '@angular/material/form-field';
+import * as _tilde_nlp_ngx_common from '@tilde-nlp/ngx-common';
+import { SelectionModel } from '@angular/cdk/collections';
+import * as i11 from '@angular/material/sort';
+import { MatSort } from '@angular/material/sort';
+import * as i3$3 from '@angular/material/table';
+import { MatTableDataSource, MatHeaderRowDef, MatRowDef, MatColumnDef, MatNoDataRow, MatTable } from '@angular/material/table';
+import * as i6$1 from '@angular/material/menu';
+import * as i7$1 from '@angular/material/checkbox';
+import * as i4$2 from '@angular/material/progress-spinner';
+import * as i18 from '@angular/material/radio';
+import { LLMRephraseUseCase, LLMSummaryUseCase, QuotaService, LLMService, QuotaUsage, QuotaResponse, QuotaType } from '@tilde-nlp/ngx-services';
+import * as i11$1 from '@angular/cdk/clipboard';
+import { Clipboard } from '@angular/cdk/clipboard';
+
+declare class IconService {
+    private readonly iconRegistry;
+    private readonly sanitizer;
+    constructor(iconRegistry: MatIconRegistry, sanitizer: DomSanitizer);
+    /** Registers svg icons to mat icon registry. Icon SVG's should be under some key in object. Icon name can be used with property name in lowercase. */
+    registerIcons(icons: any): void;
+    registerIconFromUrl(name: string, url: string): void;
+    addSvgIconSet(path: string, namespace?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IconService>;
+}
+
+declare class DOMService {
+    get window(): Window | null;
+    get localStorage(): Storage | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DOMService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DOMService>;
+}
+
+declare enum NotificationMessageType {
+    BASIC = "BASIC",
+    INFO = "INFO",
+    WARNING = "WARNING",
+    SUCCESS = "SUCCESS",
+    ERROR = "ERROR"
+}
+
+interface NotificationMessage {
+    type: NotificationMessageType;
+    id?: string;
+    title?: string;
+    body?: string;
+    localizationParams?: any;
+    buttonText?: string;
+    linkText?: string;
+    linkHref?: string;
+    routerLink?: string;
+    hideClose?: boolean;
+    /**
+     * Provide following params to use callback button instead of close button.
+     */
+    callbackButtonText?: string;
+    callbackButtonIcon?: string;
+    callbackButtonClick?: () => void;
+    error?: any;
+    /**
+     * Localization key for support info for message. If value is not null, it is displayed right after body text.
+     */
+    support?: string;
+    /**
+    * Set this to true and provide same message object in case you want to remove message from outside.
+    */
+    delete?: boolean;
+}
+
+declare class NotificationMessageComponent implements OnInit {
+    message: NotificationMessage;
+    buttonClicked: EventEmitter<any>;
+    closeClicked: EventEmitter<any>;
+    linkClicked: EventEmitter<any>;
+    /** Adds additional class that makes message to take less space on screen. */
+    inline: boolean;
+    readonly iconNames: {
+        [key in NotificationMessageType]: string;
+    };
+    className: string;
+    ngOnInit(): void;
+    buttonClick(): void;
+    closeClick(): void;
+    linkClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationMessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationMessageComponent, "lib-tld-notification-message", never, { "message": { "alias": "message"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; }, { "buttonClicked": "buttonClicked"; "closeClicked": "closeClicked"; "linkClicked": "linkClicked"; }, never, never, false, never>;
+}
+
+declare class CloseButtonComponent {
+    tldClick: EventEmitter<any>;
+    ariaCode: string;
+    clearButton: MatButton;
+    disabled: boolean;
+    tooltip: string;
+    clicked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CloseButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CloseButtonComponent, "tld-close-button", never, { "ariaCode": { "alias": "ariaCode"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; }, { "tldClick": "tldClick"; }, never, never, false, never>;
+}
+
+declare class CloseButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CloseButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CloseButtonModule, [typeof CloseButtonComponent], [typeof i2.CommonModule, typeof i4.MatButtonModule, typeof i3.TranslateModule, typeof i5.MatTooltipModule], [typeof CloseButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CloseButtonModule>;
+}
+
+declare class NotificationMessageModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationMessageModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NotificationMessageModule, [typeof NotificationMessageComponent], [typeof i2.CommonModule, typeof i3$1.FlexLayoutModule, typeof CloseButtonModule, typeof i4.MatButtonModule, typeof i3.TranslateModule, typeof i5$1.RouterModule, typeof i8.MatIconModule], [typeof NotificationMessageComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NotificationMessageModule>;
+}
+
+interface AlertConfiguration {
+    supportEmail: string;
+    registerLink: string;
+    contactSupport: boolean;
+    subscriptionSupport: boolean;
+    availableLanguages: any;
+}
+
+declare class AlertService {
+    private readonly config;
+    constructor(config: AlertConfiguration);
+    private messageSubject;
+    get defaultParams(): {
+        email: string;
+        registerLink: string;
+    };
+    private readonly defaultErrorKey;
+    private readonly errorKey;
+    private readonly numericErrorKeyPrefix;
+    private readonly titlePostFix;
+    private readonly supportPostFix;
+    private readonly subscriptionPostFix;
+    defaultError(error?: any): void;
+    getMessages(): rxjs.Observable<NotificationMessage>;
+    basic(text: string, params?: any): void;
+    info(text: string, params?: any): void;
+    success(text: string, params?: any): void;
+    error(text: string, error: any, params?: any): void;
+    warning(text: string, params?: any, hideClose?: boolean): void;
+    deleteMessage(type: NotificationMessageType, text: string, params?: any, hideClose?: boolean): void;
+    unhandeledError(error: any, errorTranslationSubKeys?: string[], params?: any): void;
+    findErrorTitleAndLocalizationKey(error: unknown, errorTranslationSubKeys: string[]): {
+        title: string;
+        description: string;
+    };
+    private findErrorKey;
+    private emit;
+    private getSupportMessage;
+    private findPostfix;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AlertService>;
+}
+
+declare const ALERT_CONFIGURATION_TOKEN = "ALERT_CONFIGURATION_TOKEN";
+
+interface System {
+    sourceLanguage: string;
+    targetLanguage: string;
+    id: string;
+    domain: string | null;
+    vendor: string;
+    /** Property created only for frontend, to seperate multi language engines and give unique id for each one of them */
+    languageId: string;
+    /** If system has terminology support. This field is only in API v1 and comes from metadata. */
+    includesTerminology?: boolean;
+    detectedLanguage?: string;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * Interface for configurating collection support from MT api and Tilde Term.
  */
-/// <amd-module name="@tilde-nlp/ngx-common" />
-export * from './public-api';
+interface TerminologyConfig {
+    appName?: string;
+    isAuth?: boolean;
+    xApiKey?: string;
+    maxRecentSystemCount?: number;
+    defaultDomains?: string[];
+    autoDomainDetection?: boolean;
+    systemListUrl?: string;
+    defaultVendor?: string;
+    allowedSystemStatuses?: string[];
+    appId?: string;
+    /** Tilde term portal API url */
+    terminologyPortalUrl?: string;
+    /** If user has permissions to create/edit new collection. This should be validated outside of the library */
+    canCreateCollection?: boolean;
+    /** Whether collections should be read from both APIs*/
+    isCollectionsActivated?: boolean;
+    /** If true and language direction collections are unavailable menu will be hidden. */
+    hideGlossaryMenuWithoutCollections?: boolean;
+    /** If true and language direction collections are unavailable menu with advertisement will appear. Otherwise, create new glossary view will appear. */
+    showGlossaryMenuAdvertisement?: boolean;
+    /** Determines if Tilde Terminology portal is supported*/
+    isTermPortalSupported?: boolean;
+    /** Min length for collection name input*/
+    collectionNameMinLength?: number;
+    /** Max length for collection name input*/
+    collectionNameMaxLength?: number;
+    /** Timeout in ms after how long shout happen automatic refresh of collection list (From both MT and term api)*/
+    refreshTimeoutMs?: number;
+    /** Overrides refreshTimeoutMs if any of collections is importing.
+    / Use case: normaly refreshing list every 10seconds, but when collection is importend, we might want to refresh list every 5secs, so user gets faster feedback when import finished.
+    */
+    refreshTimeoutMsWhenImporting?: number;
+    /** Engine Term api url */
+    engineTermUrl?: string;
+    /** Start trial url */
+    startTrialUrl?: string;
+    /** Sign in url */
+    signInUrl?: string;
+    /** Link for default glossary management link in glossary popup. */
+    defaultGlossaryManagementLink?: (engineId: string) => string;
+}
+
+declare class TerminologyConfigService {
+    private _termConfig;
+    get termConfig(): TerminologyConfig;
+    private readonly defaultApiUrl;
+    initConfigs(configuration?: TerminologyConfig): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TerminologyConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TerminologyConfigService>;
+}
+
+declare class SystemApiService {
+    private readonly http;
+    private readonly config;
+    constructor(http: HttpClient, config: TerminologyConfigService);
+    getSystemList(showDisabledEngines?: boolean): Observable<System[]>;
+    private generateSystemsFromLanguages;
+    private generateSystemsFromDomains;
+    private isLanguageDirectionAdded;
+    private createSystemObject;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SystemApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SystemApiService>;
+}
+
+declare class SystemService {
+    private readonly api;
+    constructor(api: SystemApiService);
+    getSystemList(showDisabledEngines?: boolean): Observable<System[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SystemService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SystemService>;
+}
+
+declare class LanguageTranslateService {
+    private readonly translateService;
+    constructor(translateService: TranslateService);
+    getLanguageCodeTranslation(code: string, hideRegion?: boolean): string;
+    removeRegionFromLanguageCode(code: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageTranslateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LanguageTranslateService>;
+}
+
+declare enum Operations {
+    CREATE = "CREATE",
+    DELETE = "DELETE"
+}
+
+interface NotificationWithOperation {
+    message: NotificationMessage;
+    operation: Operations;
+}
+
+declare class NotificationService {
+    private messageSubject;
+    notificationMessage: rxjs.Observable<NotificationWithOperation>;
+    private clearMessageSubject;
+    clearMessage: rxjs.Observable<NotificationMessage[]>;
+    addMessage(message: NotificationMessage): void;
+    deleteMessage(message: NotificationMessage): void;
+    clearMessages(): void;
+    isMessageUnique(messages: NotificationMessage[], newMessage: NotificationMessage): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationService>;
+}
+
+declare class PlausibleHelper {
+    /**
+     * Adds plausible for selected domain and adds additional script for custom event (goal) triggering
+     * @param domain domain that is registered in your plausible account
+     * @returns
+     */
+    static addPlausible(domain: string): void;
+    /**
+     * Emits custom plausible event
+     * @param id plausible event id that should be the same as registered in plausible
+     * @param properties an object with custom properties for the event
+     * @returns
+     */
+    static customEvent(id: string, properties?: any): void;
+}
+
+interface PlausibleEvent {
+    eventId: string;
+    properties?: {
+        key: string;
+        value: string;
+    }[];
+}
+
+declare class PlausibleEventDirective {
+    private id;
+    private properties;
+    /** Plausible event id. */
+    set libPlausibleEvent(value: PlausibleEvent | undefined);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlausibleEventDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PlausibleEventDirective, "[libPlausibleEvent]", never, { "libPlausibleEvent": { "alias": "libPlausibleEvent"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class PlausibleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlausibleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PlausibleModule, [typeof PlausibleEventDirective], [typeof i2.CommonModule], [typeof PlausibleEventDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PlausibleModule>;
+}
+
+declare enum InlineMessageIconPosition {
+    START = 0,
+    END = 1
+}
+
+declare enum InlineMessageType {
+    INFO = "info",
+    WARNING = "warning",
+    ERROR = "error"
+}
+
+interface InlineMessage {
+    title: string;
+    description?: string;
+    localizationParams: unknown;
+    type: InlineMessageType;
+    iconPosition?: InlineMessageIconPosition;
+    iconTooltip?: string;
+}
+
+declare class InlineMessageComponent {
+    readonly END_ICON_POSITION = InlineMessageIconPosition.END;
+    iconName: string;
+    message: InlineMessage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InlineMessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InlineMessageComponent, "lib-inline-message", never, { "iconName": { "alias": "iconName"; "required": false; }; "message": { "alias": "message"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class InlineMessageModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InlineMessageModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<InlineMessageModule, [typeof InlineMessageComponent], [typeof i2.CommonModule, typeof i3.TranslateModule, typeof i5.MatTooltipModule], [typeof InlineMessageComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<InlineMessageModule>;
+}
+
+declare class FilterWithHighlightPipe implements PipeTransform {
+    transform(value: any[], filter: string, key?: string): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterWithHighlightPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FilterWithHighlightPipe, "filterWithHighlight", false>;
+}
+
+declare class FilterWithHighlightModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterWithHighlightModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FilterWithHighlightModule, [typeof FilterWithHighlightPipe], [typeof i2.CommonModule], [typeof FilterWithHighlightPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FilterWithHighlightModule>;
+}
+
+declare class SortTranslationsPipe implements PipeTransform {
+    private translate;
+    constructor(translate: TranslateService);
+    /**
+     *
+     * @param objects array of objects to be sorted
+     * @param localizationPrefix prefix for localization code. This is used to get necessary object translations.
+     * @param key Which object property needs to be used for sorting.
+     * @param currentLanguage This is necessary to update values if language is changed.
+     * @returns
+     */
+    transform(objects: Array<any>, localizationPrefix: string | null, key: string | null | undefined, currentLanguage: string, translationKey?: string | null): Observable<Array<any>>;
+    private sortObjects;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortTranslationsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SortTranslationsPipe, "sortTranslations", false>;
+}
+
+declare class SortTranslationsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortTranslationsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SortTranslationsModule, [typeof SortTranslationsPipe], [typeof i2.CommonModule], [typeof SortTranslationsPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SortTranslationsModule>;
+}
+
+declare class SortTranslationsByPropertyPipe implements PipeTransform {
+    private translate;
+    constructor(translate: TranslateService);
+    /**
+     * Transforms the input array of objects by sorting them based on the specified sortingValueKey.
+     * @param values An array of objects to be sorted.
+     * @param sortingValueKey The key by which the provided values should be sorted.
+     * @param defaultValueKey For missing translations there is option to provide a default key to take value from.
+     */
+    transform(values: any[], sortingValueKey: string, defaultValueKey?: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortTranslationsByPropertyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SortTranslationsByPropertyPipe, "sortTranslationsByProperty", false>;
+}
+
+declare class SortTranslationsByPropertyModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortTranslationsByPropertyModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SortTranslationsByPropertyModule, [typeof SortTranslationsByPropertyPipe], [typeof i2.CommonModule], [typeof SortTranslationsByPropertyPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SortTranslationsByPropertyModule>;
+}
+
+declare class LanguageTranslatePipe implements PipeTransform {
+    private readonly translate;
+    private readonly languagesLocalizationKey;
+    private lastUiLanguage;
+    private readonly translationCache;
+    private readonly localeSameRegions;
+    private readonly translations;
+    constructor(translate: TranslateService);
+    transform(fullLangCode: string, hideRegion?: boolean): string;
+    private getTranslation;
+    private getLanguageTranslationFromLanguageCode;
+    private isLanguageCodeSameAsRegion;
+    private getRegionFromLanguageCode;
+    private getLanguageFromLanguageCode;
+    private capitalizeFirstLetter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageTranslatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LanguageTranslatePipe, "languageTranslate", true>;
+}
+
+declare class LanguageTranslateModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageTranslateModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LanguageTranslateModule, never, [typeof LanguageTranslatePipe, typeof i2.CommonModule], [typeof LanguageTranslatePipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LanguageTranslateModule>;
+}
+
+interface DateAgoInterval {
+    key: string;
+    interval: number;
+    min: number;
+}
+
+/**
+ * Configuration settings for DateAgo pipe.
+ */
+interface DateAgoSettings {
+    /**
+     * Intervals for defined groups.
+     */
+    intervals: DateAgoInterval[];
+    /**
+     * String to be added to original key if interval group value is bigger than 1. Typically you want to add 'S' to the key, if value is multiple.
+     */
+    multiplePostfix: string;
+    /**
+     * Localization key, that should be before interval key. Do not place '.' at the end of key.
+     */
+    localizationPrefix: string;
+    /**
+     * Key for "Just now"
+     */
+    justNowKey: string;
+    /**
+     * For how many seconds should show just now.
+     */
+    justNowSeconds: number;
+}
+
+interface DateAgo {
+    key: string;
+    howMany?: number;
+}
+
+declare class DateAgoPipe implements PipeTransform {
+    private readonly translate;
+    private readonly _ref;
+    private readonly settings;
+    readonly defaultSettings: DateAgoSettings;
+    get intervals(): DateAgoInterval[];
+    get multiplePostfix(): string;
+    get localizationPrefix(): string;
+    get justNowKey(): string;
+    get justNowSeconds(): number;
+    constructor(translate: TranslateService, _ref: ChangeDetectorRef, settings: DateAgoSettings);
+    transform(value: Date, enableMultiplePostfix?: boolean): string;
+    calculateDateAgo(value: Date, enableMultiplePostfix: boolean): DateAgo | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateAgoPipe, [null, null, { optional: true; }]>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateAgoPipe, "dateAgo", false>;
+}
+
+declare class DateAgoModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateAgoModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DateAgoModule, [typeof DateAgoPipe], [typeof i2.CommonModule, typeof i3.TranslateModule], [typeof DateAgoPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DateAgoModule>;
+}
+
+declare class ObjectLengthPipe implements PipeTransform {
+    transform(value: any): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectLengthPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ObjectLengthPipe, "objectLength", false>;
+}
+
+declare class ObjectLengthModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectLengthModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ObjectLengthModule, [typeof ObjectLengthPipe], [typeof i2.CommonModule], [typeof ObjectLengthPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ObjectLengthModule>;
+}
+
+declare class SortByNumberPipe implements PipeTransform {
+    transform(values: any[], sortingValueKey?: string, desc?: boolean): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortByNumberPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SortByNumberPipe, "sortByNumber", true>;
+}
+
+declare class SortAlphabeticallyPipe implements PipeTransform {
+    transform(values: any[], sortingValueKey?: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortAlphabeticallyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SortAlphabeticallyPipe, "sortAlphabetically", false>;
+}
+
+declare class SortAlphabeticallyModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortAlphabeticallyModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SortAlphabeticallyModule, [typeof SortAlphabeticallyPipe], [typeof i2.CommonModule], [typeof SortAlphabeticallyPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SortAlphabeticallyModule>;
+}
+
+interface TranslatedLanguage<T> {
+    value: T;
+    translation: string;
+}
+
+declare class SortLanguageListPipe implements PipeTransform {
+    #private;
+    transform<T>(list: T[], key?: string): Observable<TranslatedLanguage<T>[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortLanguageListPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SortLanguageListPipe, "sortLanguageList", true>;
+}
+
+declare enum FILE_SIZE_UNIT {
+    BYTES = "B",
+    KILOBYTES = "KB",
+    MEGABYTES = "MB",
+    GIGABYTES = "GB"
+}
+
+declare class FileSizeLabelPipe implements PipeTransform {
+    transform(value: number, decimalPlaces?: number, unit?: FILE_SIZE_UNIT): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileSizeLabelPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FileSizeLabelPipe, "fileSizeLabel", true>;
+}
+
+declare class DomainTranslatePipe implements PipeTransform {
+    readonly translate: TranslateService;
+    constructor(translate: TranslateService);
+    transform(value: string, isDomain: boolean): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DomainTranslatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DomainTranslatePipe, "domainTranslate", true>;
+}
+
+/**
+ * This is a custom pipe for sorting domains.
+ * It prioritizes the most important entries using a specific order:
+ * "General" first, followed by LLM-related domains, and then the rest in alphabetical order.
+ */
+declare class SortDomainsPipe implements PipeTransform {
+    readonly translate: TranslateService;
+    constructor(translate: TranslateService);
+    transform(value: any[], isDomainList: boolean, key: string): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortDomainsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SortDomainsPipe, "sortDomains", true>;
+}
+
+declare class ClickOutsideDirective {
+    private elementRef;
+    clickOutside: EventEmitter<void>;
+    constructor(elementRef: ElementRef);
+    onClick(target: HTMLElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickOutsideDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickOutsideDirective, "[clickOutside]", never, {}, { "clickOutside": "clickOutside"; }, never, never, false, never>;
+}
+
+declare class ClickOutsideModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickOutsideModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ClickOutsideModule, [typeof ClickOutsideDirective], [typeof i2.CommonModule], [typeof ClickOutsideDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ClickOutsideModule>;
+}
+
+declare class DragAndDropDirective {
+    private readonly element;
+    get disabled(): any;
+    active: boolean;
+    fileDropped: EventEmitter<any>;
+    onDragOver(evt: any): void;
+    onDragLeave(evt: any): void;
+    ondrop(evt: any): void;
+    constructor(element: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragAndDropDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragAndDropDirective, "[tldDragAndDrop]", never, {}, { "fileDropped": "fileDropped"; }, never, never, false, never>;
+}
+
+declare class DragAndDropModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragAndDropModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DragAndDropModule, [typeof DragAndDropDirective], [typeof i2.CommonModule], [typeof DragAndDropDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DragAndDropModule>;
+}
+
+declare class MatButtonLoadingDirective {
+    private matButton;
+    private viewContainerRef;
+    private renderer;
+    private _loading;
+    set loading(value: boolean);
+    private spinner;
+    constructor(matButton: MatButton, viewContainerRef: ViewContainerRef, renderer: Renderer2);
+    get nativeElement(): HTMLElement;
+    updateState(): void;
+    private createSpinner;
+    private destroySpinner;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatButtonLoadingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatButtonLoadingDirective, "button[mat-button][loading],  button[mat-raised-button][loading],  button[mat-icon-button][loading],  button[mat-fab][loading],  button[mat-mini-fab][loading],  button[mat-stroked-button][loading],  button[mat-flat-button][loading]", never, { "loading": { "alias": "loading"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class MatButtonLoadingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatButtonLoadingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatButtonLoadingModule, [typeof MatButtonLoadingDirective], [typeof i2.CommonModule], [typeof MatButtonLoadingDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatButtonLoadingModule>;
+}
+
+declare class TldLoaderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TldLoaderComponent, "lib-tld-loader", never, {}, {}, never, never, false, never>;
+}
+
+declare class TldLoaderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldLoaderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TldLoaderModule, [typeof TldLoaderComponent], never, [typeof TldLoaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TldLoaderModule>;
+}
+
+declare class MissingTranslationHelper implements MissingTranslationHandler {
+    handle(params: MissingTranslationHandlerParams): any;
+}
+
+declare class SaveFileHelper {
+    static saveFile(content: string, fileName: string): void;
+    static saveBlob(blob: Blob, fileName: string): void;
+}
+
+declare class HtmlElementParseHelper {
+    static tableAsCsv(tableElement: HTMLElement, ignoreAttributeName?: string): string;
+}
+
+declare class AuthHeadersHelper {
+    static getAuthHeaders(clientId: string): any;
+    static getAppIdAuthHeaders(appId: string): any;
+}
+
+declare class FileExtensionHelper {
+    static getFileExtension(fileName: string): string;
+}
+
+declare class ConversionHelper {
+    static bytesToMb(bytes: number): number;
+    static pascalCaseToEnum(property: string): string;
+}
+
+declare class SortHelper {
+    /**
+     * Sorts an array of objects based on the order of values specified in another array.
+     *
+     * @param objectArr - The array of objects to be sorted.
+     * @param sortByArray - The array that defines the preferred order of values.
+     * @param fieldName - The name of the field in the objects used for sorting.
+     *
+     * Objects in `objectArr` will be sorted based on the position of their `fieldName` value in `sortByArray`.
+     */
+    static sortByArray(objectArr: any[], sortByArray: any[], fieldName: string): void;
+    /**
+    * Transforms the input array of objects by sorting them based on the specified sortingValueKey.
+    * @param values - An array of objects to be sorted.
+    * @param sortingValueKey - The key by which the provided values should be sorted, leave it empty if you want to sort string[].
+    */
+    static sortAlphabetically(values: any[], sortingValueKey?: string): any;
+    /**
+    * Sorts an array of values by a specified numeric property or by their numeric value if no property is specified.
+    * @param values - The array of values to be sorted. Can be an array of objects or primitive numeric values.
+    * @param sortingValueKey - The key of the numeric property in the objects to sort by.
+    * @param desc - Flag indicating whether to sort in descending (true) or ascending (false) order.
+    */
+    static sortByNumber(values: any[], sortingValueKey?: string, desc?: boolean): any[];
+    /**
+    * This method is intended to be used with sorting methods like Array.sort(). It compares two strings, a and b, against a reference substring input.
+    * @param a - The first string to be compared.
+    * @param b - The second string to be compared.
+    * @param input - The reference substring used to influence the sorting order.
+    */
+    static sortByStartingLetter(a: string, b: string, input: string): number;
+}
+
+declare class HtmlHelper {
+    /**
+    * Removes special characters so string is not interpretated as html.
+    * @param text
+    */
+    static escapeHtmlString(text: string): string;
+    static encodeHtmlString(text: string): string;
+    /**
+     * Splits string into paragraphs.
+     * @param text
+     */
+    static splitInParagraphs(text: string): string[];
+    static joinParagraphs(text: string[]): string;
+    static toCamelCase(text: string, symbol?: string): string;
+    static isTextUrl(text: string): string | null;
+    static getWordCount(text: string): number | undefined;
+    static getLocalizationKey(text: string): string;
+}
+
+declare class ResolutionHelper {
+    static isMobileRes(): boolean;
+}
+
+declare const getFileSizeLabel: (size: number, decimalPlaces?: number, unit?: FILE_SIZE_UNIT) => string;
+
+declare class CustomPaginatorInernationalizationHelper extends MatPaginatorIntl {
+    #private;
+    constructor();
+    getTranslations(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomPaginatorInernationalizationHelper, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CustomPaginatorInernationalizationHelper>;
+}
+
+declare class HashHelper {
+    static hashString(username: string): string;
+}
+
+declare class CompanyProductComponent {
+    company: string;
+    product: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CompanyProductComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CompanyProductComponent, "lib-company-product", never, { "company": { "alias": "company"; "required": false; }; "product": { "alias": "product"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class CompanyProductModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CompanyProductModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CompanyProductModule, [typeof CompanyProductComponent], [typeof i2.CommonModule], [typeof CompanyProductComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CompanyProductModule>;
+}
+
+declare class FooterComponent implements OnInit {
+    currentYear: number;
+    readonly defaultTermsRoute = "terms-of-use";
+    readonly defaultPrivacyRoute = "privacy-policy";
+    privacyRoute: string;
+    termsOfUseRoute: string;
+    contactUsRoute: string;
+    baseUrl: string;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FooterComponent, "tld-footer", never, { "privacyRoute": { "alias": "privacyRoute"; "required": false; }; "termsOfUseRoute": { "alias": "termsOfUseRoute"; "required": false; }; "contactUsRoute": { "alias": "contactUsRoute"; "required": false; }; "baseUrl": { "alias": "baseUrl"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class FooterModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FooterModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FooterModule, [typeof FooterComponent], [typeof i2.CommonModule, typeof i3$1.FlexLayoutModule, typeof i3.TranslateModule, typeof i5$1.RouterModule], [typeof FooterComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FooterModule>;
+}
+
+declare enum FileUploadErrorTypeEnum {
+    FILE_UPLOAD_UNSUPPORTED_FORMAT = "FILE_UPLOAD_UNSUPPORTED_FORMAT",
+    FILE_UPLOAD_UNSUPPORTED_FORMAT_REGISTER = "FILE_UPLOAD_UNSUPPORTED_FORMAT_REGISTER",
+    MAX_SIZE = "FILE_UPLOAD_MAX_SIZE",
+    FILE_EMPTY = "FILE_UPLOAD_EMPTY"
+}
+
+interface FileUploadError {
+    code: FileUploadErrorTypeEnum;
+    error: string;
+    fileName: string;
+    maxSizeLabel: string;
+}
+
+declare class FileUploadComponent implements OnInit {
+    #private;
+    fileInput: ElementRef;
+    fileChange: EventEmitter<File[]>;
+    errorEvent: EventEmitter<FileUploadError>;
+    private _accept;
+    set accept(val: string[]);
+    get accept(): string[];
+    useCompactUpload: boolean;
+    maxSize: number;
+    multiple: boolean;
+    filePreviewProgress: number;
+    allowEmpty: boolean;
+    disabled: boolean;
+    dragZoneLabel: string;
+    uploadIconName: string;
+    uploadButtonLabel: string;
+    openExtensionPopupLabel: string;
+    minSupportedFormatCount: number;
+    /** same as accept but for registered users. It changes error message if extension is supported for registered users. */
+    extendedAcceptList: string[];
+    maxSizeLabel: string;
+    allowedExtensions: string;
+    constructor();
+    ngOnInit(): void;
+    openSupportedFormatModal(): void;
+    handleFileInput(event: Event): void;
+    onFileDrop(files: any): void;
+    private setMaxSizeLabel;
+    private emit;
+    private emitError;
+    private validate;
+    private getExtensionErrorCode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileUploadComponent, "lib-file-upload", never, { "accept": { "alias": "accept"; "required": false; }; "useCompactUpload": { "alias": "useCompactUpload"; "required": false; }; "maxSize": { "alias": "maxSize"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "filePreviewProgress": { "alias": "filePreviewProgress"; "required": false; }; "allowEmpty": { "alias": "allowEmpty"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "dragZoneLabel": { "alias": "dragZoneLabel"; "required": false; }; "uploadIconName": { "alias": "uploadIconName"; "required": false; }; "uploadButtonLabel": { "alias": "uploadButtonLabel"; "required": false; }; "openExtensionPopupLabel": { "alias": "openExtensionPopupLabel"; "required": false; }; "minSupportedFormatCount": { "alias": "minSupportedFormatCount"; "required": false; }; "extendedAcceptList": { "alias": "extendedAcceptList"; "required": false; }; }, { "fileChange": "fileChange"; "errorEvent": "errorEvent"; }, never, ["*"], false, never>;
+}
+
+declare enum FileTypeIcons {
+    WORD = "file_type_word",
+    WEB = "file_type_web",
+    OTHER = "file_type_other",
+    POWERPOINT = "file_type_powerpoint",
+    EXCEL = "file_type_excel",
+    OFFICE_OTHER = "file_type_office_other",
+    PDF = "file_type_pdf",
+    SCANNED = "file_type_scanned",
+    INTERCHANGE = "file_type_interchange"
+}
+
+declare enum FileCategories {
+    OFFICE = "OFFICE",
+    SCANNED = "SCANNED",
+    INTERCHANGE = "INTERCHANGE",
+    WEB = "WEB",
+    OTHER = "OTHER"
+}
+
+declare enum FileTypes {
+    WORD = "WORD",
+    WEB = "WEB",
+    OTHER = "OTHER",
+    POWERPOINT = "POWERPOINT",
+    EXCEL = "EXCEL",
+    OFFICE_OTHER = "OFFICE_OTHER",
+    PDF = "PDF",
+    SCANNED = "SCANNED",
+    INTERCHANGE = "INTERCHANGE"
+}
+
+declare enum FileExtensions {
+    DOC = "doc",
+    DOCX = "docx",
+    DOCM = "docm",
+    XLSX = "xlsx",
+    PPTX = "pptx",
+    ODT = "odt",
+    ODP = "odp",
+    ODS = "ods",
+    TXT = "txt",
+    RTF = "rtf",
+    PAGES = "pages",
+    SXW = "sxw",
+    JPG = "jpg",
+    JPEG = "jpeg",
+    PNG = "png",
+    BMP = "bmp",
+    PDF = "pdf",
+    SDLXLIFF = "sdlxliff",
+    SDLXLF = "sdlxlf",
+    TTX = "ttx",
+    TMX = "tmx",
+    XLF = "xlf",
+    XLIF = "xlif",
+    HTML = "html",
+    HTM = "htm",
+    JSON = "json",
+    XHTML = "xhtml",
+    XHT = "xht",
+    XLIFF = "xliff",
+    TEX = "tex",
+    TTL = "ttl",
+    SRT = "srt"
+}
+
+interface Config {
+    elements: Category[];
+}
+interface Category {
+    category: FileCategories;
+    columns: Column[];
+    anyVisible?: boolean;
+}
+interface Column {
+    anyVisible?: boolean;
+    extensions: ExtensionWithIcon[];
+}
+interface ExtensionWithIcon {
+    extension: FileExtensions;
+    icon: FileTypeIcons;
+    visible?: boolean;
+}
+
+interface DialogData {
+    extensions: string[];
+}
+
+/**
+  This is an extension dialog component.
+  Use <lib-open-extension-dialog> to open this dialog, by proivding [extensions] to it you can specify what extensions should be displayed.
+*/
+declare class ExtensionDialogComponent implements OnInit {
+    private data;
+    private readonly iconService;
+    readonly config: Config;
+    extensions: string[];
+    undescribedExtensions: string[];
+    constructor(data: DialogData, iconService: IconService);
+    ngOnInit(): void;
+    updateConfig(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExtensionDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExtensionDialogComponent, "lib-extension-dialog", never, {}, {}, never, never, false, never>;
+}
+
+declare class ExtensionDialogService {
+    private readonly dialog;
+    constructor(dialog: MatDialog);
+    open(extensions: string[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExtensionDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExtensionDialogService>;
+}
+
+declare class OpenExtensionDialogComponent {
+    private readonly service;
+    extensions: string[];
+    constructor(service: ExtensionDialogService);
+    open(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenExtensionDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OpenExtensionDialogComponent, "lib-open-extension-dialog", never, { "extensions": { "alias": "extensions"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ExtensionDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExtensionDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ExtensionDialogModule, [typeof ExtensionDialogComponent, typeof OpenExtensionDialogComponent], [typeof i2.CommonModule, typeof i4.MatButtonModule, typeof i3.TranslateModule, typeof i6.MatDialogModule, typeof i3$1.FlexLayoutModule, typeof i8.MatIconModule, typeof CloseButtonModule], [typeof OpenExtensionDialogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ExtensionDialogModule>;
+}
+
+declare class FileUploadModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploadModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FileUploadModule, [typeof FileUploadComponent], [typeof i2.CommonModule, typeof i3$2.MatProgressBarModule, typeof i3$1.FlexLayoutModule, typeof i4.MatButtonModule, typeof DragAndDropModule, typeof i8.MatIconModule, typeof ExtensionDialogModule, typeof i3.TranslateModule], [typeof FileUploadComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FileUploadModule>;
+}
+
+interface FilterBarFilterItem {
+    key: string;
+    value: any;
+    /**
+     * These properties are updated automatically during the search process.
+     * They are necessary to hide elements that do not match the search criteria or are not selected.
+     * Also if element is selected, but doesnt match search criteria it also dissapears.
+     */
+    isSelected?: boolean;
+    matchesSearchCriteria?: boolean;
+}
+
+interface FilterBarFilterSearch {
+    /**
+     * If placeholder is defined search will be appeared.
+     * When searching for items, searchCriteria and filteredValues are being set automatically.
+     */
+    placeholder: string;
+    filteredValues?: FilterBarFilterItem[];
+    searchCriteria?: string;
+}
+
+interface FilterBarFilterSingleSelection {
+    /**
+     * Indicates whether the filter is selected. This property must be supplied externally.
+     * When set to true, it disables all options except the one with the corresponding value.
+     * In order to allow unselecting the currently selected value, a specific value must be defined.
+     */
+    selected: boolean;
+    /**
+     * The value of the filter option that remains enabled when `selected` is true.
+     * This is used to match the option that should not be disabled.
+     */
+    value: string;
+}
+
+interface FilterBarFilter {
+    fieldName: string;
+    title: string;
+    values: FilterBarFilterItem[];
+    search?: FilterBarFilterSearch;
+    singleSelection?: FilterBarFilterSingleSelection;
+    disableTitleCase?: boolean;
+    /**
+     * Selected values updating automatically and records all selected options of current filter.
+     */
+    selectedValues?: FilterBarFilterItem[];
+    /**
+     * Set this to '' in case you need to fit longest content.
+     * Combine this with search, so filtering does not affect panel size.
+     */
+    maxPanelWidth?: number | string;
+    /**
+     * If values array keys are already translated, set this to true.
+     */
+    translated?: boolean;
+}
+
+interface FilterBarSettings {
+    /** Show/hide search input. Enabled by default. */
+    hideSearch?: boolean;
+    /** Initial value for search input. */
+    searchValue?: string;
+    /** Show/hide search input clear button. Disabled by default. */
+    showSearchClearButton?: boolean;
+    /** Toggle output filter item between value, and object with key and value fields. Value by default. */
+    outputFilterKeyAndValue?: boolean;
+    /** Title for search input field. Default value: FILTER_BAR.SEARCH */
+    searchTitle?: string;
+    /** Table global search entered criteria. */
+    searchInput?: string;
+    /** Search tooltip, shown after input field for icon */
+    searchTooltip?: string;
+    hideTooltip?: boolean;
+    filters?: FilterBarFilter[];
+    splittedFilters?: FilterBarFilter[][];
+}
+
+interface FilterBarChangeEvent {
+    input: string;
+    filters: {
+        [fieldName: string]: any[];
+    };
+}
+
+declare class FilterBarComponent implements OnInit, AfterViewInit, OnDestroy {
+    private cdref;
+    private translate;
+    filterWrapper: ElementRef;
+    optionSearchInputs: ElementRef[];
+    onResize(): void;
+    settings: FilterBarSettings;
+    set filterRowVisible(value: boolean);
+    filterBarChange: EventEmitter<FilterBarChangeEvent>;
+    private _inputText;
+    private _filterRowVisible;
+    private formChangesSubscription;
+    readonly filterFormGroup: FormGroup<{}>;
+    readonly form: FormGroup<{
+        filters: FormGroup<{}>;
+    }>;
+    filters: FilterBarChangeEvent;
+    filterOverflow: boolean;
+    activeFilterIndex: number;
+    get filterFormGroupValue(): {
+        [key: string]: FilterBarFilterItem[];
+    };
+    get filterRowVisible(): boolean;
+    get inputText(): string;
+    get outputFilterKeyAndValue(): boolean | undefined;
+    get currentFilters(): FilterBarFilter[] | undefined;
+    set inputText(value: string);
+    constructor(cdref: ChangeDetectorRef, translate: TranslateService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    focusOptionSearchInput(filter: FilterBarFilter, index: number): void;
+    clearOptionSearchInput(filter: FilterBarFilter, index: number): void;
+    filterOptions(event: KeyboardEvent | null, filter: FilterBarFilter): void;
+    selectEvent(event: MatSelectChange, filter: FilterBarFilter): void;
+    setPanelWidth(filter: FilterBarFilter): void;
+    emitFilters(): void;
+    switchRight(): void;
+    switchLeft(): void;
+    removeFilter(key: string, ix: number): void;
+    removeAllFilters(): void;
+    private checkOverflow;
+    private subscribeToFormValueChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterBarComponent, "tld-filter-bar", never, { "settings": { "alias": "settings"; "required": false; }; "filterRowVisible": { "alias": "filterRowVisible"; "required": false; }; }, { "filterBarChange": "filterBarChange"; }, never, never, false, never>;
+}
+
+declare class FilterBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FilterBarModule, [typeof FilterBarComponent], [typeof i2.CommonModule, typeof i3.TranslateModule, typeof i4$1.MatInputModule, typeof i5$2.MatFormFieldModule, typeof i3$1.FlexLayoutModule, typeof i7.MatSelectModule, typeof i8$1.FormsModule, typeof i5.MatTooltipModule, typeof i4.MatButtonModule, typeof i8.MatIconModule, typeof i8$1.ReactiveFormsModule, typeof SortTranslationsByPropertyModule, typeof SortAlphabeticallyModule], [typeof FilterBarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FilterBarModule>;
+}
+
+interface StatusDisplayConfig {
+    enabled: boolean;
+    title: string;
+    titleParams?: any;
+    description?: string;
+    descriptionParams?: any;
+    /**
+      * Add an extra, separated description bellow description.
+      * The main use of this description is to display a Help Center message below description.
+    */
+    extraDescription?: string;
+    extraDescriptionParams?: any;
+    icon?: string;
+    loading?: boolean;
+}
+
+interface ColumnConfig {
+    /**
+     * Column name. For column to dissapear/be visible, this must be the same as defined for mat-table columns.
+     */
+    name: string;
+    /**
+     * Display name. Component applies translate pipe to this.
+     */
+    displayName: string;
+    /**
+     * Default value to determine if column is selected.
+     */
+    selected: boolean;
+    /**
+    * If set to true, columns visibility can't be toggled.
+    */
+    notConfigurable?: boolean;
+}
+
+interface BatchConfig {
+    enabled: boolean;
+    checkBoxesDisabled?: boolean;
+}
+
+/**
+ * Multi functional table configuration for column selecting. Config responsible for configuring columns whose visibilty can be toggled.
+ */
+interface ColumnSelectConfig {
+    /**
+     * Columns to whom visibility can be changed.
+     */
+    columns: ColumnConfig[];
+    /**
+     * If column select feature is enabled.
+     */
+    enabled?: boolean;
+}
+
+declare enum ExportFormat {
+    CSV = "csv"
+}
+
+interface ExportConfig {
+    enabled: boolean;
+    fileOptions?: {
+        format?: ExportFormat;
+        saveToFile: boolean;
+        fileName: string;
+    };
+}
+
+interface FilterConfig {
+    settings: FilterBarSettings;
+    visible?: boolean;
+    enabled?: boolean;
+    hideFilterToggle?: boolean;
+}
+
+interface PaginatorConfig {
+    enabled: boolean;
+    /** Initial page when loading table. Might be useful to keep some previously opened state of table. */
+    initialPage?: number;
+    showFirstLastButtons?: boolean;
+    pageSizeOptions?: number[];
+    showPageSize?: boolean;
+}
+
+/**
+ * Configuration for table with multiple predefined actoins against mat table.
+ */
+interface MultiFunctionalTableConfig<T> {
+    /**
+     * Mat table dataSource.
+     * @deprecated use Mat Table data property instead.
+     */
+    dataSource?: MatTableDataSource<T>;
+    /**
+     * Configuration for toggling displayed columns in mat table
+     */
+    columnSelect?: ColumnSelectConfig;
+    /**
+     * Configuration for filters. For filtering custom filterBar component is used. Note that component does not filter datasource by itself but only emits event when filters are changed.
+     */
+    filter?: FilterConfig;
+    /**
+     * Configuration for exporting data.
+     */
+    export?: ExportConfig;
+    /**
+     * Local storage key to store selected columns and filter visibilty.
+     */
+    localStorageKey?: string;
+    /**
+     * Set to true, if mouse dragging is not required.
+     */
+    disableMouseDragging?: boolean;
+    /**
+     * Configuration for texts and icon for no data row.
+     */
+    noDataRow?: StatusDisplayConfig;
+    batchConfig?: BatchConfig;
+    stickyHeader?: boolean;
+    /** Table pagination configuration. Disabled by default. */
+    paginator?: PaginatorConfig;
+    /**
+      * Callback function for row click.
+      */
+    rowClickCallback?: (param: T) => void;
+    /**
+      * Provide condition under which row clicking should be disabled.
+      */
+    disableRowClick?: (param: T) => boolean;
+}
+
+declare class MultiFunctionalTableComponent<T> implements OnInit, AfterContentInit, AfterViewInit {
+    #private;
+    private readonly domService;
+    private readonly translateService;
+    readonly matSelection: SelectionModel<T>;
+    get dataSource(): MatTableDataSource<T>;
+    config: MultiFunctionalTableConfig<T>;
+    highlightedElements: T[];
+    trackByFn: (ix: number, row: T) => string | number;
+    highlightedErrorElements: T[];
+    set selection(value: T[]);
+    isRowCheckboxAlwaysVisible: boolean;
+    disablePreselectedItems: boolean;
+    filterBarChange: EventEmitter<FilterBarChangeEvent>;
+    paginatorUpdate: EventEmitter<PageEvent>;
+    exported: EventEmitter<T[]>;
+    selectionChange: Observable<T[]>;
+    headerRowDefs: QueryList<MatHeaderRowDef>;
+    rowDefs: QueryList<MatRowDef<T>>;
+    columnDefs: QueryList<MatColumnDef>;
+    noDataRow: MatNoDataRow;
+    table: MatTable<T>;
+    sort: MatSort;
+    tableContainer: ElementRef<HTMLElement>;
+    filterBar: FilterBarComponent;
+    paginator: MatPaginator;
+    tableElementRef: ElementRef<HTMLElement>;
+    /** This property will be taken into account only if config.DataSource not set. */
+    data: i0.InputSignal<T[] | undefined>;
+    dataSourceUpdateEffect: i0.EffectRef;
+    preselectedItems: T[];
+    get ignoreAttributeName(): string;
+    displayColumns: string[];
+    columnSelectActive: boolean;
+    exportActive: boolean;
+    noDataRowActive: boolean;
+    filters: FilterBarChangeEvent;
+    filterBarVisible: boolean;
+    hideSearchTooltip: boolean;
+    showSearch: boolean;
+    showSearchClearButton: boolean;
+    searchTitle: string;
+    searchTooltip: string;
+    noDataRowConfig: StatusDisplayConfig;
+    noDataRowIcon: string;
+    configurableColumns: ColumnConfig[];
+    batchSelectedEnabled: boolean;
+    hoveredRow: any;
+    hoveredRowIndex: number | undefined;
+    tableOverflow: boolean;
+    private scrollMovement;
+    private isDragging;
+    private startX;
+    private startY;
+    private scrollLeft;
+    private scrollTop;
+    get filterActive(): boolean | undefined;
+    get showFilterToggle(): boolean;
+    get showFilterReset(): _tilde_nlp_ngx_common.FilterBarFilter | undefined;
+    private localStorageValue;
+    readonly batchColumnName = "batch";
+    readonly columnSelectColumnName = "columnSelect";
+    constructor(domService: DOMService, translateService: TranslateService);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    search(event: {
+        target: {
+            value: string;
+        };
+    } | KeyboardEvent): void;
+    updateDisplayColumns(initial?: boolean): void;
+    toggleFilterBar(): void;
+    filtersChanged(filters: FilterBarChangeEvent): void;
+    clearFilters(): void;
+    export(): void;
+    isElementHighlighted(ix: number, element: T): boolean;
+    highlightErrorElement(ix: number, element: T): boolean;
+    isAllSelected(): boolean;
+    toggleAllRowSelection(): void;
+    toggleElementSelection(element: T): void;
+    onMouseDown(event: MouseEvent): void;
+    onMouseMove(event: MouseEvent): void;
+    onMouseUp(): void;
+    paginatorChange(change: PageEvent): void;
+    rowHovered(index: number, row: T): void;
+    rowHoverLeave(): void;
+    defaultTrackBy(ix: number): number;
+    private checkTableOverflow;
+    private exportToFile;
+    private updateLocalStorage;
+    private readFromLocalStorage;
+    private setColumnSelectProperties;
+    private setFilterVisibility;
+    private setNoDataRowProperties;
+    private setExportProperties;
+    private createDataSource;
+    private updateDataSourceData;
+    private updatePaginator;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiFunctionalTableComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MultiFunctionalTableComponent<any>, "tld-multi-functional-table", never, { "config": { "alias": "config"; "required": false; }; "highlightedElements": { "alias": "highlightedElements"; "required": false; }; "trackByFn": { "alias": "trackByFn"; "required": false; }; "highlightedErrorElements": { "alias": "highlightedErrorElements"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "isRowCheckboxAlwaysVisible": { "alias": "isRowCheckboxAlwaysVisible"; "required": false; }; "disablePreselectedItems": { "alias": "disablePreselectedItems"; "required": false; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; }, { "filterBarChange": "filterBarChange"; "paginatorUpdate": "paginatorUpdate"; "exported": "exported"; "selectionChange": "selectionChange"; }, ["noDataRow", "headerRowDefs", "rowDefs", "columnDefs"], ["[additionalActions]", "[batchActions]", "*"], false, never>;
+}
+
+declare class StatusDisplayComponent {
+    config: StatusDisplayConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StatusDisplayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StatusDisplayComponent, "lib-status-display", never, { "config": { "alias": "config"; "required": true; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class StatusDisplayModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<StatusDisplayModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<StatusDisplayModule, [typeof StatusDisplayComponent], [typeof i2.CommonModule, typeof i3.TranslateModule, typeof i4$2.MatProgressSpinnerModule, typeof i5$1.RouterModule], [typeof StatusDisplayComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<StatusDisplayModule>;
+}
+
+declare class MultiFunctionalTableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiFunctionalTableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MultiFunctionalTableModule, [typeof MultiFunctionalTableComponent], [typeof i2.CommonModule, typeof i3$3.MatTableModule, typeof i4.MatButtonModule, typeof i3.TranslateModule, typeof i6$1.MatMenuModule, typeof i7$1.MatCheckboxModule, typeof i8$1.FormsModule, typeof FilterBarModule, typeof i3$1.FlexLayoutModule, typeof i11.MatSortModule, typeof i4$2.MatProgressSpinnerModule, typeof i5.MatTooltipModule, typeof StatusDisplayModule, typeof i8.MatIconModule, typeof i16.MatPaginatorModule], [typeof MultiFunctionalTableComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MultiFunctionalTableModule>;
+}
+
+declare const DISABLE_EXPORT_ATTRIBUTE_NAME = "disable-export";
+
+interface ConfirmationBody {
+    title: string;
+    descriptioon: string;
+    confirmationText: string;
+    rejectionText: string;
+    /** property to display extra confirmation details (eg. selected engine names) */
+    details?: string[];
+}
+
+declare enum Confirmation {
+    PRIMARY = 1,
+    SECONDARY = 2
+}
+
+declare class ConfirmationModalComponent {
+    dialogRef: MatDialogRef<ConfirmationModalComponent>;
+    data: ConfirmationBody;
+    confirmation: typeof Confirmation;
+    constructor(dialogRef: MatDialogRef<ConfirmationModalComponent>, data: ConfirmationBody);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmationModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmationModalComponent, "lib-confirmation-modal", never, {}, {}, never, never, false, never>;
+}
+
+declare class ConfirmationModalModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmationModalModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfirmationModalModule, [typeof ConfirmationModalComponent], [typeof i2.CommonModule, typeof i6.MatDialogModule, typeof i4.MatButtonModule, typeof i3.TranslateModule], [typeof ConfirmationModalComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ConfirmationModalModule>;
+}
+
+declare class ConfirmationService {
+    private readonly dialog;
+    constructor(dialog: MatDialog);
+    openDialog(data: ConfirmationBody): Observable<Confirmation>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfirmationService>;
+}
+
+interface EngineTermCollectionAccessScopeUpdate {
+    default: boolean;
+}
+
+interface EngineTermCollectionAccessUpdate {
+    group: EngineTermCollectionAccessScopeUpdate;
+    global?: EngineTermCollectionAccessScopeUpdate;
+}
+
+declare enum EngineTermCollectionSource {
+    TILDE_TERM = "TildeTerm",
+    FILE = "File"
+}
+
+interface AddEngineTermsRequestParams {
+    collectionId: string;
+    collectionSource: EngineTermCollectionSource;
+    access: EngineTermCollectionAccessUpdate;
+}
+
+interface UpdateEngineTermsRequestParams {
+    access: EngineTermCollectionAccessUpdate;
+}
+
+interface EngineTermCollectionAccessScope {
+    default: boolean;
+    order: number;
+}
+
+interface EngineTermCollectionAccess {
+    global?: EngineTermCollectionAccessScope;
+    group?: EngineTermCollectionAccessScope;
+    user?: EngineTermCollectionAccessScope;
+}
+
+declare enum EngineTermCollectionScope {
+    GROUP = "Group",
+    GLOBAL = "Global"
+}
+
+declare enum EngineTermCollectionStatus {
+    IMPORTING = "Importing",
+    READY = "Ready",
+    ERROR = "Error",
+    DELETING = "Deleting"
+}
+
+declare enum EngineTermCollectionSubStatus {
+    UNSPECIFIED = "Unspecified",
+    IMPORTING_QUEUING = "ImportingQueuing",
+    IMPORTING = "Importing",
+    IMPORTING_FETCHING = "ImportingFetching",
+    IMPORTING_PREPROCESSING = "ImportingPreprocessing",
+    DELETING_QUEUING = "DeletingQueuing",
+    DELETING = "Deleting",
+    DELETING_DELETED = "DeletingDeleted",
+    ERROR_IMPORTING = "ErrorImporting",
+    ERROR_DELETING = "ErrorDeleting "
+}
+
+interface EngineTermCollection {
+    id: string;
+    externalCollection: ExternalCollection;
+    scope: EngineTermCollectionScope;
+    default: boolean;
+    name: string;
+    status: EngineTermCollectionStatus;
+    subStatus: EngineTermCollectionSubStatus;
+    progress: number;
+    collectionSource: EngineTermCollectionSource;
+    order: number;
+    access: EngineTermCollectionAccess;
+}
+interface ExternalCollection {
+    id: string;
+    updatedAt: Date;
+    termCount: number;
+}
+
+interface EngineTermCollectionList {
+    termCollections: EngineTermCollection[];
+}
+
+interface DefaultCollectionOrderUpdate {
+    order: string[];
+    scope: EngineTermCollectionScope;
+}
+
+declare enum CombinedCollectionTooltipKey {
+    NO_ENTRIES = "NO_ENTRIES",
+    DEFAULT_COLLECTION = "DEFAULT_COLLECTION"
+}
+
+declare enum MtCollectionStatus {
+    IMPORTING = "Importing",
+    DELETING = "Deleting",
+    READY = "Ready",
+    PROCESSING = "Processing",
+    ERROR = "Error",
+    NOT_IN_USE = "NotInUse"
+}
+
+interface MtCollection {
+    id: string;
+    lastUpdated: Date | null;
+    status: MtCollectionStatus;
+    subStatus?: EngineTermCollectionSubStatus;
+    name: string;
+    termId?: string;
+    collectionSource?: string;
+    /**
+     * Api v2 determines if collection is default.
+     */
+    termCount?: number;
+    progress?: number;
+    access?: EngineTermCollectionAccess;
+}
+
+/**
+ * Term collection from term portal languages property interface.
+ */
+interface ITldTermCollectionLanguages {
+    /**
+     * Language code
+     */
+    id: string;
+    count: number;
+    name: string;
+}
+
+interface ITldTermCollection {
+    allowsUsesBesidesDGT: boolean;
+    appropriatnessForDSI: boolean;
+    attributionText: string;
+    belonging: any;
+    canDownloadPublic: boolean;
+    closed: boolean;
+    collectionGuid: string;
+    collectionTags: any[];
+    cpEmail: string;
+    cpName: string;
+    cpOrganization: string;
+    cpSurname: string;
+    createDate: Date;
+    defaultDomain: any;
+    defaultLanguages: any;
+    description: string;
+    domainID: any;
+    domains: any;
+    elrcShareId: any;
+    entryCount: number;
+    eurovocDomainId: any;
+    externalUri: string;
+    id: string;
+    iprEmail: string;
+    iprName: string;
+    iprOrganization: string;
+    iprSurname: string;
+    isImporting: boolean;
+    isPSI: boolean;
+    languages: ITldTermCollectionLanguages[];
+    licence: any;
+    metaNordId: any;
+    modifyDate: Date;
+    name: string;
+    originalName: string;
+    originalNameLang: string;
+    ownerGroupGuid: string;
+    permissions: string[];
+    public: boolean;
+    restrictionsOfUse: any;
+    sourceURL: string;
+    targetCollectionId: any;
+    type: string;
+}
+
+/**
+ * Class that joins collection from term api and its imported collection from MT api.
+ */
+declare class CombinedCollection {
+    mtCollection: MtCollection | null;
+    termCollection: ITldTermCollection | null;
+    termTooltipKey: CombinedCollectionTooltipKey | null;
+    source: EngineTermCollectionSource;
+    /**
+     * Modified date from term api or last updated from mt api.
+     */
+    lastUpdated: Date | undefined;
+    static importingStatuses: MtCollectionStatus[];
+    static findExistingCollectionFromList(collections: Iterable<CombinedCollection>, collection: CombinedCollection): CombinedCollection | null;
+    static findExistingIndexFromList(collections: Iterable<CombinedCollection>, collection: CombinedCollection): number | null;
+    editables: {
+        globalDefault?: boolean;
+        groupDefault?: boolean;
+    };
+    private _isSynchronized;
+    /**
+     * Weather collection is synchronized with term portal collection. If no term collection, value is set to true.
+     */
+    get isSynchronized(): boolean;
+    /**
+     * Determines if collections is 'syncable'. Returns true if it is not synced or if synchronization has failed and status is error.
+     */
+    private _syncButtonVisible;
+    get syncButtonVisible(): boolean;
+    /**
+     * Term collection id. Returns value from term collection or from mt, if term collection not existing.
+     */
+    get termId(): string;
+    get mtStatus(): MtCollectionStatus | undefined;
+    /**
+     * Collection name. If has term collection, takes from there. If not, then returns mt collection name.
+     */
+    get name(): string | undefined;
+    /**
+     * Entry count from term api.
+     */
+    get termEntries(): number | undefined;
+    /** Checks if has set to default in any scope */
+    private _default;
+    get default(): boolean;
+    /**
+     * Status from mt api or custom "NOT_IN_USE" status if not imported in mt.s
+     */
+    get status(): MtCollectionStatus;
+    /**
+     * Scope can be edited only if has mt collcetion or term collection is being prepared for import.
+     */
+    get canEditScope(): boolean | MtCollection;
+    get termCount(): number | undefined;
+    private _isTermPortalCollection;
+    get isTermPortalCollection(): boolean;
+    private _isImporting;
+    get isImporting(): boolean | null;
+    constructor(termApiCollection: ITldTermCollection | null, mtCollection: MtCollection | null);
+    /**
+     * Updates collection with values from new collection.
+     * @param collection collection from which should be updated.
+     */
+    update(collection: CombinedCollection | null): void;
+    /**
+     * If some of editables are edited.
+     *
+     * if collection not imported and enabled not set, method will return true, because you cannot update collection if it is not imported or is not meant to be imported.
+     *
+     * @returns true if collection is edited, false if not.
+     */
+    isEdited(): boolean;
+    /**
+     * Deletes term collection and its properties.
+     */
+    deleteTerms(): void;
+    /**
+     * Deletes mt collection and its properties.
+     */
+    deleteMT(): void;
+    updateEditables(access: EngineTermCollectionAccess | null): void;
+    private updateIsSynchronized;
+    private updateSource;
+    private updateTooltipKey;
+}
+
+interface DomainList {
+    domains: Domain[];
+    active: Domain | undefined;
+}
+interface Domain {
+    title: string;
+    /** Property created only for frontend, to seperate multi language engines and give unique id for each one of them */
+    languageId: string;
+}
+
+interface Vendor {
+    title: string;
+    /** Property created only for frontend, to seperate multi language engines and give unique id for each one of them */
+    languageId: string;
+}
+
+interface LangListItem {
+    lang?: string;
+    languageId?: string;
+    domain?: string;
+    vendor?: string;
+}
+
+interface ActiveData {
+    systemId?: string;
+    languageId: string;
+    sourceLang?: LangListItem;
+    targetLang?: LangListItem;
+    sourceLangList?: LangListItem[];
+    targetLangList?: LangListItem[];
+    domains?: DomainList;
+    vendors?: Vendor[];
+    swapLangActive?: boolean;
+    system?: System;
+    /**
+     * Whether text/file should be retranslated on system change.
+     * For example if domain is auto and system gets changed after api response, no retranslation needed.
+     */
+    retranslate?: boolean;
+    recentSystems: System[];
+    detectedLanguage?: string;
+}
+
+interface TerminologyEngine {
+    selected: CombinedCollection | null;
+    isImporting: boolean;
+    isAnyImporting: boolean;
+    hasAnyCollections: boolean;
+    isRefreshingCollections: boolean;
+    collections: Set<CombinedCollection>;
+    refreshMtCollections: boolean;
+    refreshTermCollections: boolean;
+    engineLanguages: string[];
+    isSoftAutoRefreshOn: boolean;
+    hardAutoRefresh: boolean;
+    refreshTimeout: any;
+}
+
+declare class EngineTermApiService {
+    private readonly http;
+    private readonly config;
+    baseUrl: string;
+    constructor(http: HttpClient, config: TerminologyConfigService);
+    add(engineId: string, params: AddEngineTermsRequestParams): Observable<EngineTermCollection>;
+    update(engineId: string, collectionId: string, params: UpdateEngineTermsRequestParams): Observable<EngineTermCollection>;
+    getList(engineId: string): Observable<EngineTermCollectionList>;
+    remove(engineId: string, collectionId: string): Observable<EngineTermCollection>;
+    order(engineId: string, orderUpdate: DefaultCollectionOrderUpdate): Observable<EngineTermCollectionList>;
+    sync(engineId: string, collectionId: string): Observable<EngineTermCollection>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EngineTermApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EngineTermApiService>;
+}
+
+declare class TerminologyApiService {
+    private readonly config;
+    private readonly engineTermApi;
+    baseUrl: string;
+    constructor(config: TerminologyConfigService, engineTermApi: EngineTermApiService);
+    add(engineId: string, collection: CombinedCollection): Observable<CombinedCollection>;
+    getList(engineId: string): Observable<CombinedCollection[]>;
+    remove(engineId: string, collection: CombinedCollection): Observable<CombinedCollection>;
+    sync(engineId: string, collection: CombinedCollection): Observable<CombinedCollection>;
+    private convertToCombinedCollection;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TerminologyApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TerminologyApiService>;
+}
+
+declare class TerminologyCollectionService {
+    private readonly config;
+    private readonly http;
+    get url(): string;
+    constructor(config: TerminologyConfigService, http: HttpClient);
+    createCollection(defaultLanguages: string[], collectionName: string): Observable<CombinedCollection>;
+    getCollectionList(): Observable<CombinedCollection[]>;
+    getEditLink(termId: string, sourceLanguage?: string, targetLanguage?: string): string;
+    private convertToCombinedCollection;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TerminologyCollectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TerminologyCollectionService>;
+}
+
+declare class TerminologyService {
+    private readonly config;
+    private readonly alert;
+    private readonly termCollectionApi;
+    private readonly mtApi;
+    engines: {
+        [engineId: string]: TerminologyEngine;
+    };
+    private retranslateSubject;
+    private engineSubject;
+    private updatedEnginesSubject;
+    get isAuthenticated(): boolean | undefined;
+    get canCreateCollections(): boolean | undefined;
+    readonly LOCAL_STORAGE_KEY = "systemLastCollections";
+    get hasEditPermissions(): boolean | undefined;
+    constructor(config: TerminologyConfigService, alert: AlertService, termCollectionApi: TerminologyCollectionService, mtApi: TerminologyApiService);
+    getRetranslateSignal(): Observable<boolean>;
+    resetEngines(): void;
+    hasAnyCollections(systemId: string): boolean;
+    getEnginesWithSelectedCollectionChange(): Observable<{
+        [engineId: string]: TerminologyEngine;
+    }>;
+    setEngine(engineId: string, languages?: string[] | null, setSelectedFromLocalStorage?: boolean, termCollections?: boolean, mtCollections?: boolean, selectedCollection?: CombinedCollection, autoRefresh?: boolean): Observable<{
+        [engineId: string]: TerminologyEngine;
+    }>;
+    setSelectedCollection(engineId: string, collection: CombinedCollection | null, storeSelectedInLocalStorage: boolean): void;
+    loadCollections(engineId: string, setSelectedFromLocalStorage?: boolean): Observable<{
+        [engineId: string]: TerminologyEngine;
+    }>;
+    getCollections(): Observable<{
+        [engineId: string]: TerminologyEngine;
+    }>;
+    startAutoRefresh(engineId: string, languages?: string[] | null, setSelectedFromLocalStorage?: boolean, termCollections?: boolean, mtCollections?: boolean): Observable<{
+        [engineId: string]: TerminologyEngine;
+    }>;
+    stopAutoRefresh(engineId: string): void;
+    create(sourceLanguage: string, targetLanguage: string, collectionName: string, engineId: string, redirectToEdit?: boolean): Observable<CombinedCollection>;
+    selectedIdForTranslation(engineId: string): string | null;
+    updateIfNecessary(collection: CombinedCollection, engineId: string, isEdited?: boolean): Observable<CombinedCollection>;
+    handleAddToEngineError(error: any, engineId: string): void;
+    sync(collection: CombinedCollection, engineId: string): Observable<CombinedCollection>;
+    removeMtCollection(collection: CombinedCollection, engineId: string): Observable<CombinedCollection>;
+    addToEngineValidation(collection: CombinedCollection): boolean;
+    private clearTimeout;
+    private setSelectedFromLocalStorage;
+    private removeDeleted;
+    private addCollections;
+    private scheduleRefresh;
+    private storeSelectedInLocalStorage;
+    private readLocalStorage;
+    private updateSelectedCollectionOutsideService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TerminologyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TerminologyService>;
+}
+
+declare class TerminologyComponent implements OnInit, OnDestroy, OnChanges {
+    private readonly config;
+    private readonly terminologyService;
+    private readonly iconService;
+    selectedCollectionId: string;
+    system: {
+        systemId: string;
+        sourceLanguageCode: string;
+        targetLanguageCode: string;
+    };
+    disabled: boolean;
+    storeSelectedInLocalStorage: boolean;
+    setSelectedFromLocalStorage: boolean;
+    showMenuIconOnMobile: boolean;
+    glossarySelectEvent: EventEmitter<CombinedCollection | null>;
+    menuToggleEvent: EventEmitter<boolean>;
+    private isRefreshEnabled;
+    private isMenuOpened;
+    private presetCollectionSubscription;
+    private readonly destroy;
+    selected: CombinedCollection | null;
+    get hideGlossaryMenuWithoutCollections(): boolean | undefined;
+    get hasAnyCollections(): boolean;
+    constructor(config: TerminologyConfigService, terminologyService: TerminologyService, iconService: IconService);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    selectGlossary(collection: CombinedCollection | null): void;
+    openMenu(): void;
+    closeMenu(): void;
+    ngOnDestroy(): void;
+    private stopRefresh;
+    private presetCollection;
+    private watchSystemChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TerminologyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TerminologyComponent, "lib-terminology", never, { "selectedCollectionId": { "alias": "selectedCollectionId"; "required": false; }; "system": { "alias": "system"; "required": true; }; "disabled": { "alias": "disabled"; "required": false; }; "storeSelectedInLocalStorage": { "alias": "storeSelectedInLocalStorage"; "required": false; }; "setSelectedFromLocalStorage": { "alias": "setSelectedFromLocalStorage"; "required": false; }; "showMenuIconOnMobile": { "alias": "showMenuIconOnMobile"; "required": false; }; }, { "glossarySelectEvent": "glossarySelectEvent"; "menuToggleEvent": "menuToggleEvent"; }, never, never, false, never>;
+}
+
+declare class TerminologyPanelComponent implements OnInit, OnChanges {
+    private readonly terminologyService;
+    private readonly config;
+    system: {
+        systemId: string;
+        sourceLanguageCode: string;
+        targetLanguageCode: string;
+    };
+    setSelectedFromLocalStorage: boolean;
+    selectedCollection: CombinedCollection | null;
+    glossarySelectEvent: EventEmitter<CombinedCollection | null>;
+    get isAuthenticated(): boolean | undefined;
+    get hasAnyCollections(): boolean;
+    get hasEditPermissions(): boolean | undefined;
+    get canCreateCollections(): boolean | undefined;
+    get showGlossaryMenuAdvertisement(): boolean | undefined;
+    get signInUrl(): string | undefined;
+    get startTrialUrl(): string | undefined;
+    get showGlossaryList(): boolean | undefined;
+    sourceLanguageCode: string;
+    targetLanguageCode: string;
+    defaultGlossaryManagementLink: string;
+    readonly readerLocalizationKey = "TERM_COLLECTIONS.READER.";
+    constructor(terminologyService: TerminologyService, config: TerminologyConfigService);
+    private systemId;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    selectGlossary(collection: CombinedCollection | null): void;
+    private initializeData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TerminologyPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TerminologyPanelComponent, "lib-terminology-panel", never, { "system": { "alias": "system"; "required": true; }; "setSelectedFromLocalStorage": { "alias": "setSelectedFromLocalStorage"; "required": true; }; "selectedCollection": { "alias": "selectedCollection"; "required": false; }; }, { "glossarySelectEvent": "glossarySelectEvent"; }, never, never, false, never>;
+}
+
+declare class TerminologyCreateCollectionComponent {
+    private readonly translate;
+    private readonly dialog;
+    private readonly terminologyService;
+    sourceLanguageCode: string;
+    targetLanguageCode: string;
+    collectionCreated: EventEmitter<CombinedCollection>;
+    private readonly createCollectionErrorCode;
+    get canCreateCollections(): boolean | undefined;
+    constructor(translate: TranslateService, dialog: MatDialog, terminologyService: TerminologyService);
+    create(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TerminologyCreateCollectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TerminologyCreateCollectionComponent, "lib-terminology-create-collection", never, { "sourceLanguageCode": { "alias": "sourceLanguageCode"; "required": false; }; "targetLanguageCode": { "alias": "targetLanguageCode"; "required": false; }; }, { "collectionCreated": "collectionCreated"; }, never, never, false, never>;
+}
+
+declare class TerminologyCreateCollectionDialogComponent implements OnInit, OnDestroy {
+    private readonly dialogRef;
+    private readonly config;
+    private readonly translateService;
+    private readonly fb;
+    data: {
+        collectionName: string;
+    };
+    form: FormGroup;
+    collectionName: string;
+    minLength: number;
+    maxLength: number;
+    termPortalName: string;
+    appName: string;
+    appNameKey: string;
+    termPortalKey: string;
+    private subscription;
+    constructor(dialogRef: MatDialogRef<any>, config: TerminologyConfigService, translateService: TranslateService, fb: FormBuilder, data: {
+        collectionName: string;
+    });
+    ngOnInit(): void;
+    create(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TerminologyCreateCollectionDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TerminologyCreateCollectionDialogComponent, "lib-terminology-create-collection-dialog", never, {}, {}, never, never, false, never>;
+}
+
+declare class TerminologyCollectionListComponent implements OnInit, OnDestroy {
+    private readonly terminologyService;
+    private readonly config;
+    system: {
+        systemId: string;
+        sourceLanguageCode: string;
+        targetLanguageCode: string;
+    };
+    selectedCollection: CombinedCollection | null;
+    glossarySelectEvent: EventEmitter<CombinedCollection | null>;
+    appName: string;
+    collections: CombinedCollection[];
+    readonly localizationKey = "TERM_COLLECTIONS.";
+    readonly tooltipLocalizationKey = "TERM_COLLECTIONS.TOOLTIPS.";
+    get hasAnyCollections(): boolean;
+    get hasEditPermissions(): boolean;
+    private readonly destroy;
+    constructor(terminologyService: TerminologyService, config: TerminologyConfigService);
+    ngOnInit(): void;
+    selectGlossary(collection: CombinedCollection | null): void;
+    ngOnDestroy(): void;
+    private collectionsSortFunction;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TerminologyCollectionListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TerminologyCollectionListComponent, "lib-terminology-collection-list", never, { "system": { "alias": "system"; "required": true; }; "selectedCollection": { "alias": "selectedCollection"; "required": false; }; }, { "glossarySelectEvent": "glossarySelectEvent"; }, never, never, false, never>;
+}
+
+declare class TerminologyCollectionCardComponent {
+    private readonly terminologyService;
+    private readonly terminologyCollection;
+    collection: CombinedCollection;
+    selected: CombinedCollection | null;
+    localizationKey: string;
+    tooltipLocalizationKey: string;
+    sourceLanguageCode: string;
+    engineId: string;
+    targetLanguageCode: string;
+    hasEditPermissions: boolean;
+    glossarySelectEvent: EventEmitter<CombinedCollection>;
+    collectionErrorStatus: MtCollectionStatus;
+    collectionImportingErrorSubStatus: EngineTermCollectionSubStatus;
+    get isSelectionDisabled(): boolean;
+    constructor(terminologyService: TerminologyService, terminologyCollection: TerminologyCollectionService);
+    selectGlossary(collection: CombinedCollection): void;
+    attach(collection: CombinedCollection): void;
+    getEditLink(collection: CombinedCollection): string;
+    private isCollectionDisabled;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TerminologyCollectionCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TerminologyCollectionCardComponent, "lib-terminology-collection-card", never, { "collection": { "alias": "collection"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "localizationKey": { "alias": "localizationKey"; "required": false; }; "tooltipLocalizationKey": { "alias": "tooltipLocalizationKey"; "required": false; }; "sourceLanguageCode": { "alias": "sourceLanguageCode"; "required": false; }; "engineId": { "alias": "engineId"; "required": false; }; "targetLanguageCode": { "alias": "targetLanguageCode"; "required": false; }; "hasEditPermissions": { "alias": "hasEditPermissions"; "required": false; }; }, { "glossarySelectEvent": "glossarySelectEvent"; }, never, never, false, never>;
+}
+
+interface OpenCloseBtnIcons {
+    open: string;
+    close: string;
+}
+
+declare class OpenCloseButtonComponent implements OnInit {
+    private readonly openCloseBtnIcons;
+    private _isOpened;
+    disableFocusOnAction: boolean;
+    disabled: boolean;
+    isIcon: boolean;
+    ariaLabelCode: string;
+    set isOpened(value: boolean);
+    get isOpened(): boolean;
+    button: MatButton;
+    icons: OpenCloseBtnIcons;
+    defaultIcons: OpenCloseBtnIcons;
+    constructor(openCloseBtnIcons: OpenCloseBtnIcons);
+    ngOnInit(): void;
+    focus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenCloseButtonComponent, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OpenCloseButtonComponent, "lib-open-close-button", never, { "disableFocusOnAction": { "alias": "disableFocusOnAction"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "isIcon": { "alias": "isIcon"; "required": false; }; "ariaLabelCode": { "alias": "ariaLabelCode"; "required": false; }; "isOpened": { "alias": "isOpened"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class OpenCloseButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenCloseButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<OpenCloseButtonModule, [typeof OpenCloseButtonComponent], [typeof i2.CommonModule, typeof i3.TranslateModule, typeof i4.MatButtonModule, typeof i3$1.FlexLayoutModule], [typeof OpenCloseButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<OpenCloseButtonModule>;
+}
+
+declare class TerminologyModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TerminologyModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TerminologyModule, [typeof TerminologyComponent, typeof TerminologyPanelComponent, typeof TerminologyCreateCollectionComponent, typeof TerminologyCreateCollectionDialogComponent, typeof TerminologyCollectionListComponent, typeof TerminologyCollectionCardComponent], [typeof i2.CommonModule, typeof OpenCloseButtonModule, typeof i3.TranslateModule, typeof i3$1.FlexLayoutModule, typeof i8$1.FormsModule, typeof i8$1.ReactiveFormsModule, typeof CloseButtonModule, typeof DateAgoModule, typeof i4.MatButtonModule, typeof i8.MatIconModule, typeof i4$2.MatProgressSpinnerModule, typeof i6$1.MatMenuModule, typeof i18.MatRadioModule, typeof i6.MatDialogModule, typeof i4$1.MatInputModule, typeof i5.MatTooltipModule, typeof LanguageTranslateModule], [typeof TerminologyComponent, typeof TerminologyCreateCollectionComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TerminologyModule>;
+}
+
+declare const COLLECTIONS_MENU = "\n<svg version=\"1.1\" id=\"Layer_1\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" x=\"0px\" y=\"0px\"\n\t viewBox=\"0 0 15.9 20.3\" style=\"enable-background:new 0 0 15.9 20.3;\" xml:space=\"preserve\">\n<g id=\"Layer_1_00000122707316528403919840000013038058684751510177_\">\n</g>\n<g id=\"Layer_2_00000016758538246796687430000000356337115434427298_\">\n\t<polygon class=\"st0\" points=\"6.4,5.1 7.6,5.1 7,2.9 \t\"/>\n\t<path class=\"st0\" d=\"M15.7,0H3C1.3,0,0,1.3,0,2.9v12.2c0.6-0.5,1.4-0.9,2.3-0.9h13.6v-14C15.9,0.1,15.8,0,15.7,0z M9.1,7.2\n\t\tC8.9,7.3,8.8,7.3,8.6,7.3S8.2,7.2,8.2,7.1l-0.3-1H6.2l-0.3,1c0,0.2-0.2,0.2-0.4,0.2c-0.2,0-0.4-0.1-0.6-0.2c-0.2,0-0.3-0.2-0.2-0.4\n\t\tl1.5-5C6.3,1.3,6.8,1.3,7,1.3s0.7,0,0.8,0.4l1.5,5C9.4,6.9,9.3,7.1,9.1,7.2z M13.2,13.1h-2.9c-0.6,0-0.9-0.6-0.6-1.1l2.1-3.3h-1.5\n\t\tC10,8.7,9.7,8.4,9.7,8c0-0.4,0.3-0.7,0.7-0.7h2.8c0.5,0,0.9,0.6,0.6,1.1l-2.1,3.3h1.6c0.4,0,0.7,0.3,0.7,0.7\n\t\tC13.9,12.8,13.6,13.1,13.2,13.1z\"/>\n</g>\n<path class=\"st0\" d=\"M2.3,15.4c-0.4,0-0.8,0.1-1.1,0.4c-0.7,0.4-1.2,1.1-1.2,2c0,1.1,0.8,2.1,1.9,2.2C2,20,2,20,2.1,20\n\tc0.1,0,0.1,0,0.2,0c0,0,0,0,0,0c0,0,0,0,0,0h13.4c0.1,0,0.2-0.1,0.2-0.2v-4.4H2.3z\"/>\n</svg>\n";
+
+declare const OPEN_CLOSE_BTN_ICONS_TOKEN = "OPEN_CLOSE_BTN_ICONS_TOKEN";
+
+/**
+  This properties are same defined as Angular material min-width breakpoints.
+  https://material.angular.io/cdk/layout/overview
+*/
+declare const SCREEN_SIZE: {
+    SMALL: number;
+    MEDIUM: number;
+    LARGE: number;
+    XLARGE: number;
+};
+
+/**
+ * Local storage key which stores last used configuration of language direction in Machine Translation.
+ * By overwriting this value with langugeId (sourceLanguage-targetLanguage-domain-vendor-engineId), this system is going to be preselected.
+ */
+declare const LAST_USED_SYSTEM_LOCAL_STORAGE_KEY = "lastUsedSystem";
+
+declare enum ERROR_CODES {
+    TIMEOUT = 504
+}
+
+interface Voice {
+    voice: string;
+    voiceName?: string;
+}
+
+declare class TextToSpeechComponent implements OnInit {
+    #private;
+    maxCharLength: number;
+    voices: Voice[];
+    text: string;
+    previousText: string;
+    previousVoice: string;
+    audio: HTMLAudioElement;
+    isLoading: boolean;
+    isPlaying: boolean;
+    selected: Voice;
+    get hasOverflow(): boolean;
+    ngOnInit(): void;
+    togglePlay(): void;
+    stop(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextToSpeechComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextToSpeechComponent, "lib-text-to-speech", never, { "maxCharLength": { "alias": "maxCharLength"; "required": false; }; "voices": { "alias": "voices"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare enum LLMActions {
+    SUMMARY = "SUMMARY",
+    REPHRASE = "REPHRASE"
+}
+
+declare class LLMComponent {
+    dialog: MatDialog;
+    private readonly iconService;
+    private readonly languageService;
+    text: string | Observable<string> | undefined;
+    language: string | undefined;
+    rephrasableLanguagesCodeList: string[] | undefined;
+    summaryEnabled: boolean;
+    rephraseEnabled: boolean;
+    showUseCaseSummary: boolean;
+    showUseCaseRephrase: boolean;
+    newFeatureLocalStorageKey: string | undefined;
+    rephraseUseCases: LLMRephraseUseCase[] | undefined;
+    summaryUseCases: LLMSummaryUseCase[] | undefined;
+    menuTriggerClick: EventEmitter<void>;
+    readonly llmAction: typeof LLMActions;
+    get isTextSummarizable(): string | Observable<string> | undefined;
+    get isTargetLanguageRephrasable(): boolean | "" | undefined;
+    constructor(dialog: MatDialog, iconService: IconService, languageService: LanguageTranslateService);
+    openLLMModal(action: LLMActions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LLMComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LLMComponent, "lib-llm", never, { "text": { "alias": "text"; "required": false; }; "language": { "alias": "language"; "required": false; }; "rephrasableLanguagesCodeList": { "alias": "rephrasableLanguagesCodeList"; "required": false; }; "summaryEnabled": { "alias": "summaryEnabled"; "required": false; }; "rephraseEnabled": { "alias": "rephraseEnabled"; "required": false; }; "showUseCaseSummary": { "alias": "showUseCaseSummary"; "required": false; }; "showUseCaseRephrase": { "alias": "showUseCaseRephrase"; "required": false; }; "newFeatureLocalStorageKey": { "alias": "newFeatureLocalStorageKey"; "required": false; }; "rephraseUseCases": { "alias": "rephraseUseCases"; "required": false; }; "summaryUseCases": { "alias": "summaryUseCases"; "required": false; }; }, { "menuTriggerClick": "menuTriggerClick"; }, never, never, false, never>;
+}
+
+declare class LLMTextareaComponent implements OnInit, OnChanges, OnDestroy, AfterViewInit {
+    private readonly clipboard;
+    textarea: ElementRef;
+    text: string;
+    disabled: boolean;
+    actionButtonsDisabled: boolean;
+    textEditEvent: EventEmitter<any>;
+    dislikeEvent: EventEmitter<any>;
+    copyEvent: EventEmitter<any>;
+    textareaControl: FormControl;
+    private readonly destroy;
+    constructor(clipboard: Clipboard);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    dislike(): void;
+    copy(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LLMTextareaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LLMTextareaComponent, "lib-llm-textarea", never, { "text": { "alias": "text"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "actionButtonsDisabled": { "alias": "actionButtonsDisabled"; "required": false; }; }, { "textEditEvent": "textEditEvent"; "dislikeEvent": "dislikeEvent"; "copyEvent": "copyEvent"; }, never, never, false, never>;
+}
+
+interface LLMData {
+    text: Observable<string>;
+    language: string;
+    action: LLMActions;
+    showUseCaseSummary: boolean;
+    showUseCaseRephrase: boolean;
+    summaryUseCases: LLMSummaryUseCase[] | undefined;
+    rephraseUseCases: LLMRephraseUseCase[] | undefined;
+}
+
+declare enum LLMWritingStyle {
+    GENERAL = "General",
+    PROFESSIONAL = "Professional",
+    ACADEMIC = "Academic"
+}
+
+declare class LLMHelperService {
+    private readonly quotaService;
+    readonly llmConfiguration: _tilde_nlp_ngx_common.LLMConfiguration;
+    readonly trialRequestCount = 15;
+    private readonly LLMQuotaLocalStorageKey;
+    constructor(quotaService: QuotaService);
+    /**
+     * Returns remaining quota from API. If quota is missing, daily limit is being used from local storage.
+     */
+    getRemainingQuota(decrease?: boolean): Observable<number>;
+    getExceededLimitMessage(totalSymbols: number): NotificationMessage;
+    getReachedQuotaMessage(): NotificationMessage;
+    getDefaultErrorMessage(): NotificationMessage;
+    getRequestTimeoutMessage(action: LLMActions): NotificationMessage;
+    private setQuotaLocalStorageUsage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LLMHelperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LLMHelperService>;
+}
+
+declare class LLMTextareaWithActionsComponent implements OnInit {
+    private readonly llmService;
+    private readonly llmHelperService;
+    private readonly data;
+    isLoading: boolean;
+    isSummarized: boolean;
+    isEdited: boolean;
+    remainingQuotaMessageVisible: boolean;
+    quotaLeft: number;
+    maxCharLength: number;
+    subscriptionUrl: string;
+    previousWritingStyle: LLMWritingStyle;
+    selectedWritingStyle: LLMWritingStyle;
+    reachedQuotaMessage: NotificationMessage;
+    exceededLimitMessage: NotificationMessage;
+    requestTimeoutMessage: NotificationMessage;
+    defaultErrorMessage: NotificationMessage;
+    subscription: Subscription;
+    initialText: string;
+    editedText: string;
+    manuallyEditedText: string;
+    localizationKey: string;
+    llmActionType: LLMActions;
+    selectedUseCase: LLMSummaryUseCase | LLMRephraseUseCase;
+    private savedRephrasings;
+    readonly llmActions: typeof LLMActions;
+    readonly writingStyles: LLMWritingStyle[];
+    useCases: LLMSummaryUseCase[] | LLMRephraseUseCase[];
+    readonly messages: NotificationMessage[];
+    showUseCase: boolean;
+    get isDisabled(): boolean;
+    constructor(llmService: LLMService, llmHelperService: LLMHelperService, data: LLMData);
+    ngOnInit(): void;
+    closeMessage(msg: NotificationMessage): void;
+    checkRephrasedTextSaves(event: MatSelectChange): void;
+    getEditedText(): void;
+    cancel(): void;
+    textEditEvent(text: string): void;
+    copyPlausibleEvent(): void;
+    dislikePlausibleEvent(): void;
+    private setInitialText;
+    private checkTextLimit;
+    private writingStylePlausibleEvent;
+    private summaryPlausibleEvent;
+    private refreshQuota;
+    private setQuotaMessage;
+    private getRequest;
+    private getRequestCallback;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LLMTextareaWithActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LLMTextareaWithActionsComponent, "lib-llm-textarea-with-actions", never, {}, {}, never, never, false, never>;
+}
+
+interface LLMConfiguration {
+    subscriptionUrl: string;
+    supportEmail: string;
+    maxCharLength: number;
+    useLocalQuota: boolean;
+}
+
+declare const LLM_CONFIGURATION_TOKEN: InjectionToken<LLMConfiguration>;
+
+declare class LLMSummaryComponent {
+    isTextSummarizable: boolean;
+    newFeatureLocalStorageKey: string | undefined;
+    openModalEvent: EventEmitter<LLMActions>;
+    openModal(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LLMSummaryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LLMSummaryComponent, "lib-llm-summary", never, { "isTextSummarizable": { "alias": "isTextSummarizable"; "required": false; }; "newFeatureLocalStorageKey": { "alias": "newFeatureLocalStorageKey"; "required": false; }; }, { "openModalEvent": "openModalEvent"; }, never, never, false, never>;
+}
+
+declare class LLMRephraseComponent {
+    isTargetLanguageRephrasable: boolean;
+    newFeatureLocalStorageKey: string | undefined;
+    openModalEvent: EventEmitter<LLMActions>;
+    openModal(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LLMRephraseComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LLMRephraseComponent, "lib-llm-rephrase", never, { "isTargetLanguageRephrasable": { "alias": "isTargetLanguageRephrasable"; "required": false; }; "newFeatureLocalStorageKey": { "alias": "newFeatureLocalStorageKey"; "required": false; }; }, { "openModalEvent": "openModalEvent"; }, never, never, false, never>;
+}
+
+declare class NewFeatureDialogComponent {
+    data: any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NewFeatureDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NewFeatureDialogComponent, "lib-new-feature-dialog", never, {}, {}, never, never, true, never>;
+}
+
+interface MobileScreenCustomPosition {
+    autoScroll?: boolean;
+    left?: string;
+    top?: string;
+}
+
+declare class NewFeatureDialogWrapperComponent implements OnInit, OnDestroy {
+    #private;
+    titleLocalizationKey: string;
+    descriptionLocalizationKey: string;
+    closeLocalizationKey: string;
+    featureClassName: string;
+    featureLocalStorageKey: string;
+    timeout: number;
+    maxWidth: number;
+    mobileScreenCustomPosition?: MobileScreenCustomPosition;
+    dialogRef: MatDialogRef<NewFeatureDialogComponent> | undefined;
+    featureActive: i0.WritableSignal<boolean>;
+    isFeatureSeen: boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    showFeatureDialog(): void;
+    private setFeatureStatus;
+    private setFeatureSeen;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NewFeatureDialogWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NewFeatureDialogWrapperComponent, "lib-new-feature-dialog-wrapper", never, { "titleLocalizationKey": { "alias": "titleLocalizationKey"; "required": false; }; "descriptionLocalizationKey": { "alias": "descriptionLocalizationKey"; "required": false; }; "closeLocalizationKey": { "alias": "closeLocalizationKey"; "required": false; }; "featureClassName": { "alias": "featureClassName"; "required": false; }; "featureLocalStorageKey": { "alias": "featureLocalStorageKey"; "required": false; }; "timeout": { "alias": "timeout"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "mobileScreenCustomPosition": { "alias": "mobileScreenCustomPosition"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class LLMModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LLMModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LLMModule, [typeof LLMComponent, typeof LLMTextareaComponent, typeof LLMTextareaWithActionsComponent, typeof LLMSummaryComponent, typeof LLMRephraseComponent], [typeof i2.CommonModule, typeof i4.MatButtonModule, typeof i8.MatIconModule, typeof i3.TranslateModule, typeof i6.MatDialogModule, typeof i11$1.ClipboardModule, typeof i8$1.FormsModule, typeof i8$1.ReactiveFormsModule, typeof i7.MatSelectModule, typeof NotificationMessageModule, typeof i5.MatTooltipModule, typeof i3$1.FlexLayoutModule, typeof i4$2.MatProgressSpinnerModule, typeof NewFeatureDialogWrapperComponent], [typeof LLMComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LLMModule>;
+}
+
+declare class SidebarComponent {
+    #private;
+    get isOpen(): boolean;
+    get template(): i0.TemplateRef<HTMLTemplateElement> | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarComponent, "lib-sidebar", never, {}, {}, never, never, true, never>;
+}
+
+declare class SidebarService {
+    isOpen: boolean;
+    contentTemplate: TemplateRef<HTMLTemplateElement> | null;
+    showSidebar(content: TemplateRef<HTMLTemplateElement>): void;
+    hideSidebar(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SidebarService>;
+}
+
+interface Toast {
+    id: number;
+    message: string;
+    localizationParams?: any;
+}
+
+declare class ToastComponent implements OnInit {
+    #private;
+    toasts: Toast[];
+    ngOnInit(): void;
+    closeToast(id: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToastComponent, "lib-toast", never, {}, {}, never, never, true, never>;
+}
+
+declare class ToastService {
+    private toasts;
+    subject: Subject<Toast[]>;
+    watchToasts(): Observable<Toast[]>;
+    showToast(message: string, appearanceTime?: number, localizationParams?: any): void;
+    closeToast(id: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ToastService>;
+}
+
+interface Addon {
+    id: string;
+    qt: number;
+}
+
+declare enum SubscriptionPlan {
+    MTStarter = "MT-Starter",
+    MTPremium = "MT-Premium",
+    MTAdvanced = "MT-Advanced",
+    MTUnlimited = "MT-Unlimited",
+    MTWTStarter = "MT-WT-Starter",
+    MTWTPremium = "MT-WT-Premium",
+    MTWTAdvanced = "MT-WT-Advanced",
+    SpeechStarter = "Speech-Starter",
+    SpeechPremium = "Speech-Premium",
+    SpeechAdvanced = "Speech-Advanced",
+    SpeechUnlimited = "Speech-Unlimited",
+    TildeTermFreelance = "Tilde-Term-Freelance",
+    AnonymiseUnlimited = "Anonymise-Unlimited",
+    EventAssistantUnlimited = "Event-Assistant-Unlimited"
+}
+
+interface AuthSubscription {
+    PlanId: SubscriptionPlan;
+    Id: string;
+    IsTrial: boolean;
+    /** placeholder property, DO NOT USE THIS TO CHECK IF VALID SUBSCRIPTION. If subscription exists, it is valid. */
+    EndDate?: string;
+    Addons?: Addon[];
+    te?: string;
+    Label?: string;
+}
+
+interface JwtToken {
+    exp: number;
+    iat: number;
+    auth_time: number;
+    jti: string;
+    iss: string;
+    aud: string[];
+    sub: string;
+    type: string;
+    azp: string;
+    nonce: string;
+    session_state: string;
+    allowed_origins: string[];
+    realm_access: {
+        roles: string[];
+    };
+    resource_access: any;
+    scope: string;
+    sid: string;
+    email_verified: boolean;
+    role: string[];
+    name: string;
+    memberof: string[];
+    preferred_username: string;
+    subscription: AuthSubscription[];
+    given_name: string;
+    family_name: string;
+    email: string;
+}
+
+declare class CustomTitleStrategyService extends TitleStrategy {
+    #private;
+    readonly title: Title;
+    private subscription;
+    private readonly appName;
+    private readonly owner;
+    constructor();
+    updateTitle(snapshot: RouterStateSnapshot): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomTitleStrategyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CustomTitleStrategyService>;
+}
+
+declare const provideCustomTitleStrategy: () => Provider;
+
+declare class MissingTranslationHandlerService implements MissingTranslationHandler {
+    constructor();
+    handle(params: MissingTranslationHandlerParams): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MissingTranslationHandlerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MissingTranslationHandlerService>;
+}
+
+/**
+  This is an extension dialog component.
+  Use <lib-open-extension-dialog> to open this dialog, by proivding [extensions] to it you can specify what extensions should be displayed.
+*/
+declare class SelectLanguageDialogComponent implements OnInit {
+    #private;
+    languages: string[];
+    selectedLanguage: string;
+    ngOnInit(): void;
+    save(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectLanguageDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectLanguageDialogComponent, "lib-extension-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class GlobalMessageComponent {
+    text: string;
+    showCloseButton: boolean;
+    closeClick: EventEmitter<void>;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GlobalMessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GlobalMessageComponent, "lib-global-message", never, { "text": { "alias": "text"; "required": false; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; }; }, { "closeClick": "closeClick"; }, never, never, true, never>;
+}
+
+declare enum SUBSCRIPTION_STATE {
+    ACTIVE = 0,
+    TRIAL = 1,
+    ENDED = 2,
+    NONE = 3
+}
+
+interface SubscriptionQuotaDisplay extends QuotaUsage {
+    isUnlimited: boolean;
+    /** Converted to displayable measurments. E.g. if quota is counted in seconds, this maybe converted to mins or hours, depending on quota type. */
+    convertedLimit: string;
+    /** Converted to displayable measurments. E.g. if quota is counted in seconds, this maybe converted to mins or hours, depending on quota type. */
+    convertedUsed: string;
+    percentUsed: number;
+}
+
+interface ChargebeeSettings {
+    site: string;
+    script: string;
+}
+
+declare class SubscriptionComponent implements OnInit {
+    #private;
+    /** Parsed user token to get user related info */
+    readonly token: i0.InputSignal<JwtToken | undefined>;
+    /** Current user plan that app has selected */
+    readonly subscription: i0.InputSignal<AuthSubscription | undefined>;
+    /** Quota usage */
+    readonly quota: i0.InputSignal<QuotaResponse | undefined>;
+    readonly visibleQuotaTypes: i0.InputSignal<QuotaType[] | undefined>;
+    readonly contactUsUrl: i0.InputSignal<string | undefined>;
+    readonly chargebeeSettings: i0.InputSignal<ChargebeeSettings | undefined>;
+    readonly manageClick: i0.OutputEmitterRef<void>;
+    readonly contactUsClick: i0.OutputEmitterRef<void>;
+    readonly visibleQuotas: i0.Signal<SubscriptionQuotaDisplay[]>;
+    readonly subscriptionStates: typeof SUBSCRIPTION_STATE;
+    readonly subscriptionState: i0.Signal<SUBSCRIPTION_STATE>;
+    ngOnInit(): void;
+    manageClicked(): void;
+    contactUsClicked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SubscriptionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SubscriptionComponent, "lib-subscription", never, { "token": { "alias": "token"; "required": true; "isSignal": true; }; "subscription": { "alias": "subscription"; "required": true; "isSignal": true; }; "quota": { "alias": "quota"; "required": true; "isSignal": true; }; "visibleQuotaTypes": { "alias": "visibleQuotaTypes"; "required": false; "isSignal": true; }; "contactUsUrl": { "alias": "contactUsUrl"; "required": false; "isSignal": true; }; "chargebeeSettings": { "alias": "chargebeeSettings"; "required": false; "isSignal": true; }; }, { "manageClick": "manageClick"; "contactUsClick": "contactUsClick"; }, never, ["*"], true, never>;
+}
+
+export { ALERT_CONFIGURATION_TOKEN, AlertService, AuthHeadersHelper, COLLECTIONS_MENU, ClickOutsideDirective, ClickOutsideModule, CloseButtonComponent, CloseButtonModule, CombinedCollection, CombinedCollectionTooltipKey, CompanyProductComponent, CompanyProductModule, Confirmation, ConfirmationModalComponent, ConfirmationModalModule, ConfirmationService, ConversionHelper, CustomPaginatorInernationalizationHelper, CustomTitleStrategyService, DISABLE_EXPORT_ATTRIBUTE_NAME, DOMService, DateAgoModule, DateAgoPipe, DomainTranslatePipe, DragAndDropDirective, DragAndDropModule, ERROR_CODES, EngineTermApiService, EngineTermCollectionScope, EngineTermCollectionSource, EngineTermCollectionStatus, EngineTermCollectionSubStatus, ExportFormat, ExtensionDialogComponent, ExtensionDialogModule, ExtensionDialogService, FILE_SIZE_UNIT, FileCategories, FileExtensionHelper, FileExtensions, FileSizeLabelPipe, FileTypeIcons, FileTypes, FileUploadComponent, FileUploadErrorTypeEnum, FileUploadModule, FilterBarComponent, FilterBarModule, FilterWithHighlightModule, FilterWithHighlightPipe, FooterComponent, FooterModule, GlobalMessageComponent, HashHelper, HtmlElementParseHelper, HtmlHelper, IconService, InlineMessageComponent, InlineMessageIconPosition, InlineMessageModule, InlineMessageType, LAST_USED_SYSTEM_LOCAL_STORAGE_KEY, LLMActions, LLMComponent, LLMModule, LLM_CONFIGURATION_TOKEN, LanguageTranslateModule, LanguageTranslatePipe, LanguageTranslateService, MatButtonLoadingDirective, MatButtonLoadingModule, MissingTranslationHandlerService, MissingTranslationHelper, MtCollectionStatus, MultiFunctionalTableComponent, MultiFunctionalTableModule, NewFeatureDialogWrapperComponent, NotificationMessageComponent, NotificationMessageModule, NotificationMessageType, NotificationService, OPEN_CLOSE_BTN_ICONS_TOKEN, ObjectLengthModule, ObjectLengthPipe, OpenCloseButtonComponent, OpenCloseButtonModule, OpenExtensionDialogComponent, Operations, PlausibleEventDirective, PlausibleHelper, PlausibleModule, ResolutionHelper, SCREEN_SIZE, SaveFileHelper, SelectLanguageDialogComponent, SidebarComponent, SidebarService, SortAlphabeticallyModule, SortAlphabeticallyPipe, SortByNumberPipe, SortDomainsPipe, SortHelper, SortLanguageListPipe, SortTranslationsByPropertyModule, SortTranslationsByPropertyPipe, SortTranslationsModule, SortTranslationsPipe, StatusDisplayComponent, StatusDisplayModule, SubscriptionComponent, SubscriptionPlan, SystemService, TerminologyApiService, TerminologyCollectionService, TerminologyComponent, TerminologyConfigService, TerminologyCreateCollectionComponent, TerminologyModule, TerminologyService, TextToSpeechComponent, TldLoaderComponent, TldLoaderModule, ToastComponent, ToastService, getFileSizeLabel, provideCustomTitleStrategy };
+export type { ActiveData, AddEngineTermsRequestParams, Addon, AlertConfiguration, AuthSubscription, BatchConfig, Category, ChargebeeSettings, Column, ColumnConfig, ColumnSelectConfig, Config, ConfirmationBody, DefaultCollectionOrderUpdate, DialogData, Domain, DomainList, EngineTermCollection, EngineTermCollectionAccess, EngineTermCollectionAccessScope, EngineTermCollectionAccessScopeUpdate, EngineTermCollectionAccessUpdate, EngineTermCollectionList, ExportConfig, ExtensionWithIcon, FileUploadError, FilterBarChangeEvent, FilterBarFilter, FilterBarFilterItem, FilterBarSettings, ITldTermCollection, ITldTermCollectionLanguages, InlineMessage, JwtToken, LLMConfiguration, LangListItem, MobileScreenCustomPosition, MtCollection, MultiFunctionalTableConfig, NotificationMessage, NotificationWithOperation, OpenCloseBtnIcons, PaginatorConfig, PlausibleEvent, StatusDisplayConfig, System, TerminologyConfig, TranslatedLanguage, UpdateEngineTermsRequestParams, Vendor, Voice };