@tilde-nlp/ngx-translate 1.0.0

package/lib/modules/tld-document/services/api/models/get-file-translation-status-v1-response.model.d.ts

@@ -0,0 +1,11 @@
+import { TranslationStatuss } from '../../../models';
+export interface IGetFileTranslationStatusV1Response {
+    status: TranslationStatuss;
+    completed: number;
+    filename: string;
+    warnings: string;
+    reload: boolean;
+    translations: {
+        [key: string]: string;
+    };
+}

package/lib/modules/tld-document/services/api-v2/file-api-v2.service.d.ts

@@ -0,0 +1,22 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { IDownloadFileParams, IFileApiService, IGetFileStatusParams, IGetFileTranslationStatusResponse, IRemoveFileParams, ISourceFilePreviewResponse, IStartFileTranslationParams, ITranslatedDocumentPreviewParams } from '../../../tld-common/models';
+import { TldTranslateConfigService } from '../../../tld-common/services';
+import { ITranslationFile } from '../../models/translate-file.model';
+import * as i0 from "@angular/core";
+export declare class FileApiV2Service implements IFileApiService {
+    private readonly http;
+    private readonly config;
+    private get url();
+    constructor(http: HttpClient, config: TldTranslateConfigService);
+    translatedDocumentPreview(properties: ITranslatedDocumentPreviewParams): Observable<{
+        success: boolean;
+    }>;
+    download(properties: IDownloadFileParams): Observable<Blob>;
+    startTranslation(properties: IStartFileTranslationParams): Observable<string>;
+    remove(properties: IRemoveFileParams): Observable<any>;
+    sourceFilePreview(file: ITranslationFile): Observable<ISourceFilePreviewResponse>;
+    getStatus(properties: IGetFileStatusParams): Observable<IGetFileTranslationStatusResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileApiV2Service, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FileApiV2Service>;
+}

package/lib/modules/tld-document/services/api-v2/models/file-category-v2.model.d.ts

@@ -0,0 +1,4 @@
+export declare enum FileV2Category {
+    SOURCE = "SOURCE",
+    TRANSLATED = "TRANSLATED"
+}

package/lib/modules/tld-document/services/api-v2/models/file-translation-status-v2-response.model.d.ts

@@ -0,0 +1,20 @@
+export interface IFileTranslationStatusV2Response {
+    id: string;
+    createdAt: string;
+    fileName: string;
+    srcLang: string;
+    trgLang: string;
+    domain: string;
+    status: string;
+    substatus: string;
+    segments: number;
+    translatedSegments: number;
+    files: [
+        {
+            id: string;
+            category: string;
+            extension: string;
+            size: 0;
+        }
+    ];
+}

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

@@ -0,0 +1,2 @@
+export * from './api/file-api.service';
+export * from './tld-translate-file.service';

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

@@ -0,0 +1,60 @@
+import { DomSanitizer } from '@angular/platform-browser';
+import { Observable } from 'rxjs';
+import { IFileApiService, IFileMeta, IFileUploadError } from '../../tld-common/models';
+import { TldAlertService, TldTranslateConfigService } from '../../tld-common/services';
+import { IActiveData } from '../../tld-tooltip/models';
+import { TldSystemService } from '../../tld-tooltip/services';
+import { ITranslationFile } from '../models/translate-file.model';
+import * as i0 from "@angular/core";
+export declare class TldTranslateFileService {
+    private readonly fileApi;
+    private readonly alerts;
+    private sanitizer;
+    private config;
+    private readonly tldSystem;
+    translationStarted: boolean;
+    /** Value to be set to true while loading source preview. At that time, translate button should be disabled. */
+    get isUploadingFile(): boolean;
+    translationFiles: ITranslationFile[];
+    fileNames: string[];
+    filesAdded: number;
+    anyPdfFileLoaded: boolean;
+    anyImageFileLoaded: boolean;
+    translatedCount: number;
+    multipleFileUploadActive: boolean;
+    get disableTranslateButton(): boolean;
+    private readonly _onFilesUploaded;
+    private activeSystem;
+    private readonly _defaultStatusCheckTimeout;
+    private readonly _retryErrorCodes;
+    private readonly _networkErrorMaxRetries;
+    private readonly _statusTimeouts;
+    private readonly _onClear;
+    private readonly _supportedImageExtensions;
+    private filesUploading;
+    constructor(fileApi: IFileApiService, alerts: TldAlertService, sanitizer: DomSanitizer, config: TldTranslateConfigService, tldSystem: TldSystemService);
+    clear(): void;
+    onClear(): Observable<any>;
+    onFilesUploaded(): Observable<any>;
+    remove(file: ITranslationFile): void;
+    downloadTarget(translationFile: ITranslationFile, fileMeta: IFileMeta): void;
+    downloadSource(translationFile: ITranslationFile): void;
+    loadFilePreview(file: File): ITranslationFile;
+    translateButtonClick(active: IActiveData): void;
+    startFileTranslation(activeSystem: IActiveData, translationFile: ITranslationFile): void;
+    convertedSourceFileName(fileName: string): string;
+    fileUploadError(error: IFileUploadError): void;
+    private canStartTranslation;
+    private checkTranslationProgress;
+    private onFilePreviewLoad;
+    private translatedDocPreview;
+    private fileApiError;
+    private filePreviewAlerts;
+    private onError;
+    private fileUploaded;
+    private hasAnyImageOrPdf;
+    private clearParams;
+    private onTranslationFileError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldTranslateFileService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TldTranslateFileService>;
+}

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

@@ -0,0 +1,19 @@
+import * as i0 from "@angular/core";
+import * as i1 from "../tld-translate-file/tld-translate-file.component";
+import * as i2 from "./tld-translate-file-multiple/tld-translate-file-multiple.component";
+import * as i3 from "./download-button/download-button.component";
+import * as i4 from "./pdf-conversion-help/pdf-conversion-help.component";
+import * as i5 from "./image-conversion-help/image-conversion-help.component";
+import * as i6 from "./tld-file-translate-base.component";
+import * as i7 from "@angular/common";
+import * as i8 from "../tld-common/tld-common.module";
+import * as i9 from "@ngx-translate/core";
+import * as i10 from "@angular/flex-layout";
+import * as i11 from "../material.module";
+import * as i12 from "@tilde-nlp/ngx-common";
+import * as i13 from "../../components/shared/vendor-disclaimer/vendor-disclaimer.module";
+export declare class TldDocumentModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldDocumentModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TldDocumentModule, [typeof i1.TldTranslateFileComponent, typeof i2.TldTranslateFileMultipleComponent, typeof i3.TldTranslateFileDownloadButtonComponent, typeof i4.TldTranslatePdfConversionHelpComponent, typeof i5.TldTranslateImageConversionHelpComponent, typeof i6.TldFileTranslateBaseComponent], [typeof i7.CommonModule, typeof i8.TldCommonModule, typeof i9.TranslateModule, typeof i10.FlexLayoutModule, typeof i11.MaterialModule, typeof i12.CloseButtonModule, typeof i12.InlineMessageModule, typeof i13.VendorDisclaimerModule], [typeof i1.TldTranslateFileComponent, typeof i2.TldTranslateFileMultipleComponent, typeof i3.TldTranslateFileDownloadButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TldDocumentModule>;
+}

package/lib/modules/tld-document/tld-file-translate-base.component.d.ts

@@ -0,0 +1,29 @@
+import { OnDestroy } from '@angular/core';
+import { MatButton } from '@angular/material/button';
+import { MatDialog } from '@angular/material/dialog';
+import { TldTranslateConfigService } from '../tld-common/services';
+import { TldTranslateFileService } from './services/tld-translate-file.service';
+import { FileConversionTypes } from './models/file-conversion-types.model';
+import { TranslationStatuss } from './models/translation-statuss.model';
+import * as i0 from "@angular/core";
+export declare class TldFileTranslateBaseComponent implements OnDestroy {
+    protected readonly dialog: MatDialog;
+    protected readonly config: TldTranslateConfigService;
+    protected readonly fileService: TldTranslateFileService;
+    constructor(dialog: MatDialog, config: TldTranslateConfigService, fileService: TldTranslateFileService);
+    pdfConversionButton: MatButton;
+    imageConversionButton: MatButton;
+    readonly pdfConversion = FileConversionTypes.PDF;
+    readonly imageConversion = FileConversionTypes.IMAGE;
+    get sourceDownloadPDF(): boolean;
+    get sourceDownloadImage(): boolean;
+    readonly translatingStatuss = TranslationStatuss.TRANSLATING;
+    readonly errorTranslatingStatuss = TranslationStatuss.ERROR;
+    readonly completedTranslatingStatuss = TranslationStatuss.COMPLETED;
+    readonly uploadedTranslatingStatuss = TranslationStatuss.UPLOADED;
+    conversionDialog(type: FileConversionTypes): void;
+    clearAll(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldFileTranslateBaseComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TldFileTranslateBaseComponent, "ng-component", never, {}, {}, never, never, false>;
+}

package/lib/modules/tld-document/tld-translate-file-multiple/tld-translate-file-multiple.component.d.ts

@@ -0,0 +1,40 @@
+import { OnInit } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { TldTranslateButtonService } from '../../tld-common/components/translate-button/tld-translate-button.service';
+import { IFileMeta, IFileUploadError } from '../../tld-common/models';
+import { TldTranslateConfigService } from '../../tld-common/services';
+import { TldSystemService } from '../../tld-tooltip/services';
+import { ITranslationFile } from '../models/translate-file.model';
+import { TldTranslateFileService } from '../services/tld-translate-file.service';
+import { TldFileTranslateBaseComponent } from '../tld-file-translate-base.component';
+import * as i0 from "@angular/core";
+export declare class TldTranslateFileMultipleComponent extends TldFileTranslateBaseComponent implements OnInit {
+    protected readonly fileService: TldTranslateFileService;
+    protected readonly config: TldTranslateConfigService;
+    protected readonly dialog: MatDialog;
+    protected readonly translateButtonService: TldTranslateButtonService;
+    private systemService;
+    constructor(fileService: TldTranslateFileService, config: TldTranslateConfigService, dialog: MatDialog, translateButtonService: TldTranslateButtonService, systemService: TldSystemService);
+    translationFiles: ITranslationFile[];
+    allowedFileTypes: string[];
+    allowedFileTypesAuthUser: string[];
+    maxFileUploadSize: number;
+    multipleFiles: boolean;
+    extendedFileTypes: string[];
+    showVendorNotification: boolean;
+    get translationStarted(): boolean;
+    get disableAppendFiles(): boolean;
+    get isAuth(): boolean;
+    get translatedFilesCount(): number;
+    get maxFileCount(): number;
+    get fileCount(): number;
+    get disableTranslateButton(): boolean;
+    ngOnInit(): void;
+    download(file: ITranslationFile, fileMeta?: IFileMeta): void;
+    fileChange(files: File[]): void;
+    remove(file: ITranslationFile): void;
+    fileUploadError(error: IFileUploadError): void;
+    translateButtonClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldTranslateFileMultipleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TldTranslateFileMultipleComponent, "tld-translate-file-multiple", never, { "translationFiles": "translationFiles"; }, {}, never, never, false>;
+}

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

@@ -0,0 +1,6 @@
+export * from './tld-term.module';
+export * from './tld-term-collection/tld-term-collection.component';
+export * from './tld-term-menu/tld-term-menu.component';
+export * from './tld-term-promotion/tld-term-promotion.component';
+export * from './tld-term-collection-list/tld-term-collection-list.component';
+export * from './tld-term-create-collection-dialog/tld-term-create-collection-dialog.component';

package/lib/modules/tld-term/models/converted-collection-tooltip-key.model.d.ts

@@ -0,0 +1,5 @@
+export declare enum ConvertedCollectionTooltipKey {
+    NO_ENTRIES = "NO_ENTRIES",
+    IMPORTING = "IMPORTING",
+    SYNCING = "SYNCING"
+}

package/lib/modules/tld-term/models/converted-collection-type.model.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Enumerator to determine if collection imported from term api or mt
+ */
+export declare enum ConvertedCollectionType {
+    Term = 0,
+    MT = 1
+}

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

@@ -0,0 +1,6 @@
+export * from './mt-api/tld-mt-term-collection.model';
+export * from './term-api/tld-term-collection.model';
+export * from './term-api/tld-term-collection-languages.model';
+export * from './tld-converted-collection.model';
+export * from './converted-collection-tooltip-key.model';
+export * from './converted-collection-type.model';

package/lib/modules/tld-term/models/mt-api/tld-mt-term-collection.model.d.ts

@@ -0,0 +1,15 @@
+import { MtCollectionStatus } from "../mt-collection-status.model";
+/**
+ * Interface that describes structure returned from GetDetailedTermCorpora
+ */
+export interface ITldMTTermCollection {
+    CorpusId: string;
+    Message: string;
+    Status: MtCollectionStatus;
+    TildeTermId: string;
+    Title: string;
+    Type: string;
+    AttachmentDateTime: string;
+    Count: number;
+    PreparedDateTime: string;
+}

package/lib/modules/tld-term/models/mt-collection-status.model.d.ts

@@ -0,0 +1,5 @@
+export declare enum MtCollectionStatus {
+    READY = "Ready",
+    PROCESSING = "Processing",
+    ERROR = "Error"
+}

package/lib/modules/tld-term/models/term-api/tld-term-collection-languages.model.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Term collection from term portal languages property interface.
+ */
+export interface ITldTermCollectionLanguages {
+    /**
+     * Language code
+     */
+    id: string;
+    count: number;
+    name: string;
+}

package/lib/modules/tld-term/models/term-api/tld-term-collection.model.d.ts

@@ -0,0 +1,46 @@
+import { ITldTermCollectionLanguages } from "./tld-term-collection-languages.model";
+export 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: number;
+    iprEmail: string;
+    iprName: string;
+    iprOrganization: string;
+    iprSurname: string;
+    isImporting: boolean;
+    isPSI: boolean;
+    languages: ITldTermCollectionLanguages[];
+    licence: any;
+    metaNordId: any;
+    modifyDate: string;
+    name: string;
+    originalName: string;
+    originalNameLang: string;
+    ownerGroupGuid: string;
+    permissions: string[];
+    public: boolean;
+    restrictionsOfUse: any;
+    sourceURL: string;
+    targetCollectionId: any;
+    type: string;
+}

package/lib/modules/tld-term/models/tld-converted-collection.model.d.ts

@@ -0,0 +1,43 @@
+import { ITldMTTermCollection, ITldTermCollection } from ".";
+import { ErrorCode } from "../../tld-common/models/errors/error-codes.enum";
+import { ConvertedCollectionTooltipKey } from "./converted-collection-tooltip-key.model";
+import { ConvertedCollectionType } from "./converted-collection-type.model";
+import { MtCollectionStatus } from "./mt-collection-status.model";
+/**
+ * Used to combine term collection interfaces from term api and MT api.
+ */
+export declare class TldConvertedCollection {
+    title: string;
+    id: string;
+    termId: string;
+    /** Entry count for source language from term api */
+    entryCount: number;
+    /** Entry count from MT api */
+    mtEntryCount: number;
+    sourceLanguageCode: string;
+    targetLanguageCode: string;
+    importedFrom: ConvertedCollectionType;
+    mtAttachmentDateTime: Date;
+    termModifiedDate: Date;
+    isSynchronized: boolean;
+    languagesString: string;
+    tooltipKey: ConvertedCollectionTooltipKey;
+    mtStatus: MtCollectionStatus;
+    errorKey: ErrorCode;
+    mtPreparedDateTime: string;
+    get syncButtonVissible(): boolean;
+    get isImporting(): boolean;
+    constructor(obj: ITldTermCollection | ITldMTTermCollection, sourceLanguageCode: string, targetLanguageCode: string);
+    static findExistingCollectionFromList(termCollections: Set<TldConvertedCollection>, collection: TldConvertedCollection): TldConvertedCollection;
+    update(obj: TldConvertedCollection): void;
+    deletedFromTermApi(): void;
+    static convertCollections(collections: ITldMTTermCollection[] | ITldTermCollection[], sourceLanguage: string, targetLanguage: string): TldConvertedCollection[];
+    private fromTermApi;
+    private fromTldMTCollection;
+    private isTldCorpus;
+    /**
+     * Check if the newest version of the term collection is synchronized from Term portal.
+     * Note. Term collections that are not linked from Term portal are considered as synchronized.
+    */
+    private isTermSynchronizedWithMT;
+}

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

@@ -0,0 +1,3 @@
+export * from './tld-term-collections.service';
+export * from './term-api.service';
+export * from './mt-collections-api.service';

package/lib/modules/tld-term/services/mt-collections-api.service.d.ts

@@ -0,0 +1,13 @@
+import { HttpClient } from '@angular/common/http';
+import { TldTranslateConfigService } from '../../tld-common/services';
+import { TldConvertedCollection } from '../models';
+import * as i0 from "@angular/core";
+export declare class MtCollectionsApiService {
+    private readonly http;
+    private readonly config;
+    constructor(http: HttpClient, config: TldTranslateConfigService);
+    attachTermsFromTildeTerm(systemId: string, tildeTermCollectionId: string): import("rxjs").Observable<Object>;
+    loadMTCollections(systemId: string, sourceLanguage: string, targetLanguage: string): import("rxjs").Observable<TldConvertedCollection[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MtCollectionsApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MtCollectionsApiService>;
+}

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

@@ -0,0 +1,15 @@
+import { HttpClient } from '@angular/common/http';
+import { TldTranslateConfigService } from '../../tld-common/services';
+import { ITldTermCollection } from '../models/term-api/tld-term-collection.model';
+import { TldConvertedCollection } from '../models/tld-converted-collection.model';
+import * as i0 from "@angular/core";
+export declare class TermApiService {
+    private readonly config;
+    private readonly http;
+    get url(): string;
+    constructor(config: TldTranslateConfigService, http: HttpClient);
+    createCollection(defaultLanguages: string[], collectionName: string): import("rxjs").Observable<ITldTermCollection>;
+    getCollectionList(sourceLanguageCode: string, targetLanguageCode: string): import("rxjs").Observable<TldConvertedCollection[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TermApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TermApiService>;
+}

package/lib/modules/tld-term/services/tld-term-collections.service.d.ts

@@ -0,0 +1,57 @@
+import { Observable } from 'rxjs';
+import { TldTranslateConfigService } from '../../tld-common/services';
+import { TldSystemService } from '../../tld-tooltip/services';
+import { TldConvertedCollection } from '../models/tld-converted-collection.model';
+import { MtCollectionsApiService } from './mt-collections-api.service';
+import { TermApiService } from './term-api.service';
+import * as i0 from "@angular/core";
+export declare class TldTermCollectionsService {
+    private readonly config;
+    private readonly tldSystem;
+    private readonly termApi;
+    private readonly mtApi;
+    private _selected;
+    get selected(): TldConvertedCollection;
+    set selected(val: TldConvertedCollection);
+    private _collections;
+    get collections(): Set<TldConvertedCollection>;
+    private _isRefreshingCollections;
+    get isRefreshingCollections(): boolean;
+    get canCreateCollections(): boolean;
+    get hasEditPermissions(): boolean;
+    private _hasAnyCollections;
+    get hasAnyCollections(): boolean;
+    get shouldShowPromotion(): boolean;
+    private isAutoRefreshingOn;
+    private sourceLanguageCode;
+    private targetLanguageCode;
+    private activeSystemId;
+    private refreshTimeout;
+    private isAnyImporting;
+    private menuOpened;
+    private readonly LOCAL_STORAGE_KEY;
+    constructor(config: TldTranslateConfigService, tldSystem: TldSystemService, termApi: TermApiService, mtApi: MtCollectionsApiService);
+    onMenuOpen(): void;
+    onMenuClose(): void;
+    addCollectionToSystem(collection: TldConvertedCollection): void;
+    create(defaultLanguages: string[], collectionName: string): Observable<TldConvertedCollection>;
+    refreshCollections(setSelectedFromLocalStorage?: boolean): void;
+    /**
+     *
+     * @returns selected collection id if it is allowed to use collection for translations
+     */
+    selectedIdForTranslation(): string;
+    private startAutoRefresh;
+    private stopAutoRefresh;
+    private scheduleRefresh;
+    /**
+     * Should be called after refresh to check if there is any collections from term api that are deleted.
+     */
+    private removeDeletedFromTerms;
+    private updateCollections;
+    private setSelectedFromLocalStorage;
+    private storeSelectedInLocalStorage;
+    private readLocalStorage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldTermCollectionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TldTermCollectionsService>;
+}

package/lib/modules/tld-term/tld-term-collection/tld-term-collection.component.d.ts

@@ -0,0 +1,9 @@
+import { TldTermCollectionsService } from '../services/tld-term-collections.service';
+import * as i0 from "@angular/core";
+export declare class TldTermCollectionComponent {
+    private readonly terms;
+    get promotion(): boolean;
+    constructor(terms: TldTermCollectionsService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldTermCollectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TldTermCollectionComponent, "tld-term-collection", never, {}, {}, never, never, false>;
+}

package/lib/modules/tld-term/tld-term-collection-list/tld-term-collection-list.component.d.ts

@@ -0,0 +1,39 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { TranslateService } from '@ngx-translate/core';
+import { TldAlertService, TldTranslateConfigService } from '../../tld-common/services';
+import { TldSystemService } from '../../tld-tooltip/services';
+import { MtCollectionStatus } from '../models/mt-collection-status.model';
+import { TldConvertedCollection } from '../models/tld-converted-collection.model';
+import { TldTermCollectionsService } from '../services/tld-term-collections.service';
+import * as i0 from "@angular/core";
+export declare class TldTermCollectionListComponent implements OnInit, OnDestroy {
+    private readonly collectionService;
+    private readonly config;
+    private readonly tldSystem;
+    private readonly dialog;
+    private readonly translate;
+    private readonly alerts;
+    get selected(): TldConvertedCollection;
+    set selected(val: TldConvertedCollection);
+    get collections(): Set<TldConvertedCollection>;
+    get hasAnyCollections(): boolean;
+    get isRefreshingCollections(): boolean;
+    get hasEditPermissions(): boolean;
+    get appName(): string;
+    readonly localizationKey = "TERM_COLLECTIONS.";
+    readonly tooltipLocalizationKey = "TERM_COLLECTIONS.TOOLTIPS.";
+    readonly readyStatus = "Ready";
+    private sourceLanguageCode;
+    private targetLanguageCode;
+    private subscription;
+    readonly collectionErrorStatus = MtCollectionStatus.ERROR;
+    constructor(collectionService: TldTermCollectionsService, config: TldTranslateConfigService, tldSystem: TldSystemService, dialog: MatDialog, translate: TranslateService, alerts: TldAlertService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getEditLink(collection: TldConvertedCollection): string;
+    createNew(): void;
+    attach(collection: TldConvertedCollection): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldTermCollectionListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TldTermCollectionListComponent, "tld-term-collection-list", never, {}, {}, never, never, false>;
+}

package/lib/modules/tld-term/tld-term-create-collection-dialog/tld-term-create-collection-dialog.component.d.ts

@@ -0,0 +1,20 @@
+import { OnInit } from '@angular/core';
+import { UntypedFormControl, UntypedFormGroup } from '@angular/forms';
+import { MatDialogRef } from '@angular/material/dialog';
+import { TldTranslateConfigService } from '../../tld-common/services';
+import { TldTermCollectionListComponent } from '../tld-term-collection-list/tld-term-collection-list.component';
+import * as i0 from "@angular/core";
+export declare class TldTermCreateCollectionDialogComponent implements OnInit {
+    private readonly dialogRef;
+    data: any;
+    private readonly config;
+    formGroup: UntypedFormGroup;
+    collectionName: UntypedFormControl;
+    minLength: number;
+    maxLength: number;
+    constructor(dialogRef: MatDialogRef<TldTermCollectionListComponent>, data: any, config: TldTranslateConfigService);
+    ngOnInit(): void;
+    submit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldTermCreateCollectionDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TldTermCreateCollectionDialogComponent, "tld-term-create-collection-dialog", never, {}, {}, never, never, false>;
+}

package/lib/modules/tld-term/tld-term-menu/tld-term-menu.component.d.ts

@@ -0,0 +1,13 @@
+import { TldConvertedCollection } from '../models';
+import { TldTermCollectionsService } from '../services';
+import * as i0 from "@angular/core";
+export declare class TldTermMenuComponent {
+    private readonly collectionService;
+    get selected(): TldConvertedCollection;
+    set selected(val: TldConvertedCollection);
+    constructor(collectionService: TldTermCollectionsService);
+    menuOpened(): void;
+    menuClosed(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldTermMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TldTermMenuComponent, "tld-term-menu", never, {}, {}, never, never, false>;
+}

package/lib/modules/tld-term/tld-term-promotion/tld-term-promotion.component.d.ts

@@ -0,0 +1,17 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { TldTranslateConfigService } from '../../tld-common/services';
+import { WtwLinkParamsService } from '../../tld-common/services/wtw-link-params.service';
+import * as i0 from "@angular/core";
+export declare class TldTermPromotionComponent implements OnInit, OnDestroy {
+    private readonly config;
+    private readonly wtwQueryService;
+    private readonly destroy$;
+    readonly localizationKey = "TERM_COLLECTIONS.PROMOTION.";
+    trialUrl: string;
+    learnMoreUrl: string;
+    constructor(config: TldTranslateConfigService, wtwQueryService: WtwLinkParamsService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldTermPromotionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TldTermPromotionComponent, "tld-term-promotion", never, {}, {}, never, never, false>;
+}

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

@@ -0,0 +1,22 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./tld-term-collection/tld-term-collection.component";
+import * as i2 from "./tld-term-collection-list/tld-term-collection-list.component";
+import * as i3 from "./tld-term-create-collection-dialog/tld-term-create-collection-dialog.component";
+import * as i4 from "./tld-term-menu/tld-term-menu.component";
+import * as i5 from "./tld-term-promotion/tld-term-promotion.component";
+import * as i6 from "@angular/forms";
+import * as i7 from "@angular/common";
+import * as i8 from "../material.module";
+import * as i9 from "@ngx-translate/core";
+import * as i10 from "@angular/material/menu";
+import * as i11 from "@angular/material/divider";
+import * as i12 from "@angular/material/radio";
+import * as i13 from "@angular/material/progress-spinner";
+import * as i14 from "@angular/material/tooltip";
+import * as i15 from "../tld-common/tld-common.module";
+import * as i16 from "@tilde-nlp/ngx-common";
+export declare class TldTermModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldTermModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TldTermModule, [typeof i1.TldTermCollectionComponent, typeof i2.TldTermCollectionListComponent, typeof i3.TldTermCreateCollectionDialogComponent, typeof i4.TldTermMenuComponent, typeof i5.TldTermPromotionComponent], [typeof i6.FormsModule, typeof i7.CommonModule, typeof i8.MaterialModule, typeof i9.TranslateModule, typeof i10.MatMenuModule, typeof i11.MatDividerModule, typeof i12.MatRadioModule, typeof i13.MatProgressSpinnerModule, typeof i14.MatTooltipModule, typeof i15.TldCommonModule, typeof i6.ReactiveFormsModule, typeof i16.CloseButtonModule], [typeof i4.TldTermMenuComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TldTermModule>;
+}

package/lib/modules/tld-text/components/highlight-tree/highlight-tree.component.d.ts

@@ -0,0 +1,27 @@
+import { EventEmitter } from '@angular/core';
+import { MatMenuTrigger } from '@angular/material/menu';
+import { TldHighlightService } from '../../../tld-common/services';
+import { IGrammarCheckReplacement } from '../../models/grammar-check-replacement.model';
+import { IHighlightTree } from '../../models/highlight-tree.model';
+import * as i0 from "@angular/core";
+export declare class HighlightTreeComponent {
+    private readonly highlightService;
+    tree: IHighlightTree;
+    isSource: boolean;
+    correctionsEnabled: boolean;
+    highlight: boolean;
+    gramCheck: boolean;
+    selectSentence: boolean;
+    onReplace: EventEmitter<IGrammarCheckReplacement>;
+    constructor(highlightService: TldHighlightService);
+    mouseEnter(event: MouseEvent): void;
+    mouseLeave(event: MouseEvent): void;
+    gramCheckMenu(tree: IHighlightTree, menuTrigger?: MatMenuTrigger): void;
+    replace(tree: IHighlightTree, replacement: string): void;
+    parentClick(tree: IHighlightTree): void;
+    isSelectedSentence(tree: IHighlightTree): boolean;
+    private onMouseEvent;
+    private findWordParentSentence;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightTreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HighlightTreeComponent, "tld-highlight-tree", never, { "tree": "tree"; "isSource": "isSource"; "correctionsEnabled": "correctionsEnabled"; "highlight": "highlight"; "gramCheck": "gramCheck"; "selectSentence": "selectSentence"; }, { "onReplace": "onReplace"; }, never, never, false>;
+}