@tilde-nlp/ngx-translate 1.0.0

package/lib/modules/tld-text/services/tld-translate-text.service.d.ts

@@ -0,0 +1,104 @@
+import { TranslateService } from '@ngx-translate/core';
+import { Observable } from 'rxjs';
+import { TextToSpeechSettings } from '../../../components/shared/text-to-speech/models/text-to-speech-settings.model';
+import { ITldTranslateTextApiService } from '../../tld-common/models';
+import { TldAlertService, TldHighlightService, TldTranslateConfigService } from '../../tld-common/services';
+import { TldScrollService } from '../../tld-common/services/scroll/tld-scroll.service';
+import { TldSystemService } from '../../tld-tooltip/services';
+import { IDictionaryEntry, ISourceChangeEvent } from '../models/dictionary.model';
+import { IHighlightTree } from '../models/highlight-tree.model';
+import { IParagraphInfo } from '../models/highlight.model';
+import { IRetranslateParams } from '../models/retranslate-params.model';
+import * as i0 from "@angular/core";
+export declare class TldTranslateTextService {
+    private readonly api;
+    private readonly systemService;
+    private readonly tldScrollService;
+    private readonly configService;
+    private readonly translate;
+    private readonly highlightService;
+    private readonly alertsService;
+    private _sourceText;
+    get sourceText(): string;
+    private _sourceTextHypothesis;
+    get sourceTextHypothesis(): string;
+    private _sourceChange;
+    get sourceChange(): Observable<ISourceChangeEvent>;
+    private _sourceScroll;
+    get sourceScroll(): Observable<number>;
+    private _translateButtonClick;
+    get translateButtonClick(): Observable<any>;
+    private _hasDictionary;
+    get hasDictionary(): boolean;
+    set hasDictionary(val: boolean);
+    private _dictionaryEntry;
+    get dictionaryEntry(): IDictionaryEntry[];
+    set dictionaryEntry(val: IDictionaryEntry[]);
+    get translatedText(): string;
+    private readonly _onClear;
+    urlToTranslate: string;
+    paragraphs: IParagraphInfo[];
+    sourceParagraphs: IHighlightTree[];
+    targetParagraphs: IHighlightTree[];
+    textToSpeechSourceSettings: TextToSpeechSettings;
+    textToSpeechTargetSettings: TextToSpeechSettings;
+    private _firstParagraphTranslated;
+    get firstParagraphTranslated(): boolean;
+    private dictionarySubscription;
+    private paragraphTranslationsSubject;
+    private paragraphTranslationSubscription;
+    private readonly debouncer;
+    private debouncerSubscription;
+    /** How many paragraphs can be translated at the same time. */
+    private readonly CONCURRENT_UPLOADS;
+    private readonly DEBOUNCE_TIME;
+    /** Whether progress indicator should be shown. This value must be set to true only if configured time has passed. */
+    private _shouldShowProgressIndicator;
+    get shouldShowProgressIndicator(): boolean;
+    private progressIndicatorTimeout;
+    private _untranslatedParagraphCount;
+    get untranslatedParagraphCount(): number;
+    set untranslatedParagraphCount(value: number);
+    get isTranslating(): boolean;
+    get allowWebsiteTranslation(): boolean;
+    get autoRedirectToWebTranslate(): boolean;
+    get webWidgetRedirectUrlPrefix(): string;
+    get webWidgetRedirectUrlPosfix(): string;
+    get useDictionary(): boolean;
+    get progressIndicatorTimeoutMiliSeconds(): number;
+    get activeData(): import("../../tld-common/models").System;
+    get translateUrlRedirect(): string;
+    /** If dictattion is active. Based on this, extensions are hidden. */
+    isDictating: boolean;
+    constructor(api: ITldTranslateTextApiService, systemService: TldSystemService, tldScrollService: TldScrollService, configService: TldTranslateConfigService, translate: TranslateService, highlightService: TldHighlightService, alertsService: TldAlertService);
+    dictionaryTranslation(text: string, srcCode: string, trgCode: string): any;
+    changeSource(event: ISourceChangeEvent): void;
+    changeSourceHypothesis(text: string): void;
+    onSourceScroll(offsetTop: number): void;
+    onTranslateButtonClick(): void;
+    clearSource(): void;
+    onClear(): Observable<any>;
+    updateTranslation(options: string, systemID: string, text: string, translation: string): any;
+    listenOnChanges(): void;
+    stopListeningToChanges(): void;
+    retranslate(params?: IRetranslateParams): void;
+    /** Stops text translation if it is active. */
+    stopTranslation(): void;
+    private recreateParagraphTranslationSubject;
+    private translateParagraph;
+    private handleTranslatedParagraph;
+    private updateParagraphs;
+    private clearSourceParams;
+    private prepareAndTranslateWords;
+    private translateText;
+    /** Creates timeout which enables progress indicator after given miliseconds */
+    private setProgressIndicatorTimeout;
+    /** Method for setting necessary properties to make progress indicator visible. */
+    private showProgressIndicator;
+    /** Method for setting necessary properties to make progress indicator hidden. */
+    hideProgressIndicator(): void;
+    private toggleTextToSpeech;
+    private findTextToSpeechSettings;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldTranslateTextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TldTranslateTextService>;
+}

package/lib/modules/tld-text/tld-text.module.d.ts

@@ -0,0 +1,27 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./components/tld-translate-source/tld-translate-source.component";
+import * as i2 from "./components/tld-translate-suggest/tld-translate-suggest.component";
+import * as i3 from "./components/tld-translate-suggest/dialog/tld-translate-suggest-dialog.component";
+import * as i4 from "./components/tld-translate-text/tld-translate-text.component";
+import * as i5 from "./components/tld-dictionary/tld-dictionary.component";
+import * as i6 from "./components/textarea-with-background/textarea-with-background.component";
+import * as i7 from "./components/highlight-tree/highlight-tree.component";
+import * as i8 from "./components/progress-indicator/progress-indicator.component";
+import * as i9 from "@angular/common";
+import * as i10 from "@ngx-translate/core";
+import * as i11 from "../material.module";
+import * as i12 from "@angular/forms";
+import * as i13 from "../tld-common/tld-common.module";
+import * as i14 from "@angular/cdk/clipboard";
+import * as i15 from "../tld-audio/tld-audio.module";
+import * as i16 from "@tilde-nlp/ngx-common";
+import * as i17 from "../../components/shared/extension-dialog/extension-dialog.module";
+import * as i18 from "@angular/cdk/layout";
+import * as i19 from "@angular/material/progress-bar";
+import * as i20 from "../../components/shared/vendor-disclaimer/vendor-disclaimer.module";
+import * as i21 from "../../components/shared/text-to-speech/text-to-speech.module";
+export declare class TldTextModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldTextModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TldTextModule, [typeof i1.TldTranslateSourceComponent, typeof i2.TldTranslateSuggestComponent, typeof i3.TldTranslateSuggestDialogComponent, typeof i4.TldTranslateTextComponent, typeof i5.TldDictionaryComponent, typeof i6.TextareaWithBackgroundComponent, typeof i7.HighlightTreeComponent, typeof i8.ProgressIndicatorComponent], [typeof i9.CommonModule, typeof i10.TranslateModule, typeof i11.MaterialModule, typeof i12.FormsModule, typeof i13.TldCommonModule, typeof i14.ClipboardModule, typeof i15.TldAudioModule, typeof i16.CloseButtonModule, typeof i17.ExtensionDialogModule, typeof i18.LayoutModule, typeof i19.MatProgressBarModule, typeof i20.VendorDisclaimerModule, typeof i21.TextToSpeechModule], [typeof i1.TldTranslateSourceComponent, typeof i2.TldTranslateSuggestComponent, typeof i4.TldTranslateTextComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TldTextModule>;
+}

package/lib/modules/tld-text/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './models';

package/lib/modules/tld-text/utils/models/existing-paragraph-info.model.d.ts

@@ -0,0 +1,5 @@
+import { IParagraphInfo } from "../../models/highlight.model";
+export interface IExistingParagraphInfo {
+    hasSameIx: boolean;
+    existingParagraph: IParagraphInfo;
+}

package/lib/modules/tld-text/utils/models/index.d.ts

@@ -0,0 +1 @@
+export * from './existing-paragraph-info.model';

package/lib/modules/tld-text/utils/tld-translate-text.utils.d.ts

@@ -0,0 +1,9 @@
+import { IHighlightTree } from "../models/highlight-tree.model";
+import { IParagraphInfo } from "../models/highlight.model";
+import { IExistingParagraphInfo } from "./models/existing-paragraph-info.model";
+export declare class TldTranslateTextUtils {
+    /** Finds paragraph in given array, by comparing its text. This is helpful to use to check if parahraph is already translated. */
+    static findExistingParagraph(searchParagraph: string, searchParagraphIx: number, paragraphs: IParagraphInfo[]): IExistingParagraphInfo;
+    static changeRootAndParagraphIx(tree: IHighlightTree, root: IHighlightTree, paragraphIx: number): void;
+    static createEmptyParagraphInfo(ix: number): IParagraphInfo;
+}

package/lib/modules/tld-tooltip/index.d.ts

@@ -0,0 +1,4 @@
+export * from './tld-tooltip.module';
+export * from './tld-translate-switcher/tld-translate-switcher.component';
+export * from './tld-domain-list/tld-domain-list.component';
+export * from './translation-system-picker';

package/lib/modules/tld-tooltip/models/active-data.model.d.ts

@@ -0,0 +1,24 @@
+import { ILangListItem } from '../../tld-common/models/lang-list-item.model';
+import { System } from '../../tld-common/models/services/system/system.model';
+import { IDomainList } from './domain.model';
+import { IVendor } from './vendor.model';
+/**
+ * Interface describes active system
+ */
+export interface IActiveData {
+    systemId?: string;
+    sourceLang?: ILangListItem;
+    targetLang?: ILangListItem;
+    sourceLangList?: Array<ILangListItem>;
+    targetLangList?: Array<ILangListItem>;
+    domains?: IDomainList;
+    vendors?: IVendor[];
+    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[];
+}

package/lib/modules/tld-tooltip/models/domain.model.d.ts

@@ -0,0 +1,8 @@
+export interface IDomainList {
+    domains: IDomain[];
+    active: IDomain | undefined;
+}
+export interface IDomain {
+    domain: string;
+    title: string;
+}

package/lib/modules/tld-tooltip/models/index.d.ts

@@ -0,0 +1,4 @@
+export * from './active-data.model';
+export * from './domain.model';
+export * from './vendor.model';
+export * from './switcher-options.model';

package/lib/modules/tld-tooltip/models/switcher-options.model.d.ts

@@ -0,0 +1,14 @@
+import { IDomainList } from "./domain.model";
+import { ILangListItem } from "../../tld-common/models/lang-list-item.model";
+import { IVendor } from "./vendor.model";
+import { ISelectedLanguage } from "../../tld-common/models";
+export interface ISwitcherTranslationOptions {
+    domains: IDomainList;
+    systemId: string;
+    sourceLanguageList: ILangListItem[];
+    source: ISelectedLanguage;
+    targetLanguageList: ILangListItem[];
+    target: ISelectedLanguage;
+    vendors: IVendor[];
+    swapActive: boolean;
+}

package/lib/modules/tld-tooltip/models/system-metadata-keys.model.d.ts

@@ -0,0 +1,5 @@
+export declare enum SystemMetadataKey {
+    VENDOR = "vendor",
+    STATUS = "status",
+    INCLUDE_TERMINOLOGY_WORKFLOW = "include-terminology-workflow"
+}

package/lib/modules/tld-tooltip/models/vendor.model.d.ts

@@ -0,0 +1,4 @@
+export interface IVendor {
+    title: string;
+    systemId: string;
+}

package/lib/modules/tld-tooltip/services/api/models/description.model.d.ts

@@ -0,0 +1,4 @@
+export interface IDescription {
+    Language?: any;
+    Text?: any;
+}

package/lib/modules/tld-tooltip/services/api/models/language.model.d.ts

@@ -0,0 +1,5 @@
+import { IName } from './name.model';
+export interface ILanguage {
+    Code?: string;
+    Name?: IName;
+}

package/lib/modules/tld-tooltip/services/api/models/metadata.model.d.ts

@@ -0,0 +1,4 @@
+export interface IMetadata {
+    Key: string;
+    Value: string;
+}

package/lib/modules/tld-tooltip/services/api/models/name.model.d.ts

@@ -0,0 +1,4 @@
+export interface IName {
+    Language: string;
+    Text: string;
+}

package/lib/modules/tld-tooltip/services/api/models/system.model.d.ts

@@ -0,0 +1,14 @@
+import { IDescription } from './description.model';
+import { ILanguage } from './language.model';
+import { IMetadata } from './metadata.model';
+import { IName } from './name.model';
+export interface IApiSystem {
+    Description: IDescription;
+    Domain: string;
+    ID: string;
+    Metadata: IMetadata[];
+    SourceLanguage: ILanguage;
+    TargetLanguage: ILanguage;
+    Title: IName;
+    order?: number;
+}

package/lib/modules/tld-tooltip/services/api/tld-system-api.service.d.ts

@@ -0,0 +1,15 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { ITldSystemApiService } from '../../../tld-common/models';
+import { System } from '../../../tld-common/models/services/system/system.model';
+import { TldTranslateConfigService } from '../../../tld-common/services';
+import * as i0 from "@angular/core";
+export declare class TldSystemApiService implements ITldSystemApiService {
+    private readonly config;
+    private readonly http;
+    constructor(config: TldTranslateConfigService, http: HttpClient);
+    getSystemList(): Observable<System[]>;
+    private findMetaDataValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldSystemApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TldSystemApiService>;
+}

package/lib/modules/tld-tooltip/services/api-v2/models/error.model.d.ts

@@ -0,0 +1,4 @@
+export interface IError {
+    code: number;
+    message: string;
+}

package/lib/modules/tld-tooltip/services/api-v2/models/get-langauge-direction.d.ts

@@ -0,0 +1,6 @@
+import { IError } from "./error.model";
+import { ILanguageDirection } from "./language-direction.model";
+export interface IGetLanguageDirection {
+    languageDirections: ILanguageDirection[];
+    error: IError;
+}

package/lib/modules/tld-tooltip/services/api-v2/models/language-direction.model.d.ts

@@ -0,0 +1,7 @@
+export interface ILanguageDirection {
+    srcLang: string;
+    trgLang: string;
+    domain: string;
+    vendor: string;
+    id: string;
+}

package/lib/modules/tld-tooltip/services/api-v2/tld-system-api-v2.service.d.ts

@@ -0,0 +1,15 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { TldTranslateConfigService } from '../../../tld-common/services';
+import { System } from '../../../tld-common/models/services/system/system.model';
+import { ITldSystemApiService } from '../../../tld-common/models';
+import * as i0 from "@angular/core";
+export declare class TldSystemApiV2Service implements ITldSystemApiService {
+    private readonly config;
+    private readonly http;
+    constructor(config: TldTranslateConfigService, http: HttpClient);
+    getSystemList(): Observable<System[]>;
+    private createSystemFromLanguageDirection;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldSystemApiV2Service, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TldSystemApiV2Service>;
+}

package/lib/modules/tld-tooltip/services/index.d.ts

@@ -0,0 +1 @@
+export * from './tld-system.service';

package/lib/modules/tld-tooltip/services/tld-system.service.d.ts

@@ -0,0 +1,57 @@
+import { ReplaySubject } from 'rxjs';
+import { ILangListItem, ITldSystemApiService } from '../../tld-common/models';
+import { System } from '../../tld-common/models/services/system/system.model';
+import { TldTranslateConfigService } from '../../tld-common/services';
+import { IActiveData } from '../models/active-data.model';
+import { IDomain } from '../models/domain.model';
+import * as i0 from "@angular/core";
+export declare class TldSystemService {
+    private readonly config;
+    private readonly api;
+    private readonly apiVersion;
+    noSystemsError: boolean;
+    systems: System[];
+    widgetInitialized: boolean;
+    sysList: ReplaySubject<System[]>;
+    activeDomain: IDomain;
+    canSwapLanguages: boolean;
+    get activeVendor(): string;
+    get defaultVendor(): string;
+    get defaultDomains(): string[];
+    private activeSystem;
+    private domains;
+    private vendors;
+    private sourceLanguage;
+    private targetLanguage;
+    private sourceLangList;
+    private targetLangList;
+    get recentSystemsMaxCount(): number;
+    private recentSystems;
+    private readonly recentSystemKey;
+    private readonly active;
+    private readonly lastUsedSystemKey;
+    constructor(config: TldTranslateConfigService, api: ITldSystemApiService, apiVersion: any);
+    getSystems(): System[];
+    changeLanguage(source: string, target: string): void;
+    getActiveData(): import("rxjs").Observable<IActiveData>;
+    getActiveSystemObj(): System;
+    getActiveVendorsAndDomains(): void;
+    getLastUsedSystem(): string;
+    getUniqueLanguages(list: ILangListItem[]): string[];
+    init(defaultSystemId: string): void;
+    setLastUsedSystem(systemId: string): void;
+    swapSystemLanguages(): void;
+    changeSystem(systemId: string, retranslate?: boolean): void;
+    systemExists(systemId: string, systemList: System[]): boolean;
+    isTerminologySupported(system: System): boolean;
+    changeSourceLanguage(sourceLanguageCode: string): void;
+    changeTargetLanguage(targetLanguageCode: string): void;
+    private createRecentSystemArray;
+    private addToRecentSystemArray;
+    private canSwapSystemLanguages;
+    private createLangList;
+    private findCorrectSystem;
+    private onActiveSystemChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldSystemService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TldSystemService>;
+}

package/lib/modules/tld-tooltip/tld-domain-list/tld-domain-list.component.d.ts

@@ -0,0 +1,33 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { TranslateDomainPipe } from '../../tld-common/pipes/translate-domain.pipe';
+import { TldTranslateConfigService } from '../../tld-common/services/tld-translate-config.service';
+import { IDomain } from '../models/domain.model';
+import * as i0 from "@angular/core";
+export declare class TldDomainListComponent implements OnInit {
+    private readonly translate;
+    private readonly config;
+    private readonly translateDomainPipe;
+    private _list;
+    get list(): IDomain[];
+    set list(value: IDomain[]);
+    private _selected;
+    get selected(): IDomain;
+    set selected(value: IDomain);
+    disabled: boolean;
+    selectionChange: EventEmitter<any>;
+    get showTitle(): boolean;
+    translations: any;
+    translatedList: IDomain[];
+    selectedDomainName: string;
+    currentLanguage: string;
+    readonly titleKey: string;
+    readonly valueKey = "domain";
+    constructor(translate: TranslateService, config: TldTranslateConfigService, translateDomainPipe: TranslateDomainPipe);
+    ngOnInit(): void;
+    select(element: any): void;
+    private retranslate;
+    private translateDomainName;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldDomainListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TldDomainListComponent, "tld-domain-list", never, { "list": "list"; "selected": "selected"; "disabled": "disabled"; }, { "selectionChange": "selectionChange"; }, never, never, false>;
+}

package/lib/modules/tld-tooltip/tld-tooltip.module.d.ts

@@ -0,0 +1,25 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./tld-translate-switcher/tld-translate-switcher.component";
+import * as i2 from "./tld-domain-list/tld-domain-list.component";
+import * as i3 from "./translation-system-picker/translation-system-picker.component";
+import * as i4 from "./translation-system-picker/dropdown/translation-system-picker-dropdown.component";
+import * as i5 from "./translation-system-picker/language-list/translation-system-picker-language-list.component";
+import * as i6 from "./translation-system-picker/system-list/translation-system-picker-system-list.component";
+import * as i7 from "./translation-system-picker/filter/translation-system-picker-filter.component";
+import * as i8 from "./translation-system-picker/dropdown-body/translation-system-picker-dropdown-body.component";
+import * as i9 from "./translation-system-picker/system-picker-button/translation-system-picker-button.component";
+import * as i10 from "@angular/forms";
+import * as i11 from "@angular/common";
+import * as i12 from "@angular/platform-browser";
+import * as i13 from "@angular/flex-layout";
+import * as i14 from "../material.module";
+import * as i15 from "@ngx-translate/core";
+import * as i16 from "../tld-common/tld-common.module";
+import * as i17 from "../tld-term/tld-term.module";
+import * as i18 from "@angular/platform-browser/animations";
+import * as i19 from "@tilde-nlp/ngx-common";
+export declare class TldTooltipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldTooltipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TldTooltipModule, [typeof i1.TldTranslateSwitcherComponent, typeof i2.TldDomainListComponent, typeof i3.TranslationSystemPickerComponent, typeof i4.TranslationSystemPickerDropdownComponent, typeof i5.TranslationSystemPickerLanguageListComponent, typeof i6.TranslationSystemPickerSystemListComponent, typeof i7.TranslationSystemPickerFilterComponent, typeof i8.TranslationSystemPickerDropdownBodyComponent, typeof i9.TranslationSystemPickerButtonComponent], [typeof i10.FormsModule, typeof i11.CommonModule, typeof i12.BrowserModule, typeof i13.FlexLayoutModule, typeof i14.MaterialModule, typeof i15.TranslateModule, typeof i16.TldCommonModule, typeof i17.TldTermModule, typeof i18.BrowserAnimationsModule, typeof i19.SortTranslationsModule, typeof i19.FilterWithHighlightModule, typeof i19.ClickOutsideModule], [typeof i1.TldTranslateSwitcherComponent, typeof i2.TldDomainListComponent, typeof i3.TranslationSystemPickerComponent, typeof i4.TranslationSystemPickerDropdownComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TldTooltipModule>;
+}

package/lib/modules/tld-tooltip/tld-translate-switcher/tld-translate-switcher.component.d.ts

@@ -0,0 +1,64 @@
+import { AfterViewInit, ElementRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { TldTranslateConfigService } from '../../tld-common/services';
+import { ISwitcherTranslationOptions } from '../models/switcher-options.model';
+import { TldSystemService } from '../services/tld-system.service';
+import * as i0 from "@angular/core";
+export declare class TldTranslateSwitcherComponent implements OnInit, AfterViewInit, OnDestroy {
+    private readonly config;
+    private readonly tldSystem;
+    private elRef;
+    wrapper: ElementRef;
+    fromLabel: ElementRef;
+    sourceAside: ElementRef;
+    toLabel: ElementRef;
+    domainWrapper: ElementRef;
+    vendorWrapper: ElementRef;
+    collectionWrapper: ElementRef;
+    onResize(): void;
+    buttonDisabled: boolean;
+    showTranslateButton: boolean;
+    hideOnSmallScreens: boolean;
+    disabled: boolean;
+    hideLangMenuLabels: boolean;
+    maxDisplayedLanguages: number;
+    collections: any[];
+    showDomainsWithLanguageName: boolean;
+    isCollectionsActivated: boolean;
+    /** If this is set to true, component parent is checked for displayed language count. */
+    useParentWidth: boolean;
+    /** Show loader instead of translate button */
+    loader: boolean;
+    settings: ISwitcherTranslationOptions;
+    onDomainChange: EventEmitter<string>;
+    onActionClick: EventEmitter<any>;
+    onSourceLanguageChange: EventEmitter<any>;
+    onTargetLanguageChange: EventEmitter<any>;
+    onLanguageSwap: EventEmitter<string>;
+    onVendorChange: EventEmitter<string>;
+    languageCountByScreenSize: number;
+    get visibleLanguageCount(): number;
+    get collectionsVisible(): boolean;
+    get showVendors(): boolean;
+    get showDomains(): import("@tilde-nlp/ngx-translate").ISelectedLanguage;
+    get isSwapLanguagesDisabled(): boolean;
+    get domainSide(): "src" | "trg";
+    get swapIconPosition(): "src" | "center";
+    private readonly destroy$;
+    readonly srcLangTestId = "src-lang-menu";
+    readonly trgLangTestId = "trg-lang-menu";
+    private isTerminologySupported;
+    constructor(config: TldTranslateConfigService, tldSystem: TldSystemService, elRef: ElementRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    actionClick(): void;
+    domainChange(systemId: string): void;
+    sourceLangChange(language: string): void;
+    swapSourceAndTarget(): void;
+    targetLangChange(language: string): void;
+    vendorChange(systemId: string): void;
+    private getElementRefWidth;
+    private subscribeToActiveData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldTranslateSwitcherComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TldTranslateSwitcherComponent, "tld-translate-switcher", never, { "buttonDisabled": "buttonDisabled"; "showTranslateButton": "showTranslateButton"; "hideOnSmallScreens": "hideOnSmallScreens"; "disabled": "disabled"; "hideLangMenuLabels": "hideLangMenuLabels"; "maxDisplayedLanguages": "maxDisplayedLanguages"; "collections": "collections"; "showDomainsWithLanguageName": "showDomainsWithLanguageName"; "isCollectionsActivated": "isCollectionsActivated"; "useParentWidth": "useParentWidth"; "loader": "loader"; "settings": "settings"; }, { "onDomainChange": "onDomainChange"; "onActionClick": "onActionClick"; "onSourceLanguageChange": "onSourceLanguageChange"; "onTargetLanguageChange": "onTargetLanguageChange"; "onLanguageSwap": "onLanguageSwap"; "onVendorChange": "onVendorChange"; }, never, never, false>;
+}

package/lib/modules/tld-tooltip/translation-system-picker/dropdown/translation-system-picker-dropdown.component.d.ts

@@ -0,0 +1,44 @@
+import { BreakpointObserver } from '@angular/cdk/layout';
+import { OnDestroy, OnInit } from '@angular/core';
+import { TranslationSystemPickerDropdownBodyComponent } from '../dropdown-body/translation-system-picker-dropdown-body.component';
+import { TranslationSystemPickerFilterComponent } from '../filter/translation-system-picker-filter.component';
+import { DropdownBodyConfig } from '../models/dropdown-body-config.model';
+import { TranslationSystemPickerService } from '../services/translation-system-picker.service';
+import * as i0 from "@angular/core";
+export declare class TranslationSystemPickerDropdownComponent implements OnInit, OnDestroy {
+    private readonly systemPickerService;
+    private readonly breakPointObserver;
+    onKeydownHandler(): void;
+    dropdownBody: TranslationSystemPickerDropdownBodyComponent;
+    filter: TranslationSystemPickerFilterComponent;
+    filterText: string;
+    isMobile: boolean;
+    showMobFilter: boolean;
+    private currentStep;
+    private breakpointSubscription;
+    private menuToggleSubscription;
+    get selectedBodyConfig(): DropdownBodyConfig;
+    bodyConfigArr: DropdownBodyConfig[];
+    get currentConfig(): DropdownBodyConfig;
+    private readonly mobileTargetConfig;
+    private readonly mobileSourceConfig;
+    private readonly desktopTargetConfig;
+    constructor(systemPickerService: TranslationSystemPickerService, breakPointObserver: BreakpointObserver);
+    ngOnInit(): void;
+    onSystemClick(): void;
+    onLanguageClick(): void;
+    onFilteredLanguageClick(): void;
+    close(): void;
+    filterChange(filter: string): void;
+    ngOnDestroy(): void;
+    toggleFilter(): void;
+    clearFilter(): void;
+    back(): void;
+    nextStep(): void;
+    clickOutside(): void;
+    private subscribeToBreakpointObserver;
+    private selectBodyConfig;
+    private subscribeToMenuToggle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslationSystemPickerDropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TranslationSystemPickerDropdownComponent, "tld-translation-system-picker-dropdown", never, {}, {}, never, never, false>;
+}

package/lib/modules/tld-tooltip/translation-system-picker/dropdown-body/translation-system-picker-dropdown-body.component.d.ts

@@ -0,0 +1,65 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { TldSystemService } from '../../services/tld-system.service';
+import { DropdownBodyConfig, TranslatedSystem } from '../models';
+import { GroupedLanguageItem } from '../models/grouped-language-item';
+import { TranslatedLanguage } from '../models/translated-language.model';
+import { TranslationSystemPickerService } from '../services/translation-system-picker.service';
+import * as i0 from "@angular/core";
+export declare class TranslationSystemPickerDropdownBodyComponent implements OnInit {
+    private readonly systemService;
+    private readonly translate;
+    private readonly systemPickerService;
+    set filterText(val: string);
+    config: DropdownBodyConfig;
+    onSystemClick: EventEmitter<TranslatedSystem>;
+    onLanguageClick: EventEmitter<TranslatedLanguage>;
+    onFilteredLanguageClick: EventEmitter<TranslatedLanguage>;
+    systemList: TranslatedSystem[];
+    systemListTitle: string;
+    showFiltered: boolean;
+    get showSystems(): boolean;
+    get showLanguages(): boolean;
+    get showSystemTitle(): boolean;
+    get showLanguageTitle(): boolean;
+    private menuState;
+    private activeData;
+    private systemSubscription;
+    private langSubscription;
+    private menuToggleSubscription;
+    private languageAndDomainTranslations;
+    private readonly languagesLocalizationKey;
+    private readonly domainsLocalizationKey;
+    private readonly recentSystemTitleKey;
+    private readonly domainsTitleKey;
+    private readonly filterHighlightPipe;
+    get recentSystems(): import("@tilde-nlp/ngx-translate").System[];
+    get domains(): import("@tilde-nlp/ngx-translate").IDomain[];
+    get activeSystemId(): string;
+    allLanguages: TranslatedLanguage[];
+    filteredLanguages: TranslatedLanguage[];
+    groupedLanguages: GroupedLanguageItem[];
+    activeLanguageCode: string;
+    constructor(systemService: TldSystemService, translate: TranslateService, systemPickerService: TranslationSystemPickerService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    close(): void;
+    filterLanguages(filter: string): void;
+    languageClick(language: TranslatedLanguage): void;
+    filteredLanguageClick(language: TranslatedLanguage): void;
+    systemClick(system: TranslatedSystem): void;
+    private subscribeToMenuToggle;
+    private onMenuToggle;
+    private setActiveLanguageCode;
+    private subscribeToActiveSystemData;
+    private subscribeToLanguageChange;
+    private retranslate;
+    private translateSystems;
+    private getTranslatedDomains;
+    private getTranslatedRecentSystems;
+    private sortLanguages;
+    private getLanguageDisplayName;
+    private getDomainDisplayName;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslationSystemPickerDropdownBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TranslationSystemPickerDropdownBodyComponent, "tld-translation-system-picker-dropdown-body", never, { "filterText": "filterText"; "config": "config"; }, { "onSystemClick": "onSystemClick"; "onLanguageClick": "onLanguageClick"; "onFilteredLanguageClick": "onFilteredLanguageClick"; }, never, never, false>;
+}