@tilde-nlp/ngx-common 4.0.28 → 5.0.2

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

@@ -1,46 +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: 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;
-}
+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: 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;
+}

package/lib/terminology/models/update-engine-terms-request-params.model.d.ts

@@ -1,4 +1,4 @@
-import { EngineTermCollectionAccessUpdate } from "./engine-term-collection-access-update.model";
-export interface UpdateEngineTermsRequestParams {
-    access: EngineTermCollectionAccessUpdate;
-}
+import { EngineTermCollectionAccessUpdate } from "./engine-term-collection-access-update.model";
+export interface UpdateEngineTermsRequestParams {
+    access: EngineTermCollectionAccessUpdate;
+}

package/lib/terminology/models/vendor.model.d.ts

@@ -1,5 +1,5 @@
-export 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;
-}
+export 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;
+}

package/lib/terminology/services/engine-term-api/engine-term-api.service.d.ts

@@ -1,19 +1,19 @@
-import { HttpClient } from '@angular/common/http';
-import { TerminologyConfigService } from '../../config/services';
-import { AddEngineTermsRequestParams, DefaultCollectionOrderUpdate, EngineTermCollection, EngineTermCollectionList, UpdateEngineTermsRequestParams } from '../../models';
-import { Observable } from 'rxjs';
-import * as i0 from "@angular/core";
-export 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>;
-}
+import { HttpClient } from '@angular/common/http';
+import { TerminologyConfigService } from '../../config/services';
+import { AddEngineTermsRequestParams, DefaultCollectionOrderUpdate, EngineTermCollection, EngineTermCollectionList, UpdateEngineTermsRequestParams } from '../../models';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/lib/terminology/services/engine-term-api/index.d.ts

@@ -1 +1 @@
-export * from './engine-term-api.service';
+export * from './engine-term-api.service';

package/lib/terminology/services/index.d.ts

@@ -1,5 +1,5 @@
-export * from './terminology/terminology.service';
-export * from './engine-term-api/';
-export * from './terminology-collection/';
-export * from './terminology-api-v1/terminology-api-v1.service';
-export * from './terminology-api-v2/terminology-api-v2.service';
+export * from './terminology/terminology.service';
+export * from './engine-term-api/';
+export * from './terminology-collection/';
+export * from './terminology-api-v1/terminology-api-v1.service';
+export * from './terminology-api-v2/terminology-api-v2.service';

package/lib/terminology/services/system-api-v1/system-api-v1.service.d.ts

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

package/lib/terminology/services/system-api-v2/models/engine-deployment.model.d.ts

@@ -1,9 +1,9 @@
-import { Revision } from './revision.model';
-export interface EngineDeployment {
-    imageTag: string;
-    maxScale: number;
-    minScale: number;
-    revisions: Revision[];
-    status: string;
-    statusMessage: string;
-}
+import { Revision } from './revision.model';
+export interface EngineDeployment {
+    imageTag: string;
+    maxScale: number;
+    minScale: number;
+    revisions: Revision[];
+    status: string;
+    statusMessage: string;
+}

package/lib/terminology/services/system-api-v2/models/engine-domain-list.model.d.ts

@@ -1,4 +1,4 @@
-import { EngineDomain } from "./engine-domain.model";
-export interface EngineDomainList {
-    [domain: string]: EngineDomain;
-}
+import { EngineDomain } from "./engine-domain.model";
+export interface EngineDomainList {
+    [domain: string]: EngineDomain;
+}

package/lib/terminology/services/system-api-v2/models/engine-domain.model.d.ts

@@ -1,5 +1,5 @@
-export interface EngineDomain {
-    languages: {
-        [languageKey: string]: string[];
-    };
-}
+export interface EngineDomain {
+    languages: {
+        [languageKey: string]: string[];
+    };
+}

package/lib/terminology/services/system-api-v2/models/engine-list.model.d.ts

@@ -1,4 +1,4 @@
-import { Engine } from "./engine.model";
-export interface EngineList {
-    engines: Engine[];
-}
+import { Engine } from "./engine.model";
+export interface EngineList {
+    engines: Engine[];
+}

package/lib/terminology/services/system-api-v2/models/engine-status.enum.d.ts

@@ -1,9 +1,9 @@
-export declare enum EngineStatus {
-    IMPORTING = "Importing",
-    DELETING = "Deleting",
-    ERROR = "Error",
-    RUNNING = "Running",
-    STARTING = "Starting",
-    STAND_BY = "StandBy",
-    OFF = "Off"
-}
+export declare enum EngineStatus {
+    IMPORTING = "Importing",
+    DELETING = "Deleting",
+    ERROR = "Error",
+    RUNNING = "Running",
+    STARTING = "Starting",
+    STAND_BY = "StandBy",
+    OFF = "Off"
+}

package/lib/terminology/services/system-api-v2/models/engine-sub-status.enum.d.ts

@@ -1,16 +1,16 @@
-export declare enum EngineSubStatus {
-    Unspecified = "Unspecified",
-    Importing = "Importing",
-    ImportingQueuing = "ImportingQueuing",
-    ImportingTerms = "ImportingTerms",
-    ImportingDeploying = "ImportingDeploying",
-    ImportingImported = "ImportingImported",
-    Deleting = "Deleting",
-    DeletingQueuing = "DeletingQueuing",
-    DeletingTerms = "DeletingTerms",
-    ErrorGeneric = "ErrorGeneric",
-    ErrorImportingFailed = "ErrorImportingFailed",
-    ErrorImportingTermsFailed = "ErrorImportingTermsFailed",
-    ErrorDeletingFailed = "ErrorDeletingFailed",
-    ErrorDeletingTermsFailed = "ErrorDeletingTermsFailed"
-}
+export declare enum EngineSubStatus {
+    Unspecified = "Unspecified",
+    Importing = "Importing",
+    ImportingQueuing = "ImportingQueuing",
+    ImportingTerms = "ImportingTerms",
+    ImportingDeploying = "ImportingDeploying",
+    ImportingImported = "ImportingImported",
+    Deleting = "Deleting",
+    DeletingQueuing = "DeletingQueuing",
+    DeletingTerms = "DeletingTerms",
+    ErrorGeneric = "ErrorGeneric",
+    ErrorImportingFailed = "ErrorImportingFailed",
+    ErrorImportingTermsFailed = "ErrorImportingTermsFailed",
+    ErrorDeletingFailed = "ErrorDeletingFailed",
+    ErrorDeletingTermsFailed = "ErrorDeletingTermsFailed"
+}

package/lib/terminology/services/system-api-v2/models/engine.model.d.ts

@@ -1,24 +1,24 @@
-import { EngineDeployment } from "./engine-deployment.model";
-import { EngineDomainList } from "./engine-domain-list.model";
-import { EngineStatus } from "./engine-status.enum";
-import { EngineSubStatus } from "./engine-sub-status.enum";
-import { WorkerStatus } from "./worker-status.model";
-export interface Engine {
-    id: string;
-    name?: string;
-    sourceLanguages: string[];
-    targetLanguages: string[];
-    domain: string;
-    domains: EngineDomainList;
-    status: EngineStatus;
-    subStatus: EngineSubStatus;
-    statusMessage?: string;
-    progress: number;
-    metrics?: WorkerStatus;
-    createdAt: Date;
-    importedAt: Date;
-    updatedAt?: Date;
-    supportsTermCollections: boolean;
-    deployment?: EngineDeployment;
-    vendor: string;
-}
+import { EngineDeployment } from "./engine-deployment.model";
+import { EngineDomainList } from "./engine-domain-list.model";
+import { EngineStatus } from "./engine-status.enum";
+import { EngineSubStatus } from "./engine-sub-status.enum";
+import { WorkerStatus } from "./worker-status.model";
+export interface Engine {
+    id: string;
+    name?: string;
+    sourceLanguages: string[];
+    targetLanguages: string[];
+    domain: string;
+    domains: EngineDomainList;
+    status: EngineStatus;
+    subStatus: EngineSubStatus;
+    statusMessage?: string;
+    progress: number;
+    metrics?: WorkerStatus;
+    createdAt: Date;
+    importedAt: Date;
+    updatedAt?: Date;
+    supportsTermCollections: boolean;
+    deployment?: EngineDeployment;
+    vendor: string;
+}

package/lib/terminology/services/system-api-v2/models/index.d.ts

@@ -1,8 +1,8 @@
-export * from './engine-deployment.model';
-export * from './engine-domain-list.model';
-export * from './engine-domain.model';
-export * from './engine-status.enum';
-export * from './engine-sub-status.enum';
-export * from './engine.model';
-export * from './revision.model';
-export * from './worker-status.model';
+export * from './engine-deployment.model';
+export * from './engine-domain-list.model';
+export * from './engine-domain.model';
+export * from './engine-status.enum';
+export * from './engine-sub-status.enum';
+export * from './engine.model';
+export * from './revision.model';
+export * from './worker-status.model';

package/lib/terminology/services/system-api-v2/models/revision.model.d.ts

@@ -1,9 +1,9 @@
-export interface Revision {
-    version: number;
-    running: number;
-    starting: number;
-    terminating: number;
-    error: number;
-    standBy?: number;
-    disabled?: number;
-}
+export interface Revision {
+    version: number;
+    running: number;
+    starting: number;
+    terminating: number;
+    error: number;
+    standBy?: number;
+    disabled?: number;
+}

package/lib/terminology/services/system-api-v2/models/worker-status.model.d.ts

@@ -1,12 +1,12 @@
-export interface WorkerStatus {
-    revisions: {
-        [propName: string]: {
-            actualPods: number;
-            notReadyPods: number;
-            panicMode: boolean;
-            pendingPods: number;
-            requestedPods: number;
-            terminatingPods: number;
-        };
-    };
-}
+export interface WorkerStatus {
+    revisions: {
+        [propName: string]: {
+            actualPods: number;
+            notReadyPods: number;
+            panicMode: boolean;
+            pendingPods: number;
+            requestedPods: number;
+            terminatingPods: number;
+        };
+    };
+}

package/lib/terminology/services/system-api-v2/system-api-v2.service.d.ts

@@ -1,16 +1,16 @@
-import { HttpClient } from "@angular/common/http";
-import { Observable } from "rxjs";
-import { TerminologyConfigService } from "../../config/services";
-import { System } from "../../models/system.model";
-import * as i0 from "@angular/core";
-export declare class SystemApiV2Service {
-    private readonly http;
-    private readonly config;
-    constructor(http: HttpClient, config: TerminologyConfigService);
-    getSystemList(): Observable<System[]>;
-    private generateSystemsFromLanguages;
-    private generateSystemsFromDomains;
-    private createSystemObject;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SystemApiV2Service, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SystemApiV2Service>;
-}
+import { HttpClient } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { TerminologyConfigService } from "../../config/services";
+import { System } from "../../models/system.model";
+import * as i0 from "@angular/core";
+export declare class SystemApiV2Service {
+    private readonly http;
+    private readonly config;
+    constructor(http: HttpClient, config: TerminologyConfigService);
+    getSystemList(): Observable<System[]>;
+    private generateSystemsFromLanguages;
+    private generateSystemsFromDomains;
+    private createSystemObject;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SystemApiV2Service, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SystemApiV2Service>;
+}

package/lib/terminology/services/terminology/terminology.service.d.ts

@@ -1,61 +1,61 @@
-import { Observable } from 'rxjs';
-import { CombinedCollection, IMtTermService } from '../../models';
-import { TerminologyConfigService } from '../../config/services';
-import { TerminologyCollectionService } from '../terminology-collection/terminology-collection.service';
-import { AlertService } from '../../../services';
-import { TerminologyEngine } from '../../models/terminology-engine.model';
-import * as i0 from "@angular/core";
-export 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;
-    private readonly LOCAL_STORAGE_KEY;
-    get hasEditPermissions(): boolean | undefined;
-    constructor(config: TerminologyConfigService, alert: AlertService, termCollectionApi: TerminologyCollectionService, mtApi: IMtTermService);
-    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>;
-}
+import { Observable } from 'rxjs';
+import { CombinedCollection, IMtTermService } from '../../models';
+import { TerminologyConfigService } from '../../config/services';
+import { TerminologyCollectionService } from '../terminology-collection/terminology-collection.service';
+import { AlertService } from '../../../services';
+import { TerminologyEngine } from '../../models/terminology-engine.model';
+import * as i0 from "@angular/core";
+export 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;
+    private readonly LOCAL_STORAGE_KEY;
+    get hasEditPermissions(): boolean | undefined;
+    constructor(config: TerminologyConfigService, alert: AlertService, termCollectionApi: TerminologyCollectionService, mtApi: IMtTermService);
+    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>;
+}

package/lib/terminology/services/terminology-api-v1/terminology-api-v1.service.d.ts

@@ -1,17 +1,17 @@
-import { HttpClient } from "@angular/common/http";
-import { TerminologyConfigService } from "../../config/services";
-import { CombinedCollection, IMtTermService } from "../../models";
-import { Observable } from "rxjs";
-import * as i0 from "@angular/core";
-export declare class TerminologyApiV1Service implements IMtTermService {
-    private readonly http;
-    private readonly config;
-    constructor(http: HttpClient, config: TerminologyConfigService);
-    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<TerminologyApiV1Service, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<TerminologyApiV1Service>;
-}
+import { HttpClient } from "@angular/common/http";
+import { TerminologyConfigService } from "../../config/services";
+import { CombinedCollection, IMtTermService } from "../../models";
+import { Observable } from "rxjs";
+import * as i0 from "@angular/core";
+export declare class TerminologyApiV1Service implements IMtTermService {
+    private readonly http;
+    private readonly config;
+    constructor(http: HttpClient, config: TerminologyConfigService);
+    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<TerminologyApiV1Service, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TerminologyApiV1Service>;
+}